設計模式之（8）——代理模式-有解無憂

　　定義：為某個物件提供一個代理，以達到對這個物件的訪問控制，代理類和委托類有共同的父類或者父介面，這樣可以在使用委托類的地方都可以使用代理物件來替換（這符合程式設計中的“里氏替換原則”），代理類負責請求的預處理、過濾等初步處理之后，再將請求分派給委托類進行處理，代理類當然也可以在委托類執行完畢之后做一些其它作業；

　　代理模式根據代理類的生成時間不同可以靜態代理和動態代理，

　　靜態代理：是由程式員創建或工具生成代理類的原始碼,在編譯期就已經確定了委托類和代理類，在程式運行前就已經存在代理類的位元組碼檔案，代理類和委托類的關系在運行前就已經確定了，

　　動態代理：動態代理類的原始碼是在程式運行期間由JVM根據反射等機制動態生成的，所以不存在代理類的位元組碼檔案，代理類和委托類的關系在程式運行時動態確定，

　　說了這么多那么代理有什么優點呢？

　　說起了一大堆，總的來說主要有兩大點：1、可以對客戶端隱藏委托類的實作；2、可以實作客戶端和委托類之間的解耦，在不修改委托類的情況下做一些其他的處理，當然核心業務還得呼叫委托類的方法處理；

　　日常生活中代理的場景很常見，比如說我們有一套房子需要出售，但是我們沒有時間自己天天帶看房，那么我們就可以把這套房子掛委托給房產中介，中介就可以幫我們篩選潛在客戶，帶客戶看房，確定買家之后，中介就聯系我們和買家簽訂合同，買家付款、雙方完成過戶、房屋物業水電燃氣交接事宜等，在這個程序中賣家就是委托類，而中介就是代理類；

　　其實在Java中也有很多場景需要使用代理，如RPC的遠程呼叫，我們就是通過代理類去實作的，還有Spring中的AOP切面也是為切面生成了代理類；

　　下面我們先講講靜態代理的實作：

　　1、定義介面和介面的實作（委托類）；

　　2、定義代理類（定義介面的代理物件）；

　　3、將介面的實體注入到代理物件中，然后通過代理物件去呼叫委托類的實作；

　　靜態代理的示例代碼如下：

package cn.com.pep.model.proxy;
/**
 * 
 * @version: 1.0
 * @Description: 宣告委托類的行為，賣房
 * @author: wwh
 * @date: 2022年9月4日-下午4:17:12
 */
public interface Sell {
    
    public void sellHouse();

}

package cn.com.pep.model.proxy;
/**
 * 
 * @version: 1.0
 * @Description: 委托類
 * @author: wwh
 * @date: 2022年9月4日-下午4:16:45
 */
public class Seller implements Sell{

    public void sellHouse() {
        System.err.println("我是房主，我要賣房");
    }
}

package cn.com.pep.model.proxy;
/**
 * 
 * @version: 1.0
 * @Description: 代理類，和委托類實作共同的介面，
 *                 并通過組合的方式持有一個委托類的參考，核心方法內部還是呼叫委托類來實作，
 *                 這樣就可以對客戶端隱藏委托類的實作，同時也達到了委托類和客戶端解耦的目標；
 * @author: wwh
 * @date: 2022年9月4日-下午3:40:16
 */
public class SellerProxy implements Sell{
    
    private Sell seller;
    
    public SellerProxy(Sell seller) {
        this.seller = seller;
    }
    
    private void lookBuyer() {
        System.err.println("尋找買家，帶買家看房...");
    }

    public void sellHouse() {
        lookBuyer();
        seller.sellHouse();
        getCharge();
    }
    
    private void getCharge() {
        System.err.println("收取中介費");
    }

}

package cn.com.pep.model.proxy;
/**
 * 
 * @version: 1.0
 * @Description: 測驗類
 * @author: wwh
 * @date: 2022年9月4日-下午5:17:45
 */
public class StaticProxyPatternDemo {
    
    public static void main(String[] args) {
        Sell sell = new SellerProxy(new Seller());
        sell.sellHouse();
    }
}

　　通過以上代碼我們也不難發現靜態代理的缺點也很明顯：假設系統中有N個委托類需要代理，那么可能就需要N個代理類，這就容易造成系統的類爆炸，再者假如委托類中的方法很多，那么也可能在代理類中存在大量的重復代碼，所以我們可以看出靜態代理的可復用性不高，那么我們如何解決上面這個問題呢？答案就是動態代理，

　　動態代理分為兩種一種是基于介面的jdk的動態代理，一種是基于繼承的cglib的動態代理，我們先來說說jdk的動態代理，

