JAVA反射原理

什么是反射？

反射，一种计算机处理方式。是程序可以访问、检测和修改它本身状态或行为的一种能力。java反射使得我们可以在程序运行时动态加载一个类，动态获取类的基本信息和定义的方法,构造函数,域等。除了检阅类信息外，还可以动态创建类的实例，执行类实例的方法，获取类实例的域值。反射使java这种静态语言有了动态的特性。

类的加载

java反射机制是围绕Class类展开的，在深入java反射原理之前，需要对类加载机制有一个大致的了解。jvm使用ClassLoader将字节码文件(class文件）加载到方法区内存中：

Class clazz = ClassLoader.getSystemClassLoader().loadClass("com.mypackage.MyClass");

可见ClassLoader根据类的完全限定名加载类并返回了一个Class对象，而java反射的所有起源都是从这个class类开始的。

ReflectionData

为了提高反射的性能，缓存显然是必须的。class类内部有一个useCaches静态变量来标记是否使用缓存，这个值可以通过外部配置项sun.reflect.noCaches进行开关。class类内部提供了一个ReflectionData内部类用来存放反射数据的缓存，并声明了一个reflectionData域，由于稍后进行按需延迟加载并缓存，所以这个域并没有指向一个实例化的ReflectionData对象。

    //标记是否使用缓存，可以通过外部配置项sun.reflect.noCaches进行禁用。
    private static boolean useCaches = true;

    static class ReflectionData<T> {
        volatile Field[] declaredFields;
        volatile Field[] publicFields;
        volatile Method[] declaredMethods;
        volatile Method[] publicMethods;
        volatile Constructor<T>[] declaredConstructors;
        volatile Constructor<T>[] publicConstructors;
        volatile Field[] declaredPublicFields;
        volatile Method[] declaredPublicMethods;
        final int redefinedCount;

        ReflectionData(int redefinedCount) {
            this.redefinedCount = redefinedCount;
        }
    }

    //注意这是个SoftReference，在内存资源紧张的时候可能会被回收。volatile保证多线程环境下的读写的正确性
    private volatile transient SoftReference<ReflectionData<T>> reflectionData;
    //J主要用于和ReflectionData中的redefinedCount进行比较，如果两个值不相等，说明ReflectionData缓存的数据已经过期了。
    private volatile transient int classRedefinedCount = 0;

获取类的构造函数

在获取一个类的class后，我们可以通过反射获取一个类的所有构造函数，class类内部封装了如下方法用于提取构造函数：

    //publicOnly指示是否只获取public的构造函数，我们常用的getConstructors方法是只返回public的构造函数，而getDeclaredConstructors返回的是所有构造函数,由于java的构造函数不会继承，所以这里不包含父类的构造函数。
    private Constructor<T>[] privateGetDeclaredConstructors(boolean publicOnly) {
        checkInitted(); //主要是读取了sun.reflect.noCaches配置。
        Constructor<T>[] res;
        ReflectionData<T> rd = reflectionData();//这里缓存中读取reflectionData，如果还没有缓存，则创建一个reflectionData并设置到缓存。但是注意这个ReflectionData可能只是个空对象，里面并没有任何数据。
        if (rd != null) {
            res = publicOnly ? rd.publicConstructors : rd.declaredConstructors;
            if (res != null) return res;//检查缓存中是否有数据
        }
        //没有缓存数据可用，从这里开始需要从jvm中去获取数据。
        if (isInterface()) {
            res = new Constructor[0];//接口没有构造函数
        } else {
            res = getDeclaredConstructors0(publicOnly);//native方法，从jvm中获取
        }
        //如果代码执行到了这里，说明需要更新缓存了，将之前从jvm中请求到的数据放置到缓存中。
        if (rd != null) {
            if (publicOnly) {
                rd.publicConstructors = res;
            } else {
                rd.declaredConstructors = res;
            }
        }
        return res;
    }

上面的代码片段比较简单，主要就是读取配置，检查缓存中是否有有效数据，如果有，直接从缓存中返回，如果没有，调用native的方法从jvm中请求数据，然后设置到缓存。比较重要的是reflectionData()这个调用。这个方法主要是用于延迟创建并缓存ReflectionData对象，注意是对象，里面并没有保存反射数据，这些数据只有在第一次执行相应的反射操作后才会被填充。下面是这个方法的实现代码：

    private ReflectionData<T> reflectionData() {
        SoftReference<ReflectionData<T>> reflectionData = this.reflectionData;
        int classRedefinedCount = this.classRedefinedCount;
        ReflectionData<T> rd;
        //检查缓存是否有效，如果有效，从缓存中直接返回reflectionData。
        if (useCaches &&
                reflectionData != null &&
                (rd = reflectionData.get()) != null &&
                rd.redefinedCount == classRedefinedCount) {
            return rd;
        }
        //无法使用到缓存，创建新的reflectionData
        return newReflectionData(reflectionData, classRedefinedCount);
    }

下面看一下newReflectionData()的实现：

    private ReflectionData<T> newReflectionData(SoftReference<ReflectionData<T>> oldReflectionData,int classRedefinedCount) {
        if (!useCaches) return null;
        //这里使用while-cas模式更新reflectionData，主要是考虑多线程并发更新的问题，可能有另外一个线程已经更新了reflectionData，并且设置了有效的缓存数据，如果这里再次更新就把缓存数据覆盖了。
        while (true) {
            ReflectionData<T> rd = new ReflectionData<>(classRedefinedCount);
            if (Atomic.casReflectionData(this, oldReflectionData, new SoftReference<>(rd))) {
                return rd;//cas成功，那么我们swap的这个新对象是有效的。
            }
            //重新读取oldReflectionData，为下次重试cas做准备。
            oldReflectionData = this.reflectionData;
            classRedefinedCount = this.classRedefinedCount;
            //先判断这个oldReflectionData是否有效。如果是无效的数据，需要去重试cas一个新的ReflectionData了。
            if (oldReflectionData != null &&
                    (rd = oldReflectionData.get()) != null &&
                    rd.redefinedCount == classRedefinedCount) {
                return rd;//reflectionData中已经是有效的缓存数据了，直接返回这个reflectionData
            }
        }
    }

上面的几个代码片段是反射获取一个类的构造函数的主要方法调用。主要流程就是先从class内部的reflectionData缓存中读取数据，如果没有缓存数据，那么就从jvm中去请求数据，然后设置到缓存中，供下次使用。

执行构造函数

在通过反射获取到一个类的构造函数我们，一般我们会试图通过构造函数去实例化声明这个构造函数的类，如下：

MyClass myClass = (MyClass) constructor.newInstance();

下面来看看这个newInstance()到底发生了什么:

    public T newInstance(Object... initargs)
            throws InstantiationException, IllegalAccessException,
            IllegalArgumentException, InvocationTargetException {
        //首先判断语言级别的访问检查是否被覆盖了（通过setAccess(true)方法可以将private的成员变成public），如果没有被覆盖，需要进行访问权限检查。
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, null, modifiers);
            }
        }
        //枚举无法通过反射创建实例
        if ((clazz.getModifiers() & Modifier.ENUM) != 0)
            throw new IllegalArgumentException("Cannot reflectively create enum objects");
        //创建ConstructorAccessor对象，并进行缓存
        ConstructorAccessor ca = constructorAccessor;
        if (ca == null) {
            ca = acquireConstructorAccessor();
        }
    //通过ConstructorAccessor来执行newInstance
        return (T) ca.newInstance(initargs);
    }

