深入理解 Java 反射和動態代理

本文轉載自查看原文 2019-12-16 14:55 1685 JavaCore

📓 本文已歸檔到：「javacore」

🔁 本文中的示例代碼已歸檔到：「javacore」

1. 簡介

1.1. 什么是反射

反射(Reflection)是 Java 程序開發語言的特征之一，它允許運行中的 Java 程序獲取自身的信息，並且可以操作類或對象的內部屬性。

通過反射機制，可以在運行時訪問 Java 對象的屬性，方法，構造方法等。

1.2. 反射的應用場景

反射的主要應用場景有：

開發通用框架 - 反射最重要的用途就是開發各種通用框架。很多框架（比如 Spring）都是配置化的（比如通過 XML 文件配置 JavaBean、Filter 等），為了保證框架的通用性，它們可能需要根據配置文件加載不同的對象或類，調用不同的方法，這個時候就必須用到反射——運行時動態加載需要加載的對象。
動態代理 - 在切面編程（AOP）中，需要攔截特定的方法，通常，會選擇動態代理方式。這時，就需要反射技術來實現了。
注解 - 注解本身僅僅是起到標記作用，它需要利用反射機制，根據注解標記去調用注解解釋器，執行行為。如果沒有反射機制，注解並不比注釋更有用。
可擴展性功能 - 應用程序可以通過使用完全限定名稱創建可擴展性對象實例來使用外部的用戶定義類。

1.3. 反射的缺點

性能開銷 - 由於反射涉及動態解析的類型，因此無法執行某些 Java 虛擬機優化。因此，反射操作的性能要比非反射操作的性能要差，應該在性能敏感的應用程序中頻繁調用的代碼段中避免。
破壞封裝性 - 反射調用方法時可以忽略權限檢查，因此可能會破壞封裝性而導致安全問題。
內部曝光 - 由於反射允許代碼執行在非反射代碼中非法的操作，例如訪問私有字段和方法，所以反射的使用可能會導致意想不到的副作用，這可能會導致代碼功能失常並可能破壞可移植性。反射代碼打破了抽象，因此可能會隨着平台的升級而改變行為。

2. 反射機制

2.1. 類加載過程

類加載的完整過程如下：

在編譯時，Java 編譯器編譯好 .java 文件之后，在磁盤中產生 .class 文件。.class 文件是二進制文件，內容是只有 JVM 能夠識別的機器碼。
JVM 中的類加載器讀取字節碼文件，取出二進制數據，加載到內存中，解析.class 文件內的信息。類加載器會根據類的全限定名來獲取此類的二進制字節流；然后，將字節流所代表的靜態存儲結構轉化為方法區的運行時數據結構；接着，在內存中生成代表這個類的 java.lang.Class 對象。
加載結束后，JVM 開始進行連接階段（包含驗證、准備、初始化）。經過這一系列操作，類的變量會被初始化。

2.2. Class 對象

要想使用反射，首先需要獲得待操作的類所對應的 Class 對象。Java 中，無論生成某個類的多少個對象，這些對象都會對應於同一個 Class 對象。這個 Class 對象是由 JVM 生成的，通過它能夠獲悉整個類的結構。所以，java.lang.Class 可以視為所有反射 API 的入口點。

反射的本質就是：在運行時，把 Java 類中的各種成分映射成一個個的 Java 對象。

舉例來說，假如定義了以下代碼：

User user = new User();

步驟說明：

JVM 加載方法的時候，遇到 new User()，JVM 會根據 User 的全限定名去加載 User.class 。
JVM 會去本地磁盤查找 User.class 文件並加載 JVM 內存中。
JVM 通過調用類加載器自動創建這個類對應的 Class 對象，並且存儲在 JVM 的方法區。注意：一個類有且只有一個 Class 對象。

3. 使用反射

3.1. java.lang.reflect 包

Java 中的 java.lang.reflect 包提供了反射功能。java.lang.reflect 包中的類都沒有 public 構造方法。

java.lang.reflect 包的核心接口和類如下：

