一、概述

1. 什麼是代理

我們大家都知道微商代理，簡單地說就是代替廠家賣商品，廠家“委託”代理為其銷售商品。關於微商代理，首先我們從他們那裡買東西時通常不知道背後的廠家究竟是誰，也就是說，“委託者”對我們來說是不可見的;其次，微商代理主要以朋友圈的人為目標客戶，這就相當於為廠家做了一次對客戶群體的“過濾”。我們把微商代理和廠家進一步抽象，前者可抽象為代理類，後者可抽象為委託類(被代理類)。通過使用代理，通常有兩個優點，並且能夠分別與我們提到的微商代理的兩個特點對應起來：

優點一：可以隱藏委託類的實現;

優點二：可以實現客戶與委託類間的解耦，在不修改委託類程式碼的情況下能夠做一些額外的處理。

2. 靜態代理

若代理類在程式執行前就已經存在，那麼這種代理方式被成為 靜態代理 ，這種情況下的代理類通常都是我們在Java程式碼中定義的。 通常情況下， 靜態代理中的代理類和委託類會實現同一介面或是派生自相同的父類。 下面我們用Vendor類代表生產廠家，BusinessAgent類代表微商代理，來介紹下靜態代理的簡單實現，委託類和代理類都實現了Sell介面，Sell介面的定義如下：

/**
 * 委託類和代理類都實現了Sell介面
 */
public interface Sell { 
    void sell(); 
    void ad(); 
} 
複製程式碼

Vendor類的定義如下：

/**
 * 生產廠家
 */
public class Vendor implements Sell { 
    public void sell() { 
        System.out.println("In sell method"); 
    } 
    
    public void ad() { 
        System,out.println("ad method");
    }
} 
複製程式碼

代理類BusinessAgent的定義如下：

/**
 * 代理類
 */
public class BusinessAgent implements Sell {
    private Sell vendor;
    
    public BusinessAgent(Sell vendor){
        this.vendor = vendor;
    }

    public void sell() { 
        vendor.sell();
    } 
    
    public void ad() {
        vendor.ad();
    }
} 
複製程式碼

從BusinessAgent類的定義我們可以瞭解到，靜態代理可以通過聚合來實現，讓代理類持有一個委託類的引用即可。

下面我們考慮一下這個需求：給Vendor類增加一個過濾功能，只賣貨給大學生。通過靜態代理，我們無需修改Vendor類的程式碼就可以實現，只需在BusinessAgent類中的sell方法中新增一個判斷即可如下所示：

/**
 * 代理類
 */
public class BusinessAgent(){ implements Sell {
    private Sell vendor;
    
    public BusinessAgent(Sell vendor){
        this.vendor = vendor;
    }

    public void sell() {
        if (isCollegeStudent()) {
            vendor.sell();
        }
    } 
    
    public void ad() {
        vendor.ad();
    }
} 
複製程式碼

這對應著我們上面提到的使用代理的第二個優點：可以實現客戶與委託類間的解耦，在不修改委託類程式碼的情況下能夠做一些額外的處理。靜態代理的侷限在於執行前必須編寫好代理類，下面我們重點來介紹下執行時生成代理類的動態代理方式。

二、動態代理

1. 什麼是動態代理

代理類在程式執行時建立的代理方式被成為 動態代理。 也就是說，這種情況下，代理類並不是在Java程式碼中定義的，而是在執行時根據我們在Java程式碼中的“指示”動態生成的。相比於靜態代理， 動態代理的優勢在於可以很方便的對代理類的函式進行統一的處理，而不用修改每個代理類的函式。 這麼說比較抽象，下面我們結合一個例項來介紹一下動態代理的這個優勢是怎麼體現的。

現在，假設我們要實現這樣一個需求：在執行委託類中的方法之前輸出“before”，在執行完畢後輸出“after”。我們還是以上面例子中的Vendor類作為委託類，BusinessAgent類作為代理類來進行介紹。首先我們來使用靜態代理來實現這一需求，相關程式碼如下：

public class BusinessAgent implements Sell {
    private Vendor mVendor; 
 
    public BusinessAgent(Vendor vendor) {
        this.mVendor = vendor; 
    } 
 
    public void sell() {
        System.out.println("before"); 
        mVendor.sell(); 
        System.out.println("after"); 
    } 
 
    public void ad() {
        System.out.println("before"); 
        mVendor.ad(); 
        System.out.println("after"); 
    }
} 
複製程式碼

從以上程式碼中我們可以瞭解到，通過靜態代理實現我們的需求需要我們在每個方法中都新增相應的邏輯，這裡只存在兩個方法所以工作量還不算大，假如Sell介面中包含上百個方法呢?這時候使用靜態代理就會編寫許多冗餘程式碼。通過使用動態代理，我們可以做一個“統一指示”，從而對所有代理類的方法進行統一處理，而不用逐一修改每個方法。下面我們來具體介紹下如何使用動態代理方式實現我們的需求。

2. 使用動態代理

2.1 InvocationHandler介面

在使用動態代理時，我們需要定義一個位於代理類與委託類之間的中介類，這個中介類被要求實現InvocationHandler介面，這個介面的定義如下：

/**
 * 呼叫處理程式
 */
public interface InvocationHandler { 
    Object invoke(Object proxy, Method method, Object[] args); 
} 
複製程式碼

從InvocationHandler這個名稱我們就可以知道，實現了這個介面的中介類用做“呼叫處理器”。當我們呼叫代理類物件的方法時，這個“呼叫”會轉送到invoke方法中，代理類物件作為proxy引數傳入，引數method標識了我們具體呼叫的是代理類的哪個方法，args為這個方法的引數。這樣一來，我們對代理類中的所有方法的呼叫都會變為對invoke的呼叫，這樣我們可以在invoke方法中新增統一的處理邏輯(也可以根據method引數對不同的代理類方法做不同的處理)。因此我們只需在中介類的invoke方法實現中輸出“before”，然後呼叫委託類的invoke方法，再輸出“after”。下面我們來一步一步具體實現它。

2.2 委託類的定義

動態代理方式下，要求委託類必須實現某個介面，這裡我們實現的是Sell介面。委託類Vendor類的定義如下：

public class Vendor implements Sell { 
    public void sell() { 
        System.out.println("In sell method"); 
    }

