Java 代理模式及動態代理

阿新 • • 發佈：2018-12-20

代理

代理是英文 Proxy 翻譯過來的。我們在生活中見到過的代理，大概最常見的就是朋友圈中賣面膜的同學了。

她們從廠家拿貨，然後在朋友圈中宣傳，然後賣給熟人。

這裡寫圖片描述

按理說，顧客可以直接從廠家購買產品，但是現實生活中，很少有這樣的銷售模式。一般都是廠家委託給代理商進行銷售，顧客跟代理商打交道，而不直接與產品實際生產者進行關聯。

所以，代理就有一種中間人的味道。

接下來，我們說說軟體中的代理模式。

代理模式

代理模式是面向物件程式設計中比較常見的設計模式。這裡寫圖片描述

這是常見代理模式常見的 UML 示意圖。

需要注意的有下面幾點： 1. 使用者只關心介面功能，而不在乎誰提供了功能。上圖中介面是 Subject。 2. 介面真正實現者是上圖的 RealSubject，但是它不與使用者直接接觸，而是通過代理。 3. 代理就是上圖中的 Proxy，由於它實現了 Subject 介面，所以它能夠直接與使用者接觸。 4. 使用者呼叫 Proxy 的時候，Proxy 內部呼叫了 RealSubject。所以，Proxy 是中介者，它可以增強 RealSubject 操作。

如果難於理解的話，我用事例說明好了。值得注意的是，代理可以分為靜態代理和動態代理兩種。先從靜態代理講起。

靜態代理

我們平常去電影院看電影的時候，在電影開始的階段是不是經常會放廣告呢？

電影是電影公司委託給影院進行播放的，但是影院可以在播放電影的時候，產生一些自己的經濟收益，比如賣爆米花、可樂等，然後在影片開始結束時播放一些廣告。

現在用程式碼來進行模擬。

首先得有一個介面，通用的介面是代理模式實現的基礎。這個介面我們命名為 Movie，代表電影播放的能力。


package com.frank.test;

public interface Movie {
    void play();
}
 

然後，我們要有一個真正的實現這個 Movie 介面的類，和一個只是實現介面的代理類。
package com.frank.test;

public class RealMovie implements Movie {

    @Override
    public void play() {
        // TODO Auto-generated method stub
        System.out.println("您正在觀看電影 《肖申克的救贖》");
    }

}
這個表示真正的影片。它實現了 Movie 介面，play() 方法呼叫時，影片就開始播放。那麼 Proxy 代理呢？
package 
 com.frank.test;
public class Cinema implements Movie {

    RealMovie movie;

    public Cinema(RealMovie movie) {
        super();
        this.movie = movie;
    }


    @Override
    public void play() {

        guanggao(true);

        movie.play();

        guanggao(false);
    }

    public void guanggao(boolean isStart){
        if ( isStart ) {
            System.out.println("電影馬上開始了，爆米花、可樂、口香糖9.8折，快來買啊！");
        } else {
            System.out.println("電影馬上結束了，爆米花、可樂、口香糖9.8折，買回家吃吧！");
        }
    }

}

Cinema 就是 Proxy 代理物件，它有一個 play() 方法。不過呼叫 play() 方法時，它進行了一些相關利益的處理，那就是廣告。現在，我們編寫測試程式碼。
package com.frank.test;

public class ProxyTest {

    public static void main(String[] args) {

        RealMovie realmovie = new RealMovie();

        Movie movie = new Cinema(realmovie);

        movie.play();

    }

}

然後觀察結果：
電影馬上開始了，爆米花、可樂、口香糖9.8折，快來買啊！
您正在觀看電影 《肖申克的救贖》
電影馬上結束了，爆米花、可樂、口香糖9.8折，買回家吃吧！

現在可以看到，代理模式可以在不修改被代理物件的基礎上，通過擴充套件代理類，進行一些功能的附加與增強。值得注意的是，代理類和被代理類應該共同實現一個介面，或者是共同繼承某個類。
上面介紹的是靜態代理的內容，為什麼叫做靜態呢？因為它的型別是事先預定好的，比如上面程式碼中的 Cinema 這個類。下面要介紹的內容就是動態代理。


動態代理
既然是代理，那麼它與靜態代理的功能與目的是沒有區別的，唯一有區別的就是動態與靜態的差別。

那麼在動態代理的中這個動態體現在什麼地方？

上一節程式碼中 Cinema 類是代理，我們需要手動編寫程式碼讓 Cinema 實現 Movie 介面，而在動態代理中，我們可以讓程式在執行的時候自動在記憶體中建立一個實現 Movie 介面的代理，而不需要去定義 Cinema 這個類。這就是它被稱為動態的原因。
也許概念比較抽象。現在例項說明一下情況。

假設有一個大商場，商場有很多的櫃檯，有一個櫃檯賣茅臺酒。我們進行程式碼的模擬。
package com.frank.test;

public interface SellWine {