Member 接口 - 反映關於單個成員(字段或方法)或構造函數的標識信息。
Field 類 - 提供一個類的域的信息以及訪問類的域的接口。
Method 類 - 提供一個類的方法的信息以及訪問類的方法的接口。
Constructor 類 - 提供一個類的構造函數的信息以及訪問類的構造函數的接口。
Array 類 - 該類提供動態地生成和訪問 JAVA 數組的方法。
Modifier 類 - 提供了 static 方法和常量，對類和成員訪問修飾符進行解碼。
Proxy 類 - 提供動態地生成代理類和類實例的靜態方法。

3.2. 獲得 Class 對象

獲得 Class 的三種方法：

（1）使用 Class 類的 forName 靜態方法

示例：

package io.github.dunwu.javacore.reflect;

public class ReflectClassDemo01 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class c1 = Class.forName("io.github.dunwu.javacore.reflect.ReflectClassDemo01");
        System.out.println(c1.getCanonicalName());

        Class c2 = Class.forName("[D");
        System.out.println(c2.getCanonicalName());

        Class c3 = Class.forName("[[Ljava.lang.String;");
        System.out.println(c3.getCanonicalName());
    }
}
//Output:
//io.github.dunwu.javacore.reflect.ReflectClassDemo01
//double[]
//java.lang.String[][]

使用類的完全限定名來反射對象的類。常見的應用場景為：在 JDBC 開發中常用此方法加載數據庫驅動。

（2）直接獲取某一個對象的 class

示例：

public class ReflectClassDemo02 {
    public static void main(String[] args) {
        boolean b;
        // Class c = b.getClass(); // 編譯錯誤
        Class c1 = boolean.class;
        System.out.println(c1.getCanonicalName());

        Class c2 = java.io.PrintStream.class;
        System.out.println(c2.getCanonicalName());

        Class c3 = int[][][].class;
        System.out.println(c3.getCanonicalName());
    }
}
//Output:
//boolean
//java.io.PrintStream
//int[][][]

（3）調用 Object 的 getClass 方法，示例：

Object 類中有 getClass 方法，因為所有類都繼承 Object 類。從而調用 Object 類來獲取

示例：

package io.github.dunwu.javacore.reflect;

import java.util.HashSet;
import java.util.Set;

public class ReflectClassDemo03 {
    enum E {A, B}

    public static void main(String[] args) {
        Class c = "foo".getClass();
        System.out.println(c.getCanonicalName());

        Class c2 = ReflectClassDemo03.E.A.getClass();
        System.out.println(c2.getCanonicalName());

        byte[] bytes = new byte[1024];
        Class c3 = bytes.getClass();
        System.out.println(c3.getCanonicalName());

        Set<String> set = new HashSet<>();
        Class c4 = set.getClass();
        System.out.println(c4.getCanonicalName());
    }
}
//Output:
//java.lang.String
//io.github.dunwu.javacore.reflect.ReflectClassDemo.E
//byte[]
//java.util.HashSet

3.3. 判斷是否為某個類的實例

判斷是否為某個類的實例有兩種方式：

用 instanceof 關鍵字
用 Class 對象的 isInstance 方法（它是一個 Native 方法）

示例：

public class InstanceofDemo {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        if (arrayList instanceof List) {
            System.out.println("ArrayList is List");
        }
        if (List.class.isInstance(arrayList)) {
            System.out.println("ArrayList is List");
        }
    }
}
//Output:
//ArrayList is List
//ArrayList is List

3.4. 創建實例

通過反射來創建實例對象主要有兩種方式：

用 Class 對象的 newInstance 方法。
用 Constructor 對象的 newInstance 方法。

示例：

public class NewInstanceDemo {
    public static void main(String[] args)
        throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Class<?> c1 = StringBuilder.class;
        StringBuilder sb = (StringBuilder) c1.newInstance();
        sb.append("aaa");
        System.out.println(sb.toString());