    public void ad() {
        System,out.println("ad method");
    }
} 
複製程式碼

2.3中介類

上面我們提到過，中介類必須實現InvocationHandler介面，作為呼叫處理器”攔截“對代理類方法的呼叫。中介類的定義如下：

public class DynamicProxy implements InvocationHandler { 
    //obj為委託類物件; 
    private Object obj; 
 
    public DynamicProxy(Object obj) {
        this.obj = obj;
    } 
 
    @Override 
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
        System.out.println("before"); 
        Object result = method.invoke(obj, args); 
        System.out.println("after"); 
        return result; 
    }
} 
複製程式碼

從以上程式碼中我們可以看到，中介類持有一個委託類物件引用，在invoke方法中呼叫了委託類物件的相應方法，看到這裡是不是覺得似曾相識?

通過聚合方式持有委託類物件引用，把外部對invoke的呼叫最終都轉為對委託類物件的呼叫。這不就是我們上面介紹的靜態代理的一種實現方式嗎?

實際上，中介類與委託類構成了靜態代理關係，在這個關係中，中介類是代理類，委託類就是委託類;

代理類與中介類也構成一個靜態代理關係，在這個關係中，中介類是委託類，代理類是代理類。

也就是說，動態代理關係由兩組靜態代理關係組成，這就是動態代理的原理。下面我們來介紹一下如何”指示“以動態生成代理類。

2.4動態生成代理類

動態生成代理類的相關程式碼如下：

public class Main { 
    public static void main(String[] args) {
        //建立中介類例項 
        DynamicProxy inter = new DynamicProxy(new Vendor()); 
        //加上這句將會產生一個$Proxy0.class檔案，這個檔案即為動態生成的代理類檔案
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true"); 

        //獲取代理類例項sell 
        Sell sell = (Sell)(Proxy.newProxyInstance(Sell.class.getClassLoader(), new Class[] {Sell.class}, inter)); 
 
        //通過代理類物件呼叫代理類方法，實際上會轉到invoke方法呼叫 
        sell.sell(); 
        sell.ad(); 
    }
} 
複製程式碼

在以上程式碼中，我們呼叫Proxy類的newProxyInstance方法來獲取一個代理類例項。這個代理類實現了我們指定的介面並且會把方法呼叫分發到指定的呼叫處理器。這個方法的宣告如下：

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

方法的三個引數含義分別如下：

loader：定義了代理類的ClassLoder; interfaces：代理類實現的介面列表 h：呼叫處理器，也就是我們上面定義的實現了InvocationHandler介面的類例項

我們執行一下，看看我們的動態代理是否能正常工作。我這裡執行後的輸出為

說明我們的動態代理確實奏效了。

上面我們已經簡單提到過動態代理的原理，這裡再簡單的總結下：首先通過newProxyInstance方法獲取代理類例項，而後我們便可以通過這個代理類例項呼叫代理類的方法，對代理類的方法的呼叫實際上都會呼叫中介類(呼叫處理器)的invoke方法，在invoke方法中我們呼叫委託類的相應方法，並且可以新增自己的處理邏輯。

三、代理模式

這個應該是設計模式中最簡單的一個了，類圖

代理模式最大的特點就是代理類和實際業務類實現同一個介面（或繼承同一父類），代理物件持有一個實際物件的引用，外部呼叫時操作的是代理物件，而在代理物件的內部實現中又會去呼叫實際物件的操作

Java動態代理其實內部也是通過Java反射機制來實現的，即已知的一個物件，然後在執行時動態呼叫其方法，這樣在呼叫前後作一些相應的處理，這樣說的比較籠統，舉個簡單的例子

比如我們在應用中有這樣一個需求，在對某個類的一個方法的呼叫前和呼叫後都要做一下日誌操作，

一個普通的介面

public interface AppService {  
    public boolean createApp(String name);  
}  
複製程式碼

該介面的預設實現類

public class AppServiceImpl implements AppService {  
    public boolean createApp(String name) {  
        System.out.println("App["+name+"] has been created.");  
        return true;  
    }  
}
複製程式碼

日誌處理器（實質充當了中介類）

/**
 * 注意需實現Handler介面  
 */
public class LoggerInterceptor implements InvocationHandler {
    private Object target;//目標物件的引用，這裡設計成Object型別，更具通用性  
    public LoggerInterceptor(Object target){  
        this.target = target;  
    }
    
    public Object invoke(Object proxy, Method method, Object[] arg)  throws Throwable {  
        System.out.println("Entered "+target.getClass().getName()+"-"+method.getName()+",with arguments{"+arg[0]+"}");  
        Object result = method.invoke(target, arg);//呼叫目標物件的方法  
        System.out.println("Before return:"+result);  
        return result;  
    }  
}  
複製程式碼

外部呼叫

public class Main {  
    public static void main(String[] args) {  
        AppService target = new AppServiceImpl();//生成目標物件  
        //接下來建立代理物件  
        AppService proxy = (AppService) Proxy.newProxyInstance(  
                target.getClass().getClassLoader(),  
                target.getClass().getInterfaces(), new LoggerInterceptor(target));  
        proxy.createApp("Kevin Test");  
    }  
}  
複製程式碼