　　一個JAVA類在JVM中的生命周期分為這幾個程序：加載-》驗證->準備-》決議-》初始化-》使用-》卸載，而其中的加載階段主要完成以下三件事情：

　　1、通過一個類的全限定名來獲取定義此類的二進制流；

　　2、將這個位元組流所代表的靜態資料結構轉換為方法區的運行時資料結構；

　　3、在記憶體中生成一個代表這個類的java.lang.Class物件，作為方法區中這個類的各種資料的訪問入口；

　　而我們要說的動態代理，主要就發生在第一個階段, 這個階段類的二進制位元組流的來源可以有很多, 比如 zip 包、網路、運行時計算生成、其它檔案生成 (JSP)、資料庫獲取，其中運行時計算生成就是我們所說的動態代理技術，在 Proxy 類中, 就是運用了 ProxyGenerator.generateProxyClass 來為特定介面生成形式為 *$Proxy 的代理類的二進制位元組流，所謂的動態代理就是想辦法根據介面或者目標物件計算出代理類的位元組碼然后加載進 JVM 中，實際計算的情況會很復雜，我們借助一些諸如 JDK 動態代理實作；

　　jdk的動態代理是在程式運行時，根據一組介面定義，使用Proxy、InvocationHandler等工具類生成代理物件的實體；　

　　下面是jdk動態代理測驗的demo:　

package cn.com.pep.model.proxy.jdkproxy;
/**
 * 
 * @version: 1.0
 * @Description: 委托類介面
 * @author: wwh
 * @date: 2022年9月4日-下午7:01:48
 */
public interface IService {
    
    public void doSomething();
    
    public void doOtherthing();
}

package cn.com.pep.model.proxy.jdkproxy;
/**
 * 
 * @version: 1.0
 * @Description: 委托類，執行核心的方法
 * @author: wwh
 * @date: 2022年9月4日-下午7:02:57
 */
public class ServiceImpl implements IService{

    public void doSomething() {
        // TODO Auto-generated method stub
        System.err.println("執行doSomething方法");
    }

    public void doOtherthing() {
        // TODO Auto-generated method stub
        System.err.println("執行doOtherthing方法");
    }

}

package cn.com.pep.model.proxy.jdkproxy;

import java.util.Date;

/**
 * 
 * @version: 1.0
 * @Description:
 * @author: wwh
 * @date: 2022年9月4日-下午7:05:51
 */
public class ServiceUtil {

    public static void recoredBegin() {
        System.err.println("方法執行的開始時間是：" + new Date());
    }
}

package cn.com.pep.model.proxy.jdkproxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * 
 * @version: 1.0
 * @Description: 中間類，通過組合持有一個委托類的參考，在invoke()方法中呼叫了委托類的中的目標方法
 * @author: wwh
 * @date: 2022年9月4日-下午7:07:21
 */
public class MyInvocationHandler implements InvocationHandler {
    
    /**
     * 委托類的參考
     */
    private Object target;

    public MyInvocationHandler(Object target) {
        // TODO Auto-generated constructor stub
        this.target = target;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //記錄方法的執行開始時間
        ServiceUtil.recoredBegin();
        System.err.println("開始呼叫invoke()方法啦");
        System.err.println("真正執行的方法是：" + method.getName());
        //真正開始呼叫被代理物件的方法
        Object obj = method.invoke(target, args);
        return obj;
    }

}

package cn.com.pep.model.proxy.jdkproxy;

import java.lang.reflect.Proxy;

/**
 * 
 * @version: 1.0
 * @Description: 測驗類
 * @author: wwh
 * @date: 2022年9月4日-下午7:20:07
 */
public class JDKProxyDemo {

    public static void main(String[] args) {
        IService impl = new ServiceImpl();
        IService proxy = (IService) Proxy.newProxyInstance(impl.getClass().getClassLoader(),
                impl.getClass().getInterfaces(), new MyInvocationHandler(impl));
        proxy.doSomething();
    }
}

　　在以上的測驗代碼中，我們呼叫Proxy類的newProxyInstance()方法來獲取一個代理物件的實體，這個實體實作了我們指定的介面，并且會把方法呼叫分發到我們指定的呼叫處理器MyInvocationHandler中，呼叫invoke()方法，我們在invoke()方法中呼叫委托類的對應方法，并添加上自己的處理邏輯；

　　jdk的動態代理最大的特點是代理類和委托類實作共同的介面，jdk的動態代理內部其實是通過反射機制來實作的，已知一個物件，在運行的時候動態呼叫它的方法，并且在呼叫的時候還可以家上一些自己的邏輯在里面；