        //獲取String所對應的Class對象
        Class<?> c2 = String.class;
        //獲取String類帶一個String參數的構造器
        Constructor constructor = c2.getConstructor(String.class);
        //根據構造器創建實例
        String str2 = (String) constructor.newInstance("bbb");
        System.out.println(str2);
    }
}
//Output:
//aaa
//bbb

3.5. Field

Class 對象提供以下方法獲取對象的成員（Field）：

getFiled - 根據名稱獲取公有的（public）類成員。
getDeclaredField - 根據名稱獲取已聲明的類成員。但不能得到其父類的類成員。
getFields - 獲取所有公有的（public）類成員。
getDeclaredFields - 獲取所有已聲明的類成員。

示例如下：

public class ReflectFieldDemo {
    class FieldSpy<T> {
        public boolean[][] b = { {false, false}, {true, true} };
        public String name = "Alice";
        public List<Integer> list;
        public T val;
    }

    public static void main(String[] args) throws NoSuchFieldException {
        Field f1 = FieldSpy.class.getField("b");
        System.out.format("Type: %s%n", f1.getType());

        Field f2 = FieldSpy.class.getField("name");
        System.out.format("Type: %s%n", f2.getType());

        Field f3 = FieldSpy.class.getField("list");
        System.out.format("Type: %s%n", f3.getType());

        Field f4 = FieldSpy.class.getField("val");
        System.out.format("Type: %s%n", f4.getType());
    }
}
//Output:
//Type: class [[Z
//Type: class java.lang.String
//Type: interface java.util.List
//Type: class java.lang.Object

3.6. Method

Class 對象提供以下方法獲取對象的方法（Method）：

getMethod - 返回類或接口的特定方法。其中第一個參數為方法名稱，后面的參數為方法參數對應 Class 的對象。
getDeclaredMethod - 返回類或接口的特定聲明方法。其中第一個參數為方法名稱，后面的參數為方法參數對應 Class 的對象。
getMethods - 返回類或接口的所有 public 方法，包括其父類的 public 方法。
getDeclaredMethods - 返回類或接口聲明的所有方法，包括 public、protected、默認（包）訪問和 private 方法，但不包括繼承的方法。

獲取一個 Method 對象后，可以用 invoke 方法來調用這個方法。

invoke 方法的原型為:

public Object invoke(Object obj, Object... args)
        throws IllegalAccessException, IllegalArgumentException,
           InvocationTargetException

示例：

public class ReflectMethodDemo {
    public static void main(String[] args)
        throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {

        // 返回所有方法
        Method[] methods1 = System.class.getDeclaredMethods();
        System.out.println("System getDeclaredMethods 清單（數量 = " + methods1.length + "）：");
        for (Method m : methods1) {
            System.out.println(m);
        }

        // 返回所有 public 方法
        Method[] methods2 = System.class.getMethods();
        System.out.println("System getMethods 清單（數量 = " + methods2.length + "）：");
        for (Method m : methods2) {
            System.out.println(m);
        }

        // 利用 Method 的 invoke 方法調用 System.currentTimeMillis()
        Method method = System.class.getMethod("currentTimeMillis");
        System.out.println(method);
        System.out.println(method.invoke(null));
    }
}

3.7. Constructor

Class 對象提供以下方法獲取對象的構造方法（Constructor）：

getConstructor - 返回類的特定 public 構造方法。參數為方法參數對應 Class 的對象。
getDeclaredConstructor - 返回類的特定構造方法。參數為方法參數對應 Class 的對象。
getConstructors - 返回類的所有 public 構造方法。
getDeclaredConstructors - 返回類的所有構造方法。

獲取一個 Constructor 對象后，可以用 newInstance 方法來創建類實例。

示例：

public class ReflectMethodConstructorDemo {
    public static void main(String[] args)
        throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Constructor<?>[] constructors1 = String.class.getDeclaredConstructors();
        System.out.println("String getDeclaredConstructors 清單（數量 = " + constructors1.length + "）：");
        for (Constructor c : constructors1) {
            System.out.println(c);
        }

