JAVA反射機制詳解

何為反射？

反射(Reflection)，是指Java程式具有在執行期分析類以及修改其本身狀態或行為的能力。
通俗點說 就是 通過反射我們可以動態地獲取一個類的所有屬性和方法，還可以操作這些方法和屬性。

範例的建立

一般我們建立一個物件範例Person zhang = new Person();
雖然是簡簡單單一句，但JVM內部的實現過程是複雜的：

1. 將硬碟上指定位置的Person.class檔案載入進記憶體
2. 執行main方法時，在棧記憶體中開闢了main方法的空間（壓棧-進棧），然後在main方法的棧區分配了一個變數zhang。
3. 執行new，在堆記憶體中開闢一個 實體類的 空間，分配了一個記憶體首地址值
4. 呼叫該實體類對應的建構函式，進行初始化（如果沒有建構函式，Java會補上一個預設建構函式）。
5. 將實體類的 首地址賦值給zhang，變數zhang就參照了該實體。（指向了該物件）

其中上圖步驟1 Classloader(類載入器) 將class檔案載入到記憶體中具體分為3個階段：載入、連線、初始化

而又在 載入階段，類載入器會將類對應的.class檔案中的二進位制位元組流讀入到記憶體中，將這個位元組流轉化為方法區的執行時資料結構，然後在堆區建立一個**java.lang.Class 物件**（類相關的資訊），作為對方法區中這些資料的存取入口

詳情可看筆者之前寫過的2篇文章：
https://mp.weixin.qq.com/s/tsbDfyYLqr3ctzwHirQ8UQ
https://mp.weixin.qq.com/s/v91bqRiKDWWgeNl1DIdaDQ

然後再通過類的範例來執操作類的方法和屬性，比如zhang.eat(), zhang.getHeight()等等

如果我們使用反射的話，我們需要拿到該類Person的Class物件，再通過Class物件來操作類的方法和屬性或者建立類的範例

Class personClass = Person.class;//這邊只是舉一個例子，獲取class物件的多種方式，本文後面再慢慢道來
Object person = personClass.newInstance();

我們可以發現 通過new建立類的範例和反射建立類的範例，都繞不開.class檔案 和 Class類的。

.class檔案

首先我們得先了解一下 什麼是.class檔案
舉個簡單的例子，建立一個Person類：

public class Person {
    /**
     * 狀態 or 屬性
     */
    String name;//姓名
    String sex;//性別
    int height;//身高
    int weight;//體重
    
    /**
     * 行為
     */
    public void sleep(){
    	System.out.println(this.name+"--"+ "睡覺");
	}
    public void eat(){
        System.out.println("吃飯");
    }
    public void Dance(){
        System.out.println("跳舞");
    }
}

我們執行javac命令，編譯生成Person.class檔案
然後我們通過vim 16進位制 開啟它

#開啟file檔案
vim Person.class 

#在命令模式下輸入.. 以16進位制顯示
 :%!xxd
 
#在命令模式下輸入.. 切換回預設顯示
:%!xxd -r

不同的作業系統，不同的 CPU 具有不同的指令集，JAVA能做到平臺無關性，依靠的就是 Java 虛擬機器器。
.java原始碼是給人類讀的，而.class位元組碼是給JVM虛擬機器器讀的，計算機只能識別 0 和 1組成的二進位制檔案，所以虛擬機器器就是我們編寫的程式碼和計算機之間的橋樑。
虛擬機器器將我們編寫的 .java 源程式檔案編譯為 位元組碼 格式的 .class 檔案，位元組碼是各種虛擬機器器與所有平臺統一使用的程式儲存格式，class檔案主要用於解決平臺無關性的中間檔案

Person.class檔案 包含Person類的所有資訊

Class類

我們來看下jdk的官方api檔案對其的定義：

Class類的類表示正在執行的Java應用程式中的類和介面。 列舉是一種類，一個註釋是一種介面。 每個陣列也屬於一個反映為類物件的類，該物件由具有相同元素型別和維數的所有陣列共用。
原始Java型別（ boolean ， byte ， char ， short ， int ， long ， float和double ），和關鍵字void也表示為類物件。
類沒有公共建構函式。 相反， 類物件由Java虛擬機器器自動構建，因為載入了類，並且通過呼叫類載入器中的defineClass方法。。

**java 萬物皆是Class類 **
【圖片】
我們來看下Class類的原始碼，原始碼太多了，挑了幾個重點：

