設計模式之（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