Java 中的動態代理

1、概述

1. 什麼是代理

　　咱們你們都知道微商代理，簡單地說就是代替廠家賣商品，廠家「委託」代理爲其銷售商品。關於微商代理，首先咱們從他們那裏買東西時一般不知道背後的廠家到底是誰，也就是說，「委託者」對咱們來講是不可見的;其次，微商代理主要以朋友圈的人爲目標客戶，這就至關於爲廠家作了一次對客戶羣體的「過濾」。咱們把微商代理和廠家進一步抽象，前者可抽象爲代理類，後者可抽象爲委託類(被代理類)。經過使用代理，一般有兩個優勢，而且可以分別與咱們提到的微商代理的兩個特色對應起來：

　　優勢一：能夠隱藏委託類(被代理類)的實現;

　　優勢二：能夠實現客戶與委託類間的解耦，在不修改委託類代碼的狀況下可以作一些額外的處理。

2. 靜態代理

　　若代理類在程序運行前就已經存在，那麼這種代理方式被成爲 靜態代理 ，這種狀況下的代理類一般都是咱們在Java代碼中定義的。 一般狀況下， 靜態代理中的代理類和委託類會實現同一接口或是派生自相同的父類。 下面咱們用Vendor類表明生產廠家，BusinessAgent類表明微商代理，來介紹下靜態代理的簡單實現，委託類和代理類都實現了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 Vendor implements Sell { public void sell() { System.out.println("In sell method"); } public void ad() { System.out.println("ad method"); } }

　　從BusinessAgent類的定義咱們能夠了解到，靜態代理能夠經過聚合來實現，讓代理類持有一個委託類的引用便可。

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

public class BusinessAgent implements Sell { ... public void sell() { if (isCollegeStudent()) { vendor.sell(); } } ... } 

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

2、動態代理

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. 使用動態代理

(1)InvocationHandler接口

在使用動態代理時，咱們須要定義一個位於代理類與委託被代理()類之間的中介類，這個中介類被要求實現InvocationHandler接口，這個接口的定義以下：

public interface InvocationHandler {

    Object invoke(Object proxy, Method method, Object[] args);

}

　　從InvocationHandler這個名稱咱們就能夠知道，實現了這個接口的中介類用作「調用處理器」。當咱們調用代理類對象的方法時，這個「調用」會轉送到invoke方法中，代理類對象做爲proxy參數傳入，參數method標識了咱們具體調用的是代理類的哪一個方法，args爲這個方法的可變參數(能夠有0個,1個,2個,...,N個)。這樣一來，咱們對代理類中的全部方法的調用都會變爲對invoke的調用，這樣咱們能夠在invoke方法中添加統一的處理邏輯(也能夠根據method參數對不一樣的代理類方法作不一樣的處理)。所以咱們只需在中介類的invoke方法實現中輸出「before」，而後調用委託類的invoke方法，再輸出「after」。下面咱們來一步一步具體實現它。

(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");

    }

}

(3)中介類

上面咱們提到過，中介類必須實現InvocationHandler接口，做爲調用處理器」攔截「對代理類方法的調用。中介類的定義以下：

public class DynamicProxy implements InvocationHandler {

    private Object obj; // 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的調用最終都轉爲對委託(被代理)類對象的調用。這不就是咱們上面介紹的靜態代理的一種實現方式嗎?實際上，中介類與委託(被代理)類構成了靜態代理關係，在這個關係中，中介類是代理類，委託(被代理)類就是委託(被代理)類; 代理類與中介類也構成一個靜態代理關係，在這個關係中，中介類是委託(被代理)類，代理類是代理類。也就是說，動態代理關係由兩組靜態代理關係組成，這就是動態代理的原理。下面咱們來介紹一下如何」指示「以動態生成代理類。

(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; } }

日誌處理器

public class LoggerInterceptor implements InvocationHandler {// 注意實現這個Handler接口
    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"); } }