破晓的知识屋
0%

Java反射

发表于 更新于 分类于 ， ， 阅读次数： Valine：
本文字数： 5.6k 阅读时长 ≈ 5 分钟

[toc]

反射#

Q： 调用类对象.class 和 forName(类名)的区别？#

1
Class<A> classA = A.class;
1
Class<A> classA = Class.forName("A");

A： 仅使用.class不能进行第一次静态初始化， forname函数则可以

例如B是A的基类,下面这段代码如何？
假设有父子2个类，如下：

1
2
3
static class Parent { }

static class Son extends Parent{}

Q： 用instanceof 可以和父类比较吗，且会返回true吗？#

1
2
3
4
Son son = new Son();
if (son instanceof  Parent) {
    System.out.println("a instanof B");
}

A： 可以比较，且返回true。

Q： 用getClass并用== 可以和父类比较吗，且会返回true吗#

比如下面这样， 注意A是B的子类。

1
2
3
4
Son son = new Son();
if (son.getClass() == Parent.class){
    System.out.println("son class == Parent.class");
}

A： 不可以，编译就会报错了。和Class<泛型>的 ==号比较有关。
image.png

因为getClass返回的是<? extends Son>， .class返回的是Class<Parent>

Q： 用getClass并用.equals可以和父类比较吗，且会返回true吗，下面这样：#

1
2
3
4
    Son son = new Son();
if (son.getClass().equals(Parent.class)){
    System.out.println("son class.equals(Parent.class)");
}

A： 可以比较，正常编译， 但是会返回false，即不相等！

Q： getDeclaredXXX 有哪几种？#

A： 5种：

  • 注解Annotation
  • 内部类Classed
  • 构造方法Construcotor
  • 字段Field
  • 方法Method
    image.png

Q：getMethods()返回哪些方法， getDeclaredMethods()会返回哪些方法？#

A：
getMethods()返回 本类、父类、父接口 的public方法
getDeclaredMethods()只 返回本类的 所有 方法

其他getXXX和getDeclaredXXX的区别同理。

拿到Filed、Method、Constructor之后咋用

  • Method可以invoke（object， args）
  • Constructor可以newInstance(Object…)来做构造调用。
  • Filed可以用get(object)、set(object)来设置属性值。

Q： 反射拿到Method对象后， 该对象.getModifiers() 是干嘛的？#

A： 返回该方法的修饰符，并且是1个整数。
image.png

Q：下面这样对一个无默认构造的类执行newInstance会发生什么？#

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.huawei.test

public class A {
    public A(int i ) {
        System.out.printf("i=" +i);
    }

    public static void main(String[] args) {
        try {
            A a = (A)Class.forName("com.huawei.test.A").newInstance();
        } catch (ClassNotFoundException e) {
            System.out.printf("ClassNotFoundException");
        } catch (InstantiationException e) {
            System.out.printf("InstantiationException");
        } catch (IllegalAccessException e) {
            System.out.printf("IllegalAccessException");
        }
    }
}

A:
打印InstantiationException初始化错误。
因为A没有默认构造器了，所以不可以用newInstance来构造。
应该改成这样,通过获取正确的构造器来进行构造。

1
A a = (A)Class.forName("A").getConstructor(int.class).newInstance(123);

Q：如何提高反射的效率？#

A：

  • 使用高性能反射包，例如ReflectASM
  • 缓存反射的对象，避免每次都要重复去字节码中获取。（缓存！缓存！）
  • method反射可设置method.setAccessible(true)来关闭安全检查。
  • 尽量不要getMethods()后再遍历筛选，而直接用getMethod(methodName)来根据方法名获取方法
  • 利用hotspot虚拟机中的反射优化技术（jit技术）
    参考资料：
    https://segmentfault.com/q/1010000003004720
    https://www.cnblogs.com/coding-night/p/10772631.html

Q：用反射获取到的method对象， 是返回一个method引用，还是返回1个拷贝的method对象？#

A：
反射拿method对象时， 会做一次拷贝，而不是直接返回引用，因此最好对频繁使用的同一个method做缓存，而不是每次都去查找。
image.png

Q:getMethods()后自己做遍历获取方法和getMethod(methodName) 直接获取方法， 为什么性能会有差异？#

A：
getMethods() 返回method数组时，每个method都做了一次拷贝。
getMethod(methodName)只会返回那个方法的拷贝， 性能的差异就体现在拷贝上。
image.png

Q:获取方法时，jvm内部其实有缓存，但是返回给外部时依然会做拷贝。那么该method的缓存是持久存在的吗？#

A:
不是持久存在的，内存不足时会被回收。
源码如下：
image.png

1
2
3
4
5
6
7
private Class.ReflectionData<T> reflectionData() {
    SoftReference<Class.ReflectionData<T>> reflectionData = this.reflectionData;
    int classRedefinedCount = this.classRedefinedCount;
    Class.ReflectionData rd;
    return reflectionData != null && (rd = (Class.ReflectionData)reflectionData.get()) != null
    && rd.redefinedCount == classRedefinedCount ? rd : this.newReflectionData(reflectionData,     classRedefinedCount);
}

