JAVA反射機制詳解

• 何為反射？
  • 實體的創建
  • .class檔案
  • Class類
• 反射的使用
  • 獲取Class實體4種方式
  • Class類常用的API
  • 創建物件
  • 訪問屬性
  • 呼叫方法
• 反射的應用場景
• 擴展：反射組態檔
• 尾語

何為反射？

反射(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 = https://www.cnblogs.com/xiaoniuhululu/archive/2022/08/04/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

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

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

創建物件

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)，從而能任意呼叫被私有化保護的方法、域和構造方法，
由此我們可以發現** 單例模式不再安全，反射可破之！**

訪問屬性

我們來看一個例子：

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

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

呼叫方法

我們來看一個例子：

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

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

標籤：其他

上一篇：Java中break、continue和return三者之間的區別

下一篇：趣味問題《尋人啟事》的Python程式解決