[[407965]]

設計模式已經跟大家分享很多了常見的模式了，感興趣的小伙伴可以再回顧一下，鞏固一下理解。

這次要跟大家分享的是設計模式中三大類創建型中的代理模式，代理模式在業務場景上我們可能不會經常用到，但是面試官卻會經常問一個問題?

請你跟我講講Spring里面AOP的代理模式?jdk的代理模式和cglib的代理模式又啥區別?

清楚和不清楚的同學都可以接著向下看，一定會有收獲。

言歸正傳，接下來開始一步一步分析一下代理模式。

定義以及目的

首先代理模式可以分為多種類型

• 遠程代理：就是將工作委托給遠程對象(不同的服務器，或者不同的進程)來完成。常見的是用在web Service中。還有就是我們的RPC調用也可以理解為一種遠程代理。
• 保護代理：該模式主要進行安全/權限檢查。(接觸很少)
• 緩存代理：這個很好理解，就是通過存儲來加速調用，比如Sping中的@Cacheable方法，緩存特定的參數獲取到的結果，當下次相同參數調用該方法，直接從緩存中返回數據。
• 虛擬代理：這種代理主要是為方法增加功能，比如記錄一些性能指標等，或進行延遲初始化

上面只是我們作為了解的概念，接下來再看看代理模式有哪些部分構成。

• Subject(共同接口)：客戶端使用的現有接口
• RealSubject(真實對象)：真實對象的類
• ProxySubject(代理對象)：代理類

從圖中可以看出其實整個接口還是很簡單，就是一個真實對象以及代理對象。

• 目的：提供一個實際代理對象，以便更好的控制實際對象。以上定義來自《設計模式之美》

代碼舉例實現

為了方便理解，還是舉一個例子，不知道大家在讀初中或者高中是否經歷過傳小紙條的過程，假如現在同學A 對同學C有一些話想聊(比如放學相約一起打游戲)但是因為現在是上課時間，又不能大聲說，同學A和同學C之間坐了一個同學B，所以現在同學A只能是先找到同學B把紙條給它，讓他轉告同學C，但是去玩還是不是不去玩，那還是只能真正的同學C自己才能決定。

所以代理模式可以理解為 同學B是同學的C的代理，同學A要找同學C，只能找到同學B，通過同學B轉達同學C，同時將同學的C的執行結果反饋給同學A。

說完了例子還是具體看看代碼的實現吧

public interface Subject { 
   // 共同的接口 
    void doSomething(); 
} 

定義一個共同的接口(即大家要做的事請：放學一起打游戲)

public class RealSubject implements Subject { 
   // 真實對象 
    @Override 
    public void doSomething() { 
        System.out.println("放學去打游戲"); 
    } 
} 

構建一個真實對象，即例子中的同學C

public class ProxySubject implements Subject { 
 
    private RealSubject realSubject; 
 
    public ProxySubject(RealSubject realSubject) { 
        this.realSubject = realSubject; 
    } 
 
    public ProxySubject() throws ClassNotFoundException, IllegalAccessException, InstantiationException { 
        this.realSubject = (RealSubject) this.getClass().getClassLoader().loadClass("com.ao.bing.demo.proxyPattern.RealSubject").newInstance(); 
    } 
 
    @Override 
    public void doSomething() { 
        realSubject.doSomething(); 
    } 
 
 
    public static void main(String[] args) { 
 
        try { 
            // 第一種方式 
            new ProxySubject().doSomething(); 
            // 打印結果： 放學去打游戲 
        } catch (Exception e) { 
            // 異常情況，代理失敗， 
            // 傳紙條的被老師抓了。或者同學C不在座位上了 等異常情況 
        } 
 
        // 第二種方式 
        new ProxySubject(new RealSubject()).doSomething(); 
        // 打印結果： 放學去打游戲 
    } 
} 

構建代理對象，即同學B，那么可以看到同學A并沒有真實接觸到同學C，通過同學B對同學C的代理就能知道同學C放學能不能跟他一起去打游戲

在Main方法里面，有兩種方式來調用真實對象

• 第一種：采用類加載器形式，去加載實列對象，這樣我們就不同關心到底什么時候需要真實的實列化對象
• 第二種：通過傳值的形式，把實列化對象傳過來。(理解為裝飾器模式了)

這里大家要區別一下，代理模式是提供完全相同的接口，而裝飾器模式是為了增強接口。

靜態代理、動態代理和cglib代理分析

靜態代理

在上面的舉的列子實現其實就是靜態代理，大家可以看到整體也比較簡單。但是它的缺點也很明顯