image.png

可以看到这是一个软引用。
软引用的定义：
内存紧张时可能会被回收，不过也可以通过-XX:SoftRefLRUPolicyMSPerMB参数控制回收的时机，
只要发生GC就会将其回收
如果reflectionData被回收之后，又执行了反射方法，那只能通过newReflectionData方法重新创建一个这样的对象了

Q： 反射是线程安全的吗?#

A:
是线程安全的。 获取反射的数据时，通过cas去获取。 cas概念可以见多线程一节。
image.png

Q: 反射的具体性能差异在哪？#

a普通方法调用
b反射方法调用
c关闭安全检查的反射方法调用，性能差异如下：
image.png

b反射方法调用和c关闭安全检查的反射方法调用的性能差异在哪？
普通方法调用和关闭安全检查的反射方法调用的性能差异在哪？
A:

  • 安全检查的性能消耗在于
    ，SecurityManager.checkPermission(SecurityConstants.CHECK_MEMBER_ACCESS_PERMISSION); 这项检测需要运行时申请 RuntimePermission(“accessDeclaredMembers”)。
    所以如果不考虑安全检查， 对反射方法调用invoke时， 应当设置 Method#setAccessible(true)

  • 普通方法和反射方法的性能差异在于

  1. Method#invoke 方法会对参数做封装和解封操作
  2. 需要检查方法可见性
  3. 需要校验参数
  4. 反射方法难以内联
  5. JIT 无法优化

Q: 为什么反射没法做JIT优化呢？#

A:
我们都知道 Java 代码是需要编译才能在虚拟机里运行的，但其实 Java 的编译期是一段不确定的操作过程。因为它可能是一个前端编译器（如 Javac）把 *.java 文件编译成 *.class 文件的过程；也可能是程序运行期的即时编译器（JIT 编译器，Just In Time Compiler）把字节码文件编译成机器码的过程；还可能是静态提前编译器（AOT 编译器，Ahead Of Time Compiler）直接把 *.java 文件编译成本地机器码的过程。
其中即时编译器（JIT）在运行期的优化过程对于程序运行来说更重要，Java虚拟机在编译阶段的代码优化就在这里进行，
由于反射涉及动态解析的类型，因此无法执行某些Java虚拟机优化。因此，反射操作的性能要比非反射操作慢，因此应该避免在对性能敏感的应用程序中频繁使用Java反射来创建对象

动态代理#

Q: 讲一下动态代理的作用 以及他和静态代理的区别#

A:

  • 作用

    先弄一个原始接口类Info，里面提供一些接口例如dealInfo()、getInfo()之类的

    然后可以有N个实现了这个接口的各种Info子类。

    我们希望这些Info字类做dealInfo的时候， 都能在调用前后打一下日志。

    但不希望每个子类里强制都添加这个过程。

    所以引入一个代理Proxy， 将Info类放进去代理种执行，无论你放什么info子类进去，调用dealInfo时，都会在调用前后打印日志。

  • 和静态代理的区别：

    静态代理也是给代理传1个对象，然后执行方法时，执行代理对象的方法

    但是有个执行问题：

    如果我们的类需要加100个方法，那么我们在代理中也要加100个方法，里面反复写“啊，我要调用代理对象的方法”， 这太蠢了

    所以引入动态代理， 这样代理和所代理类之间实现了解耦， 没有必要每次改实类时，也要改代理的内容，重复加方法之类的。

    动态代理可以直接根据method去调用，并且还能弄一个自己独有的处理。

Q: 讲一下动态代理怎么用的？#

A:
代理Proxy类必须implements InvocationHandler
要有一个代理成员，在构造器中去传参数绑定这个代理成员
并实现Object invoke(Object object, Method method, Object[] args)
在invoke方法中调用method.invoke(subject, args)
然后真正执行时，
接口Info = （Info）Proxy.newProxyInstance（代理类对象.getClass().getClassLoader()，实际对象.handler.getInterfaces(), 代理类对象.）
那么当我们执行Info类的某些函数时，就是通过代理去执行了。
d190cf550b2ccb10577825cf86f8d3b2a24b99e2

Q: java动态代理的底层实现原理？#

A:
我们可以对InvocationHandler看做一个中介类，中介类持有一个被代理对象
在invoke方法中调用了被代理对象的相应方法。
通过聚合方式持有被代理对象的引用，把外部对invoke的调用最终都转为对被代理对象的调用。
代理类调用自己方法时，通过自身持有的中介类对象来调用中介类对象的invoke方法
从而达到代理执行被代理对象的方法。
也就是说，动态代理通过中介类实现了具体的代理功能。
d2cee51a51bbbd8be3c5315d2b39b1c664497474