        Constructor<?>[] constructors2 = String.class.getConstructors();
        System.out.println("String getConstructors 清單（數量 = " + constructors2.length + "）：");
        for (Constructor c : constructors2) {
            System.out.println(c);
        }

        System.out.println("====================");
        Constructor constructor = String.class.getConstructor(String.class);
        System.out.println(constructor);
        String str = (String) constructor.newInstance("bbb");
        System.out.println(str);
    }
}

3.8. Array

數組在 Java 里是比較特殊的一種類型，它可以賦值給一個對象引用。下面我們看一看利用反射創建數組的例子：

public class ReflectArrayDemo {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> cls = Class.forName("java.lang.String");
        Object array = Array.newInstance(cls, 25);
        //往數組里添加內容
        Array.set(array, 0, "Scala");
        Array.set(array, 1, "Java");
        Array.set(array, 2, "Groovy");
        Array.set(array, 3, "Scala");
        Array.set(array, 4, "Clojure");
        //獲取某一項的內容
        System.out.println(Array.get(array, 3));
    }
}
//Output:
//Scala

其中的 Array 類為 java.lang.reflect.Array 類。我們通過 Array.newInstance 創建數組對象，它的原型是：

public static Object newInstance(Class<?> componentType, int length)
    throws NegativeArraySizeException {
    return newArray(componentType, length);
}

4. 動態代理

動態代理是反射的一個非常重要的應用場景。動態代理常被用於一些 Java 框架中。例如 Spring 的 AOP ，Dubbo 的 SPI 接口，就是基於 Java 動態代理實現的。

4.1. 靜態代理

靜態代理其實就是指設計模式中的代理模式。

代理模式為其他對象提供一種代理以控制對這個對象的訪問。

Subject 定義了 RealSubject 和 Proxy 的公共接口，這樣就在任何使用 RealSubject 的地方都可以使用 Proxy 。

abstract class Subject {
    public abstract void Request();
}

RealSubject 定義 Proxy 所代表的真實實體。

class RealSubject extends Subject {
    @Override
    public void Request() {
        System.out.println("真實的請求");
    }
}

Proxy 保存一個引用使得代理可以訪問實體，並提供一個與 Subject 的接口相同的接口，這樣代理就可以用來替代實體。

class Proxy extends Subject {
    private RealSubject real;

    @Override
    public void Request() {
        if (null == real) {
            real = new RealSubject();
        }
        real.Request();
    }
}

說明：

靜態代理模式固然在訪問無法訪問的資源，增強現有的接口業務功能方面有很大的優點，但是大量使用這種靜態代理，會使我們系統內的類的規模增大，並且不易維護；並且由於 Proxy 和 RealSubject 的功能本質上是相同的，Proxy 只是起到了中介的作用，這種代理在系統中的存在，導致系統結構比較臃腫和松散。

4.2. 動態代理

為了解決靜態代理的問題，就有了創建動態代理的想法：

在運行狀態中，需要代理的地方，根據 Subject 和 RealSubject，動態地創建一個 Proxy，用完之后，就會銷毀，這樣就可以避免了 Proxy 角色的 class 在系統中冗雜的問題了。

Java 動態代理基於經典代理模式，引入了一個 InvocationHandler，InvocationHandler 負責統一管理所有的方法調用。

動態代理步驟：

獲取 RealSubject 上的所有接口列表；
確定要生成的代理類的類名，默認為：com.sun.proxy.$ProxyXXXX；
根據需要實現的接口信息，在代碼中動態創建該 Proxy 類的字節碼；
將對應的字節碼轉換為對應的 class 對象；
創建 InvocationHandler 實例 handler，用來處理 Proxy 所有方法調用；
Proxy 的 class 對象以創建的 handler 對象為參數，實例化一個 proxy 對象。

從上面可以看出，JDK 動態代理的實現是基於實現接口的方式，使得 Proxy 和 RealSubject 具有相同的功能。

但其實還有一種思路：通過繼承。即：讓 Proxy 繼承 RealSubject，這樣二者同樣具有相同的功能，Proxy 還可以通過重寫 RealSubject 中的方法，來實現多態。CGLIB 就是基於這種思路設計的。