public final class Class<T> implements java.io.Serializable,
                              GenericDeclaration,
                              Type,
                              AnnotatedElement {
    private static final int ANNOTATION= 0x00002000;
    private static final int ENUM      = 0x00004000;
    private static final int SYNTHETIC = 0x00001000;

    private static native void registerNatives();
    static {
        registerNatives();
    }

    /*
     * Private constructor. Only the Java Virtual Machine creates Class objects.
     * This constructor is not used and prevents the default constructor being
     * generated.
     */
    private Class(ClassLoader loader) { //私有化的 構造器
        // Initialize final field for classLoader.  The initialization value of non-null
        // prevents future JIT optimizations from assuming this final field is null.
        classLoader = loader;
    }
    ...
    
    // reflection data that might get invalidated when JVM TI RedefineClasses() is called
    private static class ReflectionData<T> {
        volatile Field[] declaredFields;//欄位
        volatile Field[] publicFields;
        volatile Method[] declaredMethods;//方法
        volatile Method[] publicMethods;
        volatile Constructor<T>[] declaredConstructors;//構造器
        volatile Constructor<T>[] publicConstructors;
        // Intermediate results for getFields and getMethods
        volatile Field[] declaredPublicFields;
        volatile Method[] declaredPublicMethods;
        volatile Class<?>[] interfaces;//介面

        // Value of classRedefinedCount when we created this ReflectionData instance
        final int redefinedCount;

        ReflectionData(int redefinedCount) {
            this.redefinedCount = redefinedCount;
        }
    }
      ...
     //註釋資料
     private volatile transient AnnotationData annotationData;

    private AnnotationData annotationData() {
        while (true) { // retry loop
            AnnotationData annotationData = this.annotationData;
            int classRedefinedCount = this.classRedefinedCount;
            if (annotationData != null &&
                annotationData.redefinedCount == classRedefinedCount) {
                return annotationData;
            }
            // null or stale annotationData -> optimistically create new instance
            AnnotationData newAnnotationData = createAnnotationData(classRedefinedCount);
            // try to install it
            if (Atomic.casAnnotationData(this, annotationData, newAnnotationData)) {
                // successfully installed new AnnotationData
                return newAnnotationData;
            }
        }
    } 
    ...
                                  
        
        

我們可以發現Class也是類，是一種特殊的類，將我們定義普通類的共同的部分進行抽象，儲存類的屬性，方法，構造方法，類名、包名、父類別，註解等和類相關的資訊。
Class類的構造方法是private，只有JVM能建立Class範例，我們開發人員 是無法建立Class範例的，JVM在構造Class物件時，需要傳入一個類載入器。
類也是可以用來儲存資料的，Class類就像 普通類的模板 一樣，用來儲存「類所有相關資訊」的類。

我們來繼續看這個利用反射的例子：Class personClass = Person.class;
由於JVM為載入的 Person.class建立了對應的Class範例，並在該範例中儲存了該 Person.class的所有資訊，因此，如果獲取了Class範例（personClass ），我們就可以通過這個Class範例獲取到該範例對應的Person類的所有資訊。

反射的使用

獲取Class範例4種方式

1. 通過物件呼叫 getClass() 方法來獲取

Person p1 = new Person();
Class c1 = p1.getClass();
    

像這種已經建立了物件的，再去進行反射的話，有點多此一舉。
一般是用於傳過來的是Object型別的物件，不知道具體是什麼類，再用這種方式比較靠譜

2. 類名.class

Class c2 = Person.class;

這種需要提前知道匯入類的包，程式效能更高，比較常用，通過此方式獲取 Class 物件，Person類不會進行初始化

3. 通過 Class 物件的 forName() 靜態方法來獲取，最常用的一種方式

Class c3 = Class.forName("com.zj.demotest.domain.Person");

這種只需傳入類的全路徑，Class.forName會進行初始化initialization步驟，即靜態初始化（會初始化類變數，靜態程式碼塊）。

4. 通過類載入器物件的loadClass()方法

public class TestReflection {
    public static void main(String[] args) throws ClassNotFoundException {
        Person p1 = new Person();
        Class c1 = p1.getClass();

        Class c2 = Person.class;

        Class c3 = Class.forName("com.zj.demotest.domain.Person");

        //第4中方式，類載入器
        ClassLoader classLoader = TestReflection.class.getClassLoader();
        Class c4 = classLoader.loadClass("com.zj.demotest.domain.Person");


        System.out.println(c1.equals(c2));
        System.out.println(c2.equals(c3));
        System.out.println(c3.equals(c4));
        System.out.println(c1.equals(c4));
    }
}

loadClass的原始碼：

public Class<?> loadClass(String name) throws ClassNotFoundException {
    return loadClass(name, false);
}

loadClass 傳入的第二個引數是"false",因此它不會對類進行連線這一步驟，根據類的生命週期我們知道，如果一個類沒有進行驗證和準備的話，是無法進行初始化過程的，即不會進行類初始化，靜態程式碼塊和靜態物件也不會得到執行

我們將c1,c2,c3,c4進行 equals 比較

System.out.println(c1.equals(c2));
System.out.println(c2.equals(c3));
System.out.println(c3.equals(c4));
System.out.println(c1.equals(c4));

結果：

true
true
true
true

因為Class範例在JVM中是唯一的，所以，上述方法獲取的Class範例是同一個範例，一個類在 JVM 中只會有一個 Class 範例

Class類常用的API

日常開發的時候，我們一般使用反射是為了 建立類範例（物件）、反射獲取類的屬性和呼叫類的方法

getName()	獲得類的完整名字
getFields()	獲得類的public型別的屬性
getDeclaredFields()	獲得類的所有屬性。包括private 宣告的和繼承類
getMethods()	獲得類的public型別的方法
getDeclaredMethods()	獲得類的所有方法。包括private 宣告的和繼承類
getMethod(String name, Class[] parameterTypes)	獲得類的特定方法，name引數指定方法的名字，parameterTypes 引數指定方法的引數型別。
getConstructors()	獲得類的public型別的構造方法
getConstructor(Class[] parameterTypes)	獲得類的特定構造方法，parameterTypes 引數指定構造方法的引數型別
newInstance()	通過類的不帶引數的構造方法建立這個類的一個物件
getSuperClass()	用於返回表示該 Class 表示的任何類、介面、原始型別或任何 void 型別的超類的Class(即父類別)。
...	...

我們這邊就不全部展開講了，挑幾個重點講解一下

建立物件

1. 呼叫class物件的newInstance()方法

Class c1 = Class.forName("com.zj.demotest.domain.Person");
Person p1 = (Person) c1.newInstance();
p1.eat();

結果：

吃飯

注意：Person類必須有一個無參的構造器且類的構造器的存取許可權不能是private

2. 使用指定構造方法Constructor來建立物件

如果我們非得讓Person類的無參構造器設為private呢，我們可以獲取對應的Constructor來建立物件

Class c1 = Class.forName("com.zj.demotest.domain.Person");
Constructor<Person> con =  c1.getDeclaredConstructor();
con.setAccessible(true);//允許存取
Person p1 = con.newInstance();
p1.eat();

結果：

吃飯

注意：setAccessible()方法能在執行時壓制Java語言存取控制檢查(Java language access control checks)，從而能任意呼叫被私有化保護的方法、域和構造方法。
由此我們可以發現** 單例模式不再安全，反射可破之！**

存取屬性

Field getField(name)	根據欄位名獲取某個public的field（包括父類別）
Field getDeclaredField(name)	根據欄位名獲取當前類的某個field（不包括父類別）
Field[] getFields()	獲取所有public的field（包括父類別）
Field[] getDeclaredFields()	獲取當前類的所有field（不包括父類別）

我們來看一個例子：

public class TestReflection3 {
    
    public static void main(String[] args) throws Exception {
        Object p = new Student("li hua");
        Class c = p.getClass();
        Field f = c.getDeclaredField("name");//獲取屬性
        f.setAccessible(true);//允許存取
        Object val= f.get(p);
        System.out.println(val);
    }


    static class Student {
        private String name;

        public Student(String name) {
            this.name = name;
        }
    }
}

結果：

li hua

我們可以發現反射可以破壞類的封裝

呼叫方法

Method getMethod(name, Class...)	獲取某個public的Method（包括父類別）
Method getDeclaredMethod(name, Class...)	獲取當前類的某個Method（不包括父類別）
Method[] getMethods()	獲取所有public的Method（包括父類別）
Method[] getDeclaredMethods()	獲取當前類的所有Method（不包括父類別）

我們來看一個例子：

public class TestReflection4 {

    public static void main(String[] args) throws Exception {

        //獲取私有方法，需要傳參：方法名和引數
        Method h = Student.class.getDeclaredMethod("setName",String.class);

        h.setAccessible(true);

        Student s1 =new Student();
        System.out.println(s1.name);
        //傳入目標物件，呼叫對應的方法
        h.invoke(s1,"xiao ming");
        System.out.println(s1.name);
    }


    static class Student {
        private String name;

        private void setName(String name) {
            this.name = name;
        }
    }
}

結果：

null
xiao ming

我們發現獲取方法getMethod()時，需要傳參 方法名和引數
這是因為.class檔案中通常有不止一個方法，獲取方法getMethod()時,會去呼叫searchMethods方法迴圈遍歷所有Method，然後根據 方法名和引數型別 找到唯一符合的Method返回。

我們知道類的方法是在JVM的方法區中 ，當我們new 多個物件時，屬性會另外開闢堆空間存放，而方法只有一份，不會額外消耗記憶體，方法就像一套指令模板，誰都可以傳入資料交給它執行，然後得到對應執行結果。
method.invoke(obj, args)時傳入目標物件，即可呼叫對應物件的方法

如果獲取到的Method表示一個靜態方法，呼叫靜態方法時，無需指定範例物件，所以invoke方法傳入的第一個引數永遠為null, method.invoke(null, args)

那如果 方法重寫了呢，反射依舊遵循 多型 的原則。

反射的應用場景

如果平時我們只是寫業務程式碼,很少會接觸到直接使用反射機制的場景，畢竟我們可以直接new一個物件，效能比還反射要高。
但如果我們是工具框架的開發者,那一定非常熟悉,像 Spring/Spring Boot、MyBatis 等等框架中都大量使用反射機制，反射被稱為框架的靈魂
比如：

1. Mybatis Plus可以讓我們只寫介面，不寫實現類，就可以執行SQL
2. 開發專案時，切換不同的資料庫只需更改組態檔即可
3. 類上加上@Component註解，Spring就幫我們建立物件
4. 在Spring我們只需 @Value註解就讀取到組態檔中的值
5. 等等

擴充套件：反射組態檔

我們來模擬一個設定高於編碼的例子

新建my.properties，將其放在resources的目錄下

#Person類的包路徑
className=com.zj.demotest.domain.Person 
methodName=eat

Person類 還是本文 一直用的，在文章的開頭有

最後我們來編寫一個測試類

public class TestProp {
    public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {

        Properties properties = new Properties();

        ClassLoader classLoader = TestProp.class.getClassLoader();
        InputStream inputStream = classLoader.getResourceAsStream("my.properties");// 載入組態檔
        properties.load(inputStream);

        String className = properties.getProperty("className");
        System.out.println("組態檔中的內容：className="+className);
        String methodName = properties.getProperty("methodName");
        System.out.println("組態檔中的內容：methodName="+methodName);

        Class name = Class.forName(className);
        Object object = name.newInstance();

        Method method = name.getMethod(methodName);
        method.invoke(object);
    }
}

結果：

組態檔中的內容：className=com.zj.demotest.domain.Person
組態檔中的內容：methodName=eat
吃飯

緊接著，我們修改組態檔:

className=com.zj.demotest.domain.Person
methodName=Dance

結果變為：

組態檔中的內容：className=com.zj.demotest.domain.Person
組態檔中的內容：methodName=Dance
跳舞

是不是很方便？

尾語

反射機制是一種功能強大的機制，讓Java程式具有在執行期分析類以及修改其本身狀態或行為的能力。
對於特定的複雜系統程式設計任務，它是非常必要的，為各種框架提供開箱即用的功能提供了便利，為解耦合提供了保障機制。
但是世事無絕對，反射相當於一系列解釋操作，通知 JVM 要做的事情，效能比直接存取物件要差點（JIT優化後，對於框架來說實際是影響不大的），還會增加程式的複雜性等（明明直接new一下就能解決的事情，非要寫一大段程式碼）。

推薦配合閱讀：

https://mp.weixin.qq.com/s/tsbDfyYLqr3ctzwHirQ8UQ
https://mp.weixin.qq.com/s/v91bqRiKDWWgeNl1DIdaDQ

參考資料：
《JAVA核心技術 卷二》
https://www.pudn.com/news/628f83bdbf399b7f351eb05f.html
https://www.zhihu.com/question/19826278
https://www.jianshu.com/p/423e061a46c8

---

本篇文章到這裡就結束啦，很感謝你能看到最後，如果覺得文章對你有幫助，別忘記關注我！