　　那假如沒有結構我們該如何實作動態代理呢？這時候我們的cglib動態代理就橫空出世啦，

　　cglib的動態代理是通過一個第三方框架來實作的，所以我們在使用的時候應該引入對應的jar包，例如：

　　其原理大致是：對指定的委托類生成一個子類并重寫其中的業務方法來實作的；

　 cglib的測驗代碼如下：

package cn.com.pep.model.proxy.cglib;
/**
 * 
 * @version: 1.0
 * @Description: 委托類
 * @author: wwh
 * @date: 2022年9月4日-下午8:52:20
 */
public class SayHello {
    
    public void sayHello() {
        System.err.println("目標方法執行了");
    }
}

package cn.com.pep.model.proxy.cglib;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
/**
 * 
 * @version: 1.0
 * @Description: 創建一個攔截器,cglib動態代理，代理類的方法都會被分發到此類中的intercept()方法中
 * @author: wwh
 * @date: 2022年9月4日-下午9:16:07
 */
public class CglibInterceptor implements MethodInterceptor{

    /**
     * obj,表示要增強的物件
     * method，表示攔截的方法
     * args,陣串列示引數串列，基本資料型別需要傳入其包裝型別
     * methodProxy,表示要觸發父類的方法物件
     */
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        before(method.getName());
        /**
         * 在方法的內部主要呼叫的methodProxy.invokeSuper，執行的原始類的方法，如果呼叫invoke方法否會出現死回圈，
         */
        Object result = methodProxy.invokeSuper(obj, args);
        after(method.getName());
        return result;
    }
    
    /**
     * 呼叫invoke方法之前執行
     */
    private void before(String methodName) {
        System.out.println("呼叫方法" + methodName +"之【前】的日志處理");
    }

    /**
     * 呼叫invoke方法之后執行
     */
    private void after(String methodName) {
        System.out.println("呼叫方法" + methodName +"之【后】的日志處理");
    }
}

package cn.com.pep.model.proxy.cglib;

import net.sf.cglib.proxy.Enhancer;

/**
 * 
 * @version: 1.0
 * @Description: 測驗類
 * @author: wwh
 * @date: 2022年9月4日-下午9:29:22
 */
public class CglibDemo {
    
    public static void main(String[] args) {
        //創建一個類增強器
        Enhancer enhancer = new Enhancer();
        //設定類加載器
        enhancer.setClassLoader(enhancer.getClassLoader());
        //設定被代理物件
        enhancer.setSuperclass(SayHello.class);
        //設定方法訪問攔截器
        enhancer.setCallback(new CglibInterceptor());
        //創建代理物件
        SayHello proxy = (SayHello) enhancer.create();
　　　　　//通過代理物件進行方法呼叫
        proxy.sayHello();
    }
}

　　cglib動態代理的創建程序可以總結為以下幾個步驟：

　　1、查找目標類定義的所有非final修飾的public型別的方法；

　　2、將符合條件的方法定義轉換成位元組碼；

　　3、將位元組碼轉換成相應的代理的class物件；

　　4、實作MethodInterceptor介面，用來處理對所有代理方法的攔截；

　　jdk動態代理和cglib動態代理的比較：

　　jdk的動態代理：基于反射來實作，委托類必須實作了介面才能創建代理類，代碼實作簡單，簡化了開發和維護，jdk原生支持，反射速度較慢；

　　cglib的動態代理：基于ASM機制，通過位元組碼技術，通過生成委托類的子類，采用方法攔截的技術來攔截所有弗雷方法的呼叫，織入橫切邏輯，完成代理，并且無需實作介面，達到代理類的無侵入，只關心業務類即可，并且是直接操作位元組碼生成的，速度上有一定的優勢，但是無法對final修飾的方法進行代理，spring全家桶中的很多功能是通過這種方式來實作的；

　　注意事項：

　　1、和配接器模式相比，配接器模式重點在于改變所考慮物件的介面，而代理不能改變所代理物件的介面；

　　2、和裝飾設計模式相比，裝飾設計模式重點在于強調類功能的增強，而代理模式的重點在于物件的訪問控制；

本文來自博客園，作者：一只烤鴨朝北走，僅用于技術學習，所有資源都來源于網路，部分是轉發，部分是個人總結，歡迎共同學習和轉載，轉載請在醒目位置標明原文，如有侵權，請留言告知，及時撤除，轉載請注明原文鏈接：https://www.cnblogs.com/wha6239/p/16650461.html

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/503617.html

標籤：設計模式

上一篇：[設計模式]代理模式、配接器模式與裝飾器模式

下一篇：新零售SaaS架構：商品系統架構設計