     void mainJiu();

}
SellWine 是一個介面，你可以理解它為賣酒的許可證。
package com.frank.test;

public class MaotaiJiu implements SellWine {

    @Override
    public void mainJiu() {
        // TODO Auto-generated method stub
        System.out.println("我賣得是茅臺酒。");

    }

}

然後建立一個類 MaotaiJiu,對的，就是茅臺酒的意思。  
我們還需要一個櫃檯來賣酒：
package com.frank.test;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;


public class GuitaiA implements InvocationHandler {

    private Object pingpai;


    public GuitaiA(Object pingpai) {
        this.pingpai = pingpai;
    }



    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // TODO Auto-generated method stub
        System.out.println("銷售開始  櫃檯是： "+this.getClass().getSimpleName());
        method.invoke(pingpai, args);
        System.out.println("銷售結束");
        return null;
    }

}

GuitaiA 實現了 InvocationHandler 這個類，這個類是什麼意思呢？大家不要慌張，待會我會解釋。

然後，我們就可以賣酒了。
package com.frank.test;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;


public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        MaotaiJiu maotaijiu = new MaotaiJiu();


        InvocationHandler jingxiao1 = new GuitaiA(maotaijiu);


        SellWine dynamicProxy = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(),
                MaotaiJiu.class.getInterfaces(), jingxiao1);

        dynamicProxy.mainJiu();

    }

}


這裡，我們又接觸到了一個新的概念，沒有關係，先別管，先看結果。
銷售開始  櫃檯是： GuitaiA
我賣得是茅臺酒。
銷售結束

看到沒有，我並沒有像靜態代理那樣為 SellWine 介面實現一個代理類，但最終它仍然實現了相同的功能，這其中的差別，就是之前討論的動態代理所謂“動態”的原因。

動態代理語法
放輕鬆，下面我們開始講解語法，語法非常簡單。

動態程式碼涉及了一個非常重要的類 Proxy。正是通過 Proxy 的靜態方法 newProxyInstance 才會動態建立代理。

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

下面講解它的 3 個引數意義。

loader 自然是類載入器

interfaces 程式碼要用來代理的介面

h 一個 InvocationHandler 物件

初學者應該對於 InvocationHandler 很陌生，我馬上就講到這一塊。

InvocationHandler

InvocationHandler 是一個介面，官方文件解釋說，每個代理的例項都有一個與之關聯的 InvocationHandler 實現類，如果代理的方法被呼叫，那麼代理便會通知和轉發給內部的 InvocationHandler 實現類，由它決定處理。

public interface InvocationHandler {

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

InvocationHandler 內部只是一個 invoke() 方法，正是這個方法決定了怎麼樣處理代理傳遞過來的方法呼叫。

proxy 代理物件
method 代理物件呼叫的方法
args 呼叫的方法中的引數

因為，Proxy 動態產生的代理會呼叫 InvocationHandler 實現類，所以 InvocationHandler 是實際執行者。

public class GuitaiA implements InvocationHandler {
    private Object pingpai;


    public GuitaiA(Object pingpai) {
        this.pingpai = pingpai;
    }



    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // TODO Auto-generated method stub
        System.out.println("銷售開始  櫃檯是： "+this.getClass().getSimpleName());
        method.invoke(pingpai, args);
        System.out.println("銷售結束");
        return null;
    }

}

GuitaiA 就是實際上賣酒的地方。

現在，我們加大難度，我們不僅要賣茅臺酒，還想賣五糧液。

package com.frank.test;

public class Wuliangye implements SellWine {

    @Override
    public void mainJiu() {
        // TODO Auto-generated method stub
        System.out.println("我賣得是五糧液。");

    }

}

Wuliangye 這個類也實現了 SellWine 這個介面，說明它也擁有賣酒的許可證，同樣把它放到 GuitaiA 上售賣。

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        MaotaiJiu maotaijiu = new MaotaiJiu();

        Wuliangye wu = new Wuliangye();

        InvocationHandler jingxiao1 = new GuitaiA(maotaijiu);
        InvocationHandler jingxiao2 = new GuitaiA(wu);

        SellWine dynamicProxy = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(),
                MaotaiJiu.class.getInterfaces(), jingxiao1);
        SellWine dynamicProxy1 = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(),
                MaotaiJiu.class.getInterfaces(), jingxiao2);

        dynamicProxy.mainJiu();

        dynamicProxy1.mainJiu();

    }

}

我們來看結果：

銷售開始  櫃檯是： GuitaiA
我賣得是茅臺酒。
銷售結束
銷售開始  櫃檯是： GuitaiA
我賣得是五糧液。
銷售結束

有人會問，dynamicProxy 和 dynamicProxy1 什麼區別沒有？他們都是動態產生的代理，都是售貨員，都擁有賣酒的技術證書。

我現在擴大商場的經營，除了賣酒之外，還要賣煙。

首先，同樣要建立一個介面，作為賣煙的許可證。

package com.frank.test;

public interface SellCigarette {
    void sell();
}

