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 版本的主要就是字節碼操作了，比較複雜，暫時不做深入了。