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 版本的主要就是字节码操作了,比较复杂,暂时不做深入了。

posted @ 2017-06-01 23:59  meiyoumingcheng  阅读(14057)  评论(2编辑  收藏