Java反射學問很深,這裡就淺談吧。如果涉及到方法內聯,逃逸分析的話,我們就說說是什麼就好了。有興趣的可以去另外看看,我後面可能也會寫一下。(因為我也不會呀~)

一、Java反射是什麼?

反射的核心是JVM在執行時才動態載入類或呼叫方法/訪問屬性,它不需要事先(寫程式碼的時候或編譯期)知道執行物件是誰。

反射是由類開始的,從class物件中,我們可以獲得有關該類的全部成員的完整列表;可以找出該類的所有型別、類自身資訊。

二、反射的一些應用

1、java整合開發環境,每當我們敲入點號時,IDE便會根據點號前的內容,動態展示可以訪問的欄位和方法。

2、java偵錯程式,它能夠在除錯過程中列舉某一物件所有欄位的值。

3、web開發中,我們經常接觸到各種配置的通用框架。為保證框架的可擴充套件性,他往往藉助java的反射機制。例如Spring框架的依賴反轉(IOC)便是依賴於反射機制。

三、Java反射的實現

       1. Java反射使用的api(列舉部分,具體在rt.jar包的java.lang.reflect.*)中

列舉Class.java中的一些方法。這些都很常用,比如在你嘗試編寫一個mvc框架的時候,就可以參照這個類裡面的方法,再結合一些Servlet的api就實現一個簡單的框架。

 

     2.程式碼實現

       2.1程式碼實現的目的:說明反射呼叫是有兩種方式,一種是本地實現,另一種是委派實現。

這裡圍繞Method.invoke方法展開。檢視invoke()原始碼:

 public Object invoke(Object obj, Object... args)
        throws IllegalAccessException, IllegalArgumentException,
           InvocationTargetException
    {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, obj, modifiers);
            }
        }
        MethodAccessor ma = methodAccessor;             // read volatile
        if (ma == null) {
            ma = acquireMethodAccessor();
        }
        return ma.invoke(obj, args);
    }

說明:invoke()是有MethodAccessor介面實現的,這個介面有倆實現:

一個是使用委派模式的“委派實現”,一個是通過本地方法呼叫來實現反射呼叫的“本地實現”。

這兩種實現不是獨立的,而是相互協作的。下面,用程式碼讓大家看一下具體操作。

Java程式碼:

public class InvokeDemo {
    public static void target(int i){
        new Exception("#"+i).printStackTrace();
    }
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Class<?> invokeDemo1 = Class.forName("com.example.demo.invoke_demo.InvokeDemo");
        Method method1 = invokeDemo1.getMethod("target", int.class);
        method1.invoke(null,0);
    }
}

執行之後,便可以在異常棧中查詢方法呼叫的路線:

java.lang.Exception: #0
    at com.example.demo.invoke_demo.InvokeDemo.target(InvokeDemo.java:9)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at com.example.demo.invoke_demo.InvokeDemo.main(InvokeDemo.java:15)

這裡,我們會看到,invoke方法是先呼叫委派實現,然後再將請求傳到本地方法實現的,最後在傳到目標方法使用。

為什麼要這樣做呢?為什麼不直接呼叫本地方法呢?

其實,Java的反射呼叫機制還設立了另一種動態生成位元組碼的實現(“動態實現”),直接使用invoke指令來呼叫目標方法。之所以採用委派實現,便是為了能夠在“本地實現”和動態實現之間來回切換。(但是,動態實現貌似並沒有開源)

動態實現與本地實現的區別在於,反射程式碼段重複執行15次以上就會使用動態實現,15次以下就使用本地實現。下面是重複這個程式碼的控制檯輸出的第#14、#15、#16段異常:

Class<?> invokeDemo1 = Class.forName("com.example.demo.invoke_demo.InvokeDemo");
        Method method1 = invokeDemo1.getMethod("target", int.class);
        method1.invoke(null,0);

控制檯:

java.lang.Exception: #15
    at com.example.demo.invoke_demo.InvokeDemo.target(InvokeDemo.java:9)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at com.example.demo.invoke_demo.InvokeDemo.main(InvokeDemo.java:20)
java.lang.Exception: #16
    at com.example.demo.invoke_demo.InvokeDemo.target(InvokeDemo.java:9)
    at sun.reflect.GeneratedMethodAccessor1.invoke(Unknown Source)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at com.example.demo.invoke_demo.InvokeDemo.main(InvokeDemo.java:20)
java.lang.Exception: #17
    at com.example.demo.invoke_demo.InvokeDemo.target(InvokeDemo.java:9)
    at sun.reflect.GeneratedMethodAccessor1.invoke(Unknown Source)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at com.example.demo.invoke_demo.InvokeDemo.main(InvokeDemo.java:20)

從#15到#16異常鏈路看,反射的呼叫就開始從本地實現向動態實現的轉變。這 是JVM對反射呼叫進行辨別優化效能的一個手段。

另外注意一點,粉紅色部分的字型,標記為“unkown source" ,那就是不開源的吧,所以看不到那是啥。。

 

四、Java反射的效能開銷