在 Java 的動態代理機制中，有兩個重要的類（接口），一個是 InvocationHandler 接口、另一個則是 Proxy 類，這一個類和一個接口是實現我們動態代理所必須用到的。

4.3. InvocationHandler 接口

InvocationHandler 接口定義：

public interface InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

每一個動態代理類都必須要實現 InvocationHandler 這個接口，並且每個代理類的實例都關聯到了一個 Handler，當我們通過代理對象調用一個方法的時候，這個方法的調用就會被轉發為由 InvocationHandler 這個接口的 invoke 方法來進行調用。

我們來看看 InvocationHandler 這個接口的唯一一個方法 invoke 方法：

Object invoke(Object proxy, Method method, Object[] args) throws Throwable

參數說明：

proxy - 代理的真實對象。
method - 所要調用真實對象的某個方法的 Method 對象
args - 所要調用真實對象某個方法時接受的參數

如果不是很明白，等下通過一個實例會對這幾個參數進行更深的講解。

4.4. Proxy 類

Proxy 這個類的作用就是用來動態創建一個代理對象的類，它提供了許多的方法，但是我們用的最多的就是 newProxyInstance 這個方法：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,  InvocationHandler h)  throws IllegalArgumentException

這個方法的作用就是得到一個動態的代理對象。

參數說明：

loader - 一個 ClassLoader 對象，定義了由哪個 ClassLoader 對象來對生成的代理對象進行加載。
interfaces - 一個 Interface 對象的數組，表示的是我將要給我需要代理的對象提供一組什么接口，如果我提供了一組接口給它，那么這個代理對象就宣稱實現了該接口(多態)，這樣我就能調用這組接口中的方法了
h - 一個 InvocationHandler 對象，表示的是當我這個動態代理對象在調用方法的時候，會關聯到哪一個 InvocationHandler 對象上

4.5. 動態代理實例

上面的內容介紹完這兩個接口(類)以后，我們來通過一個實例來看看我們的動態代理模式是什么樣的：

首先我們定義了一個 Subject 類型的接口，為其聲明了兩個方法：

public interface Subject {

    void hello(String str);

    String bye();
}

接着，定義了一個類來實現這個接口，這個類就是我們的真實對象，RealSubject 類：

public class RealSubject implements Subject {

    @Override
    public void hello(String str) {
        System.out.println("Hello  " + str);
    }

    @Override
    public String bye() {
        System.out.println("Goodbye");
        return "Over";
    }
}

下一步，我們就要定義一個動態代理類了，前面說個，每一個動態代理類都必須要實現 InvocationHandler 這個接口，因此我們這個動態代理類也不例外：

public class InvocationHandlerDemo implements InvocationHandler {
    // 這個就是我們要代理的真實對象
    private Object subject;

    // 構造方法，給我們要代理的真實對象賦初值
    public InvocationHandlerDemo(Object subject) {
        this.subject = subject;
    }

    @Override
    public Object invoke(Object object, Method method, Object[] args)
        throws Throwable {
        // 在代理真實對象前我們可以添加一些自己的操作
        System.out.println("Before method");

        System.out.println("Call Method: " + method);

        // 當代理對象調用真實對象的方法時，其會自動的跳轉到代理對象關聯的handler對象的invoke方法來進行調用
        Object obj = method.invoke(subject, args);

        // 在代理真實對象后我們也可以添加一些自己的操作
        System.out.println("After method");
        System.out.println();

        return obj;
    }
}

最后，來看看我們的 Client 類：