靜態代理需要為每一個對象都創建一個代理類，增加了維護成本以及開發成本，那么為了解決這個問題，動態代理就出來了，不要再固定為每一個需要代理的類而創建一個代理類

動態代理

動態代理合理的避免了靜態代理的那種方式，不用事先為要代理的類而構建好代理類。而是在運行時通過反射機制創建。

在寫動態代理事需要理解兩個東西：Proxy 可以理解為就是調度器，InvocationHandler 增強服務接口可以理解為代理器。所以我個人理解動態代理其實就是一種行為的監聽。

具體的代碼實現舉一個例子：螳螂捕蟬，通過通過螳螂監聽到蟬的動作。方便后面講到多級代理模式。

public interface BaseService { 
    void mainService(); 
} 
 
public class Cicada implements BaseService { 
    @Override 
    public void mainService() { 
        System.out.println("主要業務，以蟬為例，當蟬出現業務調用時，螳螂監聽到"); 
    } 
} 

創建共同接口，以及真實對象蟬

public class PrayingMantis implements InvocationHandler { 
 
    private BaseService baseService; 
 
  // 這里采用的是構建傳參數，可以用反射，舉的第一個例子有樣式代碼 
    public PrayingMantis(BaseService baseService) { 
        this.baseService = baseService; 
    } 
 
    // 螳螂主要業務，也就是監聽對象 
    @Override 
    public Object invoke(Object listener, Method method, Object[] args) throws Throwable { 
        method.invoke(baseService,args); 
        secondaryMain(); 
        return null; 
    } 
    // 這里理解增強業務，即我們可以在實現InvocationHandler里面添加其他的業務，比如日志等等。 
    private void secondaryMain(){ 
        System.out.println("螳螂捕蟬 - 次要業務"); 
    } 
} 

創建螳螂類，監聽著蟬的類的動作

public class BeanFactory { 
 
    public static BaseService newInstanc(Class classFile) { 
        // 1. 創建蟬，真實類對象 
        BaseService trueCicada = new Cicada(); 
        // 2.創建代理類 螳螂 
        InvocationHandler prayingMantis = new PrayingMantis(trueCicada); 
        // 3.向Jvm索要代理對象 其實就是監聽的對象， 
        Class classArray[] = {BaseService.class}; 
        BaseService baseService = (BaseService) Proxy.newProxyInstance(classFile.getClassLoader(), classArray, prayingMantis); 
        return baseService; 
    } 
   
   // 測試Demo 
    public static void main(String[] args) { 
        BaseService baseService  = newInstanc(Cicada.class); 
        baseService.mainService(); 
        // 測試結果 ：主要業務 
        //           螳螂捕蟬 - 次要業務 
    } 
} 

通過結果可以看出當蟬主要業務發生調用時，螳螂能監聽到蟬的業務并且能處理其他業務邏輯，這也就是Spring里面AOP為什么能處理日志切面等。

代理的本質：

• 我認為其實就是一種行為的監聽，對代理對象($proxy InvocationHandler)的一種監聽行為。

代理模式組成：

• 接口：聲明需要被監聽行為
• 代理實現類(InvocationHandler):次要業務，次要業務和主要業務綁定執行
• 代理對象(監聽對象)
• Cglib動態代理

cglib動態代理

其實和jdk的動態代理是很相似的，都是要去實現代理器接口完成。

具體代碼如下：

public class PrayingMantis implements MethodInterceptor { 
 
    private Cicada cicada;// 代理對象 
 
    public Cicada getInstance(Cicada cicada) { 
        this.cicada = cicada; 
        Enhancer enhancer = new Enhancer(); 
        enhancer.setSuperclass(this.cicada.getClass()); 
        enhancer.setCallback(this); 
        return (Cicada) enhancer.create(); 
    } 
 
    @Override 
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { 
        Object object = methodProxy.invokeSuper(o, objects); 
        secondaryMain(); 
        return object; 
    } 
 
    private void secondaryMain() { 
        System.out.println("螳螂捕蟬 - 次要業務"); 
    } 
 
