摘要：本文首發于作者最近在學，研究了下和代理模式，寫點心得和大家分享下。所以下面來重點分析下代理模式。這里代理模式分為靜態代理和動態代理兩種，我們分別來看下。代理模式，代理，意味著有一方代替另一方完成一件事。

本文首發于 https://jaychen.cc
作者 jaychen

最近在學 Spring，研究了下 AOP 和代理模式，寫點心得和大家分享下。

先說下AOP，AOP 全稱 Aspect Oriented Programming，面向切面編程，和 OOP 一樣也是一種編程思想。AOP 出現的原因是為了解決 OOP 在處理 侵入性業務上的不足。

那么，什么是侵入性業務？類似日志統計、性能分析等就屬于侵入性業務。本來原本的業務邏輯代碼優雅大氣，正常運行，突然說需要在這段邏輯里面加上性能分析，于是代碼就變成了下面這個樣子

long begin = System.currentTimeMillis(); 

// 原本的業務
doSomething();

long end = System.currentTimeMillis();
long step = end - begin;
System.out.println("執行花費 ：" + step);

從上面的代碼看到，性能分析的業務代碼和原本的業務代碼混在了一起，好端端的代碼就這么被糟蹋了。所以，侵入性業務必須有一個更好的解決方案，這個解決方案就是 AOP。

那么，AOP 是如何解決這類問題？

通常，我們會使用代理模式來實現 AOP，這就意味著代理模式可以優雅的解決侵入性業務問題。所以下面來重點分析下代理模式。

這個是代理模式的類圖。很多人可能看不懂類圖，但是說實話有時候一圖勝千言，這里稍微解釋下類圖的含義，尤其是類圖中存在的幾種連線符。

矩形代表一個類，矩形內部的信息有：類名，屬性和方法。

虛線 + 三角空心箭頭為 is=a 的關系，表示繼承，所以上圖中 TestSQL 和 Performance 都實現 IDatabase 接口。

實線 + 箭頭為關聯關系，一般在代碼中以成員變量的形式體現，所以上圖中 Performance 類有一個 TestSQL 的成員變量。

有了類圖，我們可以根據類圖直接寫出代理模式的代碼了。這里代理模式分為靜態代理和動態代理兩種，我們分別來看下。

假設一個場景，我們需要測試一條 sql query 執行所花費的時間。

如果按照普通的方式，代碼邏輯應該如下

long begin = System.currentTimeMillis(); 

query();

long end = System.currentTimeMillis();
long step = end - begin;
System.out.println("執行花費 ：" + step);

上面說過了，這種會導致查詢邏輯和性能測試邏輯混淆在一塊，那么來看看使用代理模式是如何解決這個問題的。

代理模式，代理，意味著有一方代替另一方完成一件事。這里，我們會編寫兩個類：TestSQL 為query 執行邏輯，Performance 為性能測試類。這里 Performance 會代替 TestSQL 去執行 query 邏輯。

要想 Performance 能夠代替 TestSQL 執行 query 邏輯，那么這兩個類應該是有血緣關系的，即這兩個必須實現同一個接口。

// 接口
public interface IDatabase {
    void query();
}


public class TestSQL implements IDatabase {

    @Override
    public void query() {
        System.out.println("執行 query。。。。");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


// 代理類
public class PerformanceMonitor implements IDatabase {
    TestSQL sql;

    public PerformanceMonitor(TestSQL sql) {
        this.sql = sql;
    }


    @Override
    public void query() {
        long begin = System.currentTimeMillis();

        // 業務邏輯。
        sql.query();

        long end = System.currentTimeMillis();
        long step = end - begin;
        System.out.println("執行花費 : " + step);
    }
}


// 測試代碼
public class Main {
    public static void main(String[] strings) {
        TestSQL sql = new TestSQL();

        PerformanceMonitor performanceMonitor = new PerformanceMonitor(sql);
        // 由 Performance 代替 testSQL 執行
        performanceMonitor.query();
    }
}

從上面的示例代碼可以分析出來代理模式是如何運作的，這里我們可以很明顯看出代理模式的優越性，TestSQL 的邏輯很純粹，沒有混入其他無關的業務代碼。

回顧靜態代理的代碼，發現代理類 Performance 必須實現 IDatabase 接口。如果有很多業務需要用到代理來實現，那么每個業務都需要定義一個代理類，這會導致類迅速膨脹，為了避免這點，Java 提供了動態代理。

為何稱之為動態代理，動態代理底層是使用反射實現的，是在程序運行期間動態的創建接口的實現。在靜態代理中，我們需要在編碼的時候編寫 Performance 類實現 IDatabase 接口。而使用動態代理，我們不必編寫 Performance 實現 IDatabase 接口，而是 JDK 在底層通過反射技術動態創建一個 IDatabase 接口的實現。

使用動態代理需要使用到 InvocationHandler 和 Proxy 這兩個類。

// 代理類,不再實現 IDatabase 接口，而是實現 InvocationHandler 接口
public class Performance implements InvocationHandler {

    private TestSQL sql;

    public Performance(TestSQL sql) {
        this.sql = sql;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long begin = System.currentTimeMillis();

        // method.invoke 實際上就是調用 sql.query()
        Object object = method.invoke(sql, args);

        long end = System.currentTimeMillis();
        long step = end - begin;
        System.out.println("執行花費 ：" + step);
        return object;
    }
}



public class Main {
    public static void main(String[] strings) {
        TestSQL sql = new TestSQL();
        Performance performance = new Performance(sql);

        IDatabase proxy = (IDatabase) Proxy.newProxyInstance(
                sql.getClass().getClassLoader(),
                sql.getClass().getInterfaces(),
                performance
        );
        proxy.query();
    }
}

先來看看 newProxyInstance 函數，這個函數的作用就是用來動態創建一個代理對象的類，這個函數需要三個參數：

第一個參數為類加載器，如果不懂是什么玩意，先套著模板寫，等我寫下一篇文章拯救你。

第二個參數為要代理的接口，在這個例子里面就是 IDatabase 接口。

第三個參數為實現 InvocationHandler 接口的對象。

執行 newProxyInstance 之后，Java 會在底層自動生成一個代理類，其代碼大概如下：

public final class $Proxy1 extends Proxy implements IDatabase{
    private InvocationHandler h;

    private $Proxy1(){}

    public $Proxy1(InvocationHandler h){
        this.h = h;
    }

    public void query(){
        ////創建method對象
        Method method = Subject.class.getMethod("query");
        //調用了invoke方法
        h.invoke(this, method, new Object[]{}); 
    }
}

你會發現，這個類很像在靜態代理中的 Performance 類，是的，動態代理其本質是 Java 自動為我們生成了一個 $Proxy1 代理類。在 mian 函數中 newProxyInstance 的返回值就是該類的一個實例。并且，$Proxy1 中的 h 屬性就是 newProxyInstance 的第三個參數。所以，當我們在 main 函數中執行 proxy.query()，實際上是調用 $proxy1#query 方法，進而再調用 Performance#invoke 方法。而在 Performance#invoke 通過 Object object = method.invoke(sql, args); 調用了 TestSQL#query 方法。

回顧上面的流程，理解動態代理的核心在于理解 Java 自動生成的代理類。這里還有一點要說明，JDK 的動態代理有一個不足：它只能為接口創建代理實例。這句話體現在代碼上就是 newProxyInstance 的第二個參數是一個接口數組。為什么會存在這個不足？其實看 $Proxy1 代理類就知道了，這個由 JDK 生成的代理類需要繼承 Proxy 類，而 Java 只支持單繼承，所以就限制了 JDK 的動態代理只能為接口創建代理。