public class InvokeDemo {
    private static long n = 0;
    public static void target(int i){
        n++;
    }
    /* 8662ms
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Class<?> invokeDemo1 = Class.forName("com.example.demo.invoke_demo.InvokeDemo");
        Method method1 = invokeDemo1.getMethod("target", int.class);

        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
                if(i==1000000000-1){
                    long  total = System.currentTimeMillis()-start;
                    System.out.println(total);
                }
            method1.invoke(null,1);
        }
    }    
    */    
    // 161ms
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            if(i==1000000000-1){
                long  total = System.currentTimeMillis()-start;
                System.out.println(total);
            }
            target(1);
        }
    }
}

上面展示了使用反射呼叫和不使用反射呼叫的效能,結果表示,使用反射的耗時為8662ms,而不使用反射的耗時為161ms。這裡就可以看到差異。

那麼從位元組碼層面檢視,又是什麼樣的一種風景呢?

 1.不使用反射:

public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=4, locals=6, args_size=1
         0: invokestatic  #3                  // Method java/lang/System.currentTimeMillis:()J
         3: lstore_1
         4: iconst_0
         5: istore_3
         6: iload_3
         7: ldc           #4                  // int 1000000000
         9: if_icmpge     43
        12: iload_3
        13: ldc           #5                  // int 999999999
        15: if_icmpne     33
        18: invokestatic  #3                  // Method java/lang/System.currentTimeMillis:()J
        21: lload_1
        22: lsub
        23: lstore        4
        25: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
        28: lload         4
        30: invokevirtual #7                  // Method java/io/PrintStream.println:(J)V
        33: iconst_1
        34: invokestatic  #8                  // Method target:(I)V
        37: iinc          3, 1
        40: goto          6
        43: return
      LineNumberTable:
        line 8: 0
        line 9: 4
        line 10: 12
        line 11: 18
        line 12: 25
        line 14: 33
        line 9: 37
        line 16: 43
      StackMapTable: number_of_entries = 3
        frame_type = 253 /* append */
          offset_delta = 6
          locals = [ long, int ]
        frame_type = 26 /* same */
        frame_type = 250 /* chop */
          offset_delta = 9

 

2.使用反射:

 public static void main(java.lang.String[]) throws java.lang.ClassNotFoundException, java.lang.NoSuchMethodException, java.lang.reflect.InvocationTargetException, java.lang.IllegalAccessException;
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=6, locals=8, args_size=1
         0: ldc           #3                  // String InvokeDemo2
         2: invokestatic  #4                  // Method java/lang/Class.forName:(Ljava/lang/String;)Ljava/lang/Class;
         5: astore_1
         6: aload_1
         7: ldc           #5                  // String target
         9: iconst_1
        10: anewarray     #6                  // class java/lang/Class
        13: dup
        14: iconst_0
        15: getstatic     #7                  // Field java/lang/Integer.TYPE:Ljava/lang/Class;
        18: aastore
        19: invokevirtual #8                  // Method java/lang/Class.getMethod:(Ljava/lang/String;[Ljava/lang/Class;)Ljava/lang/reflect/Method;
        22: astore_2
        23: invokestatic  #9                  // Method java/lang/System.currentTimeMillis:()J
        26: lstore_3
        27: iconst_0
        28: istore        5
        30: iload         5
        32: ldc           #10                 // int 1000000000
        34: if_icmpge     82
        37: iload         5
        39: ldc           #11                 // int 999999999
        41: if_icmpne     59
        44: invokestatic  #9                  // Method java/lang/System.currentTimeMillis:()J
        47: lload_3
        48: lsub
        49: lstore        6
        51: getstatic     #12                 // Field java/lang/System.out:Ljava/io/PrintStream;
        54: lload         6
        56: invokevirtual #13                 // Method java/io/PrintStream.println:(J)V
        59: aload_2
        60: aconst_null
        61: iconst_1
        62: anewarray     #14                 // class java/lang/Object
        65: dup
        66: iconst_0
        67: iconst_1
        68: invokestatic  #15                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
        71: aastore
        72: invokevirtual #16                 // Method java/lang/reflect/Method.invoke:(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;
        75: pop
        76: iinc          5, 1
        79: goto          30
        82: return

anewarray: 表示建立一個引用型別的(如類、介面、陣列)陣列,並將其引用值壓如棧頂 (1: anewarray #2)

 

大致的分析:

1.綠色部分:反射呼叫分配了更多的棧,說明需要進行比普通呼叫還要多的棧空間分配,也就是pop出,push進。。

2.從方法體上看: 在反射部分程式碼中的藍色背景部分,也就是62行位元組碼,使用了建立陣列這一操作,並且還有68行的將int型別的1進行裝箱操作,這些步驟對於普通呼叫來說,都是多出來的,自然也就比普通呼叫的方式耗時得多了。

 

但是,普通呼叫和反射呼叫一個方法的用途不一樣,我們不能為了反射呼叫而呼叫,最好能夠在普通呼叫無法滿足的情況下進行該操作。

 

五、優化反射呼叫

(明天再寫吧。。。demo都沒寫出來,不好意思寫了。。)

&n