    public static void main(String[] args) { 
        PrayingMantis prayingMantis = new PrayingMantis(); 
        Cicada instance = prayingMantis.getInstance(new Cicada()); 
        instance.mainService(); 
        // 結果：主要業務 
        //      螳螂捕蟬 - 次要業務 
    } 

因為蟬類都是一樣的所以我就不單獨這里再貼出來。

細心的同學已經發現，Cglib 無需通過接口來實現，它是通過實現子類的方式來完成調用的。

• Enhancer 對象把代理對象設置為被代理類的子類來實現動態代理的。因為是采用繼承方式，所以代理類不能加final修飾，否則會報錯。
• final類：類不能被繼承，內部的方法和變量都變成final類型

JDK和Cglib的區別：

• jdk動態代理是利用反射機制生成一個實現代理接口的匿名類，在調用具體方法前調用InvokeHandler來處理
• cglib動態代理是利用ASM開源包，對被代理對象類的class文件加載進來，通過修改其字節碼生成子類來處理
• ASM: 一個 Java 字節碼操控框架。它能被用來動態生成類或者增強既有類的功能。ASM 可以直接產生二進制 class 文件，也可以在類被加載入 Java 虛擬機之前動態改變類行為。Java class 被存儲在嚴格格式定義的 .class 文件里，這些類文件擁有足夠的元數據來解析類中的所有元素：類名稱、方法、屬性以及 Java 字節碼(指令)。ASM 從類文件中讀入信息后，能夠改變類行為，分析類信息，甚至能夠根據用戶要求生成新類。 -- 以上ASM解釋來自簡書

多級動態代理

看完上面的動態代理，不知道大家有沒有想法，實現一個多級動態代理。

還是以螳螂捕蟬為例子，再加上一個黃雀在后，實現多級動態代理模式。

public class Cardinal implements InvocationHandler { 
  // 監聽代理代理對象 
    private Object proxyOne; 
 
    public Cardinal(Object proxyOne) { 
        this.proxyOne = proxyOne; 
    } 
 
    // 螳螂主要業務，也就是監聽對象 
    @Override 
    public Object invoke(Object proxy, Method method, Object[] args) throws            Throwable { 
        method.invoke(proxyOne, args); 
        secondaryMain(); 
        return null; 
    } 
    private void secondaryMain() { 
        System.out.println("黃雀吃螳螂 - 次要業務"); 
    } 
} 

創建一個黃雀代理對象，那作為他的真實對象就變成螳螂了，當螳螂對象發生調用時，黃雀就能堅挺到，同時作出對應業務邏輯

public class BeanFactory { 
 
    public static BaseService newInstanc(Class classFile) { 
        // 1. 創建蟬，真實類對象 
        BaseService trueCicada = new Cicada(); 
 
        // 2.創建代理類 螳螂 
        InvocationHandler prayingMantis = new PrayingMantis(trueCicada); 
 
        // 3.向Jvm索要代理對象 其實就是堅挺的對象 
        Class classArray[] = {BaseService.class}; 
        BaseService baseService = (BaseService) Proxy.newProxyInstance(classFile.getClassLoader(), classArray, prayingMantis); 
 
        // 4.創建代理實現類 黃雀 二級代理 
        InvocationHandler cardinal = new Cardinal(baseService); 
        BaseService secondBaseService = (BaseService) Proxy.newProxyInstance(classFile.getClassLoader(), classArray, cardinal); 
         
       // 假設要實現三級，四級代理，則在黃雀類上再加一層代理即可實現。 
       // 省略其他的更多級代理對象 
        return secondBaseService; 
    } 
   
     // 測試demo 
      public static void main(String[] args) { 
        BaseService baseService  = BeanFactory.newInstanc(Cicada.class); 
        baseService.mainService(); 
        // 結果：主要業務 
        //      螳螂捕蟬 - 次要業務 
        //      黃雀吃螳螂 - 次要業務 
    } 
} 

根據這個代碼基本就實現多級代理過程。螳螂監聽著蟬類的動作，黃雀監聽著螳螂類的動作。

同樣的如果要實現三級代理，四級代理也就不是什么難事了，在每一層的上面再加一個代理對象就可以了。

• 動態代理本質還是可以理解為將“次要業務”與“主要業務”解耦合，讓開發者能更加專注于主要業務，提升開發效率，以及維護成本。

總結

代理模式在業務代碼上我個人認為是比較少見的，特別是動態代理基本上是沒有見過。但是代理模式也是我們必須要理解的一種模式，因為學習好代理模式有助于我們去讀一些源碼，排查一些更深層次的問題，或者面對一些業務場景問題，也能有一個很大的提升，設計模式本身也就是為了解決問題而創建出來的。

理解完動態代理現在對我們來說AOP的實現原理也就不言而喻了。

詳細的設計模式到這里就結束了，后面針對一些不常見設計模式我還是會給大家做一個總結吧。

我是敖丙，你知道的越多，你不知道的越多，我們下期見!!!