Java 反射详解(76题)

转载请注明链接：https://blog.csdn.net/feather_wch/article/details/81771443

介绍Java的反射机制，包括底层原理、使用场景、性能分析、性能优化、相关API的使用，以及最后的补充面试题。

Java 反射详解(76题)

版本：2018/8/23-1(22:30)

---

基本知识(12题)

反射是什么

1、反射是什么？

1. 反射是Java语言中一个相当重要的特性
2. 反射允许正在运行的Java程序去观测和修改程序的动态行为。
3. 通过java.lang.reflect.*保障的类可以实现反射。

2、Java中识别对象和类信息的两种方法？

传统RTTI(它假定我们在编译时已经知道了所有的类型信息)；反射机制(它允许我们在运行时发现和使用类的信息)

3、RTTI(RunTime Type Information)是什么？

1. 所有的类型信息都必须在编译时已知。
2. 会在所有类第一次使用的时候，将class对象(保存在.class文件)动态加载到JVM。

4、 反射机制实现方法

1. class类和reflect类库对反射进行了支持，通过里面的Field、Method和Constructor等类，能够确定对象信息，而在编译时不需要知道类的任何事情。
2. 但是反射的.class文件在运行的时候也必须是已知的。
3. .class文件可以在本地也可以通过网络获得。

5、 反射和RTTI的本质区别

RTTI：编译器在编译时打开和检查.class文件
反射：运行时打开和检查.class文件

6、JVM加载对象的方法

类的信息会存在方法区，类加载器会通过方法区的类信息，在堆Heap上创建一个类对象(Class对象)，这个类对象是唯一的，后续的New等操作都是通过这个唯一的类对象作为模板去进行new等操作。

7、反射的特点

1. 允许程序在运行时取得任何一个已知名称的class的内部信息，包括包括其modifiers(修饰符)，fields(属性)，methods(方法)等，并可于运行时改变fields内容或调用methods。
2. 可以更灵活的编写代码，代码可以在运行时装配，无需在组件之间进行源代码链接，降低代码的耦合度
3. 反射使用不当会造成很高的资源消耗！

使用场景

8、通过Class对象可以枚举该类中的所有方法

9、通过Method.Accessible绕过Java语言的访问权限

1. 能在私有方法所在类之外的地方调用该方法
2. 该类位于java.lang.reflect包，该方法继承自AccessibleObject

10、IDE中输入点号能动态展示方法和字段就是利用反射

11、Java调试器能够在调试过程中枚举某一对象所有字段的值。

12、web开发中，用于提升框架的可拓展性。

1. 借助Java的反射机制，根据配置来加载不同的类。
2. Spring框架的依赖反转(IOC), 就是依赖于反射。

反射机制(29题)

1、Method

1. 继承自抽象类Executable，需要实现其9个方法

public final class Method extends Executable {
   
    @Override
    public Class<?> getDeclaringClass()  {...}
    @Override
    public String getName()  {...}
    @Override
    public int getModifiers()  {...}
    @Override
    public TypeVariable<?>[] getTypeParameters()  {...}
    @Override
    public Class<?>[] getParameterTypes()  {...}
    @Override
    public Class<?>[] getExceptionTypes()  {...}
    @Override
    public String toGenericString() {...}
    @Override
    public Annotation[][] getParameterAnnotations() {...}
    @Override
    public AnnotatedType getAnnotatedReturnType() {...}
}

2、Method的invoke方法

// Method.java---调用method方法
public Object invoke(Object obj, Object... args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException
{
    // 1、权限检查，调用祖父类AccessibleObject的checkAccess检查权限
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, obj, modifiers);
        }
    }
    /**=========================================
     * 2、 会委派给MethodAccessor来处理
     *  MethodAccessor是一个接口，具有两个具体实现：
     *   1. 通过本地方法来实现反射调用
     *   2. 使用委派模式来实现反射调用
     *========================================*/
    MethodAccessor ma = methodAccessor;             // read volatile
    if (ma == null) {
        // 获取到MethodAccessor
        ma = acquireMethodAccessor();
    }
    // MA调用invoke方法
    return ma.invoke(obj, args);
}

// Method.java-获取到MethodAccessor
private MethodAccessor acquireMethodAccessor() {
    // 1、检查是否已经创建了MethodAccessor
    MethodAccessor tmp = null;
    if (root != null) tmp = root.getMethodAccessor();
    if (tmp != null) {
        // 2、已经存在就直接返回
        methodAccessor = tmp;
    } else {
        // 3、不存在MethodAccessor，制造一个并且使其连接到root上
        tmp = reflectionFactory.newMethodAccessor(this);
        setMethodAccessor(tmp);
    }
    // 4、返回MA
    return tmp;
}

本地实现

3、本地方法实现反射调用的原理？

1. 当进入到Java虚拟机内部之后，就拥有了Method实例所指向方法的具体地址
2. 此时反射就是准备好参数，然后进入目标方法。
3. 本质是Java层切换到C++层，再切换到Java层去调用该方法。(根据如下打印的调用栈，可以看出)

// 1、Java层
at java.lang.reflect.Method.invoke(Method.java:483)

// 2、C++层Native方法
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

// 3、Java层：target方法
at Main.target(Main.java:19)

4、反射调用的轨迹

实例：

public class Main {
   
    // 1、需要反射的方法
    public static void target(int i){
     // 2、打印出轨迹
        new Exception("#" + i).printStackTrace();
    }

    public static void main(String[] args) {
         // 3、反射方法并且调用
            Class c = Class.forName("Main");
            Method method = c.getMethod("target", int.class);
            method