public class Client {
    public static void main(String[] args) {
        // 我們要代理的真實對象
        Subject realSubject = new RealSubject();

        // 我們要代理哪個真實對象，就將該對象傳進去，最后是通過該真實對象來調用其方法的
        InvocationHandler handler = new InvocationHandlerDemo(realSubject);

        /*
         * 通過Proxy的newProxyInstance方法來創建我們的代理對象，我們來看看其三個參數
         * 第一個參數 handler.getClass().getClassLoader() ，我們這里使用handler這個類的ClassLoader對象來加載我們的代理對象
         * 第二個參數realSubject.getClass().getInterfaces()，我們這里為代理對象提供的接口是真實對象所實行的接口，表示我要代理的是該真實對象，這樣我就能調用這組接口中的方法了
         * 第三個參數handler， 我們這里將這個代理對象關聯到了上方的 InvocationHandler 這個對象上
         */
        Subject subject = (Subject)Proxy.newProxyInstance(handler.getClass().getClassLoader(), realSubject
                .getClass().getInterfaces(), handler);

        System.out.println(subject.getClass().getName());
        subject.hello("World");
        String result = subject.bye();
        System.out.println("Result is: " + result);
    }
}

我們先來看看控制台的輸出：

com.sun.proxy.$Proxy0
Before method
Call Method: public abstract void io.github.dunwu.javacore.reflect.InvocationHandlerDemo$Subject.hello(java.lang.String)
Hello  World
After method

Before method
Call Method: public abstract java.lang.String io.github.dunwu.javacore.reflect.InvocationHandlerDemo$Subject.bye()
Goodbye
After method

Result is: Over

我們首先來看看 com.sun.proxy.$Proxy0 這東西，我們看到，這個東西是由 System.out.println(subject.getClass().getName()); 這條語句打印出來的，那么為什么我們返回的這個代理對象的類名是這樣的呢？

Subject subject = (Subject)Proxy.newProxyInstance(handler.getClass().getClassLoader(), realSubject
                .getClass().getInterfaces(), handler);

可能我以為返回的這個代理對象會是 Subject 類型的對象，或者是 InvocationHandler 的對象，結果卻不是，首先我們解釋一下為什么我們這里可以將其轉化為 Subject 類型的對象？

原因就是：在 newProxyInstance 這個方法的第二個參數上，我們給這個代理對象提供了一組什么接口，那么我這個代理對象就會實現了這組接口，這個時候我們當然可以將這個代理對象強制類型轉化為這組接口中的任意一個，因為這里的接口是 Subject 類型，所以就可以將其轉化為 Subject 類型了。

同時我們一定要記住，通過 Proxy.newProxyInstance 創建的代理對象是在 jvm 運行時動態生成的一個對象，它並不是我們的 InvocationHandler 類型，也不是我們定義的那組接口的類型，而是在運行是動態生成的一個對象，並且命名方式都是這樣的形式，以$開頭，proxy 為中，最后一個數字表示對象的標號。

接着我們來看看這兩句

subject.hello("World");
String result = subject.bye();

這里是通過代理對象來調用實現的那種接口中的方法，這個時候程序就會跳轉到由這個代理對象關聯到的 handler 中的 invoke 方法去執行，而我們的這個 handler 對象又接受了一個 RealSubject 類型的參數，表示我要代理的就是這個真實對象，所以此時就會調用 handler 中的 invoke 方法去執行。

我們看到，在真正通過代理對象來調用真實對象的方法的時候，我們可以在該方法前后添加自己的一些操作，同時我們看到我們的這個 method 對象是這樣的：

public abstract void io.github.dunwu.javacore.reflect.InvocationHandlerDemo$Subject.hello(java.lang.String)
public abstract java.lang.String io.github.dunwu.javacore.reflect.InvocationHandlerDemo$Subject.bye()

正好就是我們的 Subject 接口中的兩個方法，這也就證明了當我通過代理對象來調用方法的時候，起實際就是委托由其關聯到的 handler 對象的 invoke 方法中來調用，並不是自己來真實調用，而是通過代理的方式來調用的。

5. 小結

6. 參考資料

本文由博客一文多發平台 OpenWrite 發布！

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 深入理解Java反射+動態代理深入理解 Java 動態代理機制深入理解Java反射 java反射與動態代理的理解 java基礎強化——深入理解反射深入理解java反射原理深入理解ES6之——代理和反射（proxy）深入分析Java反射(四)-動態代理深入理解Java的動態編譯深入理解Java：類加載機制及反射