上面代码主要就是做权限检查，如果权限通过，则通过执行acquireConstructorAccessor()获取一个ConstructorAccessor来真正执行newInstance，acquireConstructorAccessor()这个方法实现比较简单，真正工作的是ReflectionFactory.newConstructorAccessor()，这个方法的主要工作就是为一个Constructor动态生成针对ConstructorAccessor接口的实现ConstructorAccessorImpl，下面来看一下这个方法实现：

    public ConstructorAccessor newConstructorAccessor(Constructor c) {
        checkInitted();
        Class declaringClass = c.getDeclaringClass();
        //如果声明这个构造函数的类部是抽象类，则返回一个InstantiationExceptionConstructorAccessorImpl，这其实也是个ConstructorAccessor，只是它对newInstace的实现是直接抛出一个InstantiationException异常
        if (Modifier.isAbstract(declaringClass.getModifiers())) {
            return new InstantiationExceptionConstructorAccessorImpl(null);
        }
        //如果是Class，同上
        if (declaringClass == Class.class) {
            return new InstantiationExceptionConstructorAccessorImpl
                    ("Can not instantiate java.lang.Class");
        }
        //如果是ConstructorAccessorImpl子类，这里会造成无限循环，所以直接通过native方式实例化这个类
        if (Reflection.isSubclassOf(declaringClass,
                ConstructorAccessorImpl.class)) {
            return new BootstrapConstructorAccessorImpl(c);
        }
        //判断是否启用了Inflation机制，默认是启用了。
        //如果没有启用Inflation机制，那么通过asm操作字节码的方式来生成一个ConstructorAccessorImpl类。
        //如果启用了，那么在执行inflationThreshold（默认15次）次数之前，是通过navite调用来执行newInstance，超过这个次数之后，才会通过asm来生成类。
        //Inflation机制主要是在执行时间和启动时间上做一个平衡，native方式执行慢但是第一次执行不耗费任何时间，asm生成代码的方式执行快（20倍），但是第一次生成需要耗费大量的时间。
        //可以通过sun.reflect.noInflation和sun.reflect.inflationThreshold配置型来进行动态配置
        if (noInflation) {
            return new MethodAccessorGenerator().
                    generateConstructor(c.getDeclaringClass(),
                            c.getParameterTypes(),
                            c.getExceptionTypes(),
                            c.getModifiers());
        } else {
            NativeConstructorAccessorImpl acc =
                    new NativeConstructorAccessorImpl(c);
            DelegatingConstructorAccessorImpl res =
                    new DelegatingConstructorAccessorImpl(acc);
            acc.setParent(res);
            return res;
        }
    }

由上面代码可见，在生成ConstructorAccessorImpl的操作上，一共提供多种版本的实现：直接抛出异常的实现，native执行的实现，asm生成代码的实现。native的实现比较简单，asm 版本的主要就是字节码操作了，比较复杂，暂时不做深入了。