JAVA反射機制詳解

2022 年 8 月 4 日
筆記
Java Why

何為反射？
反射的使用
反射的應用場景
擴展：反射配置文件
尾語

何為反射？

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

實例的創建

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

將硬碟上指定位置的Person.class文件載入進記憶體
執行main方法時，在棧記憶體中開闢了main方法的空間（壓棧-進棧），然後在main方法的棧區分配了一個變數zhang。
執行new，在堆記憶體中開闢一個實體類的空間，分配了一個記憶體首地址值
調用該實體類對應的構造函數，進行初始化（如果沒有構造函數，Java會補上一個默認構造函數）。
將實體類的首地址賦值給zhang，變數zhang就引用了該實體。（指向了該對象）

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

而又在 載入階段，類載入器會將類對應的.class文件中的二進位位元組流讀入到記憶體中，將這個位元組流轉化為方法區的運行時數據結構，然後在堆區創建一個**java.lang.Class 對象**（類相關的資訊），作為對方法區中這些數據的訪問入口

詳情可看筆者之前寫過的2篇文章：
//mp.weixin.qq.com/s/tsbDfyYLqr3ctzwHirQ8UQ
//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種方式

通過對象調用 getClass() 方法來獲取

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

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

類名.class

Class c2 = Person.class;

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

通過 Class 對象的 forName() 靜態方法來獲取，最常用的一種方式

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

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

通過類載入器對象的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(即父類)。
…	…

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

創建對象

調用class對象的newInstance()方法

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

結果：

吃飯

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

使用指定構造方法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 等等框架中都大量使用反射機制，反射被稱為框架的靈魂
比如：

Mybatis Plus可以讓我們只寫介面，不寫實現類，就可以執行SQL
開發項目時，切換不同的資料庫只需更改配置文件即可
類上加上@Component註解，Spring就幫我們創建對象
在Spring我們只需 @Value註解就讀取到配置文件中的值
等等

擴展：反射配置文件

我們來模擬一個配置高於編碼的例子

新建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=eat

結果變為：

配置文件中的內容：className=com.zj.demotest.domain.Person
配置文件中的內容：methodName=Dance
跳舞

是不是很方便？

尾語

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

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

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

Tags: Java Why