然後，賣什麼煙呢？我是湖南人，那就芙蓉王好了。

public class Furongwang implements SellCigarette {

    @Override
    public void sell() {
        // TODO Auto-generated method stub
        System.out.println("售賣的是正宗的芙蓉王，可以掃描條形碼查證。");
    }

}

然後再次測試驗證：

package com.frank.test;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;


public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        MaotaiJiu maotaijiu = new MaotaiJiu();

        Wuliangye wu = new Wuliangye();

        Furongwang fu = new Furongwang();

        InvocationHandler jingxiao1 = new GuitaiA(maotaijiu);
        InvocationHandler jingxiao2 = new GuitaiA(wu);

        InvocationHandler jingxiao3 = new GuitaiA(fu);

        SellWine dynamicProxy = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(),
                MaotaiJiu.class.getInterfaces(), jingxiao1);
        SellWine dynamicProxy1 = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(),
                MaotaiJiu.class.getInterfaces(), jingxiao2);

        dynamicProxy.mainJiu();

        dynamicProxy1.mainJiu();

        SellCigarette dynamicProxy3 = (SellCigarette) Proxy.newProxyInstance(Furongwang.class.getClassLoader(),
                Furongwang.class.getInterfaces(), jingxiao3);

        dynamicProxy3.sell();

    }

}

然後，檢視結果：

銷售開始  櫃檯是： GuitaiA
我賣得是茅臺酒。
銷售結束
銷售開始  櫃檯是： GuitaiA
我賣得是五糧液。
銷售結束
銷售開始  櫃檯是： GuitaiA
售賣的是正宗的芙蓉王，可以掃描條形碼查證。
銷售結束

結果符合預期。大家仔細觀察一下程式碼，同樣是通過 Proxy.newProxyInstance() 方法，卻產生了 SellWine 和 SellCigarette 兩種介面的實現類代理，這就是動態代理的魔力。

代理的作用

可能有同學會問，已經學習了代理的知識，但是，它們有什麼用呢？

主要作用，還是在不修改被代理物件的原始碼上，進行功能的增強。

這在 AOP 面向切面程式設計領域經常見。

在軟體業，AOP為Aspect Oriented Programming的縮寫，意為：面向切面程式設計，通過預編譯方式和執行期動態代理實現程式功能的統一維護的一種技術。AOP是OOP的延續，是軟體開發中的一個熱點，也是Spring框架中的一個重要內容，是函數語言程式設計的一種衍生範型。利用AOP可以對業務邏輯的各個部分進行隔離，從而使得業務邏輯各部分之間的耦合度降低，提高程式的可重用性，同時提高了開發的效率。

主要功能日誌記錄，效能統計，安全控制，事務處理，異常處理等等。

上面的引用是百度百科對於 AOP 的解釋，至於，如何通過代理來進行日誌記錄功能、效能統計等等，這個大家可以參考 AOP 的相關原始碼，然後仔細琢磨。

同註解一樣，很多同學可能會有疑惑，我什麼時候用代理呢？

這取決於你自己想幹什麼。你已經學會了語法了，其他的看業務需求。對於實現日誌記錄功能的框架來說，正合適。

至此，靜態代理和動態代理者講完了。

總結

代理分為靜態代理和動態代理兩種。
靜態代理，代理類需要自己編寫程式碼寫成。
動態代理，代理類通過 Proxy.newInstance() 方法生成。
不管是靜態代理還是動態代理，代理與被代理者都要實現兩樣介面，它們的實質是面向介面程式設計。
靜態代理和動態代理的區別是在於要不要開發者自己定義 Proxy 類。
動態代理通過 Proxy 動態生成 proxy class，但是它也指定了一個 InvocationHandler 的實現類。
代理模式本質上的目的是為了增強現有程式碼的功能。

Java 代理模式及動態代理

代理

代理模式

靜態代理

動態代理

動態代理語法

Proxy

InvocationHandler

代理的作用

總結

輕松學Java 中的代理模式及動態代理

Java 中的代理模式及動態代理

Java 代理模式及動態代理

輕鬆學，Java 中的代理模式及動態代理

Java設計模式---代理模式(二)---動態代理

Java設計模式之代理模式的動態代理

Java設計模式之代理模式的動態代理下篇

Java代理模式之動態代理

java設計模式之動態代理的概述和實現

java代理模式和動態代理

Java設計模式-代理模式之動態代理(附原始碼分析)

Java的三種代理模式(Spring動態代理物件)

java類載入及動態代理之位元組碼插莊技術

java設計模式：動態代理模式 Proxy

java設計模式之代理模式（動態代理）

設計模式_代理模式_動態代理

設計模式之禪學習筆記09--代理模式（動態代理）

設計模式--代理模式（動態代理）

設計模式之代理模式（動態代理）

輕鬆學，Java 中的代理模式（proxy）及動態代理

Java 代理模式及動態代理

代理

代理模式

靜態代理

動態代理

動態代理語法

Proxy

InvocationHandler

代理的作用

總結

相關推薦