設計模式之代理模式-有解無憂

本文由老王出租房子引出——代理設計模式，將從最簡單的靜態代理實作開始，后延伸使用jdk實作動態代理，最后擴展到Cglib實作動態代理，為了更深入理解代理模式，我們會對實際應用中的典型案例進行介紹，包括在Spring和Mybatis中的應用，

讀者可以拉取完整代碼到本地進行學習，實作代碼均測驗通過后上傳到碼云，

一、引出問題

上篇文章老王和小王組裝電腦雖然完美結束了，但是老王和小王的爭吵卻并沒有結束，老王決定將小王掃地出門，并把小王住的房子出租，租金用來彌補游戲本的花銷，

老投訓費很大的功夫，搞清楚了各種租房平臺的規則并發布了房源資訊，接著鄰居提醒他：房子租出去并不代表躺著收租金了，有一天租客提出一些額外的要求，在合同允許的范圍內，你也要盡量滿足他們（為了便于理解，現實當然不存在啦），房子租出去后物業有問題你還要和物業協調，

老王開始思考，如果我直租給租客，會面臨兩個問題：

①我需要了解租房的全程序，我自己的事和租房的事嚴重的耦合了，

②租客提出的一些要求我不得不介入到其中，我不得不改變我自己的行程安排，

我應該想到一種辦法，

第一點，將業務和功能解耦，業務層專注業務，比如網路介面請求，業務層只需要知道該調哪個介面請求方法，而不需要知道這個介面請求是如何發起網路請求的，

第二點，創建一個切面，在這個切面中增加一些通用的附加操作，比如注解決議，日志上報等，避免這些通用操作在每個介面方法都要寫一遍，

老王靈感一閃：我可以給我的房子找一個一個代理，以控制對這個房子的管理，即通過代理管理房子.這樣做的好處是:可以在目標實作的基礎上,增強額外的功能操作,即擴展目標的功能，

這實際上就是靜態代理，

二、靜態代理

代理模式：為一個物件提供一個替身，以控制對這個物件的訪問，即通過代理物件訪問目標物件.這樣做的好處是:可以在目標物件實作的基礎上,增強額外的功能操作,即擴展目標物件的功能，

也即在靜態代理中應該有三個角色：

①代理物件，消費端通過它來訪問實際的物件（中介）

②實際被代理的物件（老王房子）

③一組可以被代理的行為的集合，通常是一個介面（老王和中介之間的約定事件）

老王與中介的約定介面：

/**
 * 代理行為的集合（介面）
 * @author tcy
 * @Date 02-08-2022
 */
public interface HostAgreement {

    // 房子出租
    void rent();
}

實際物件類（老王）：

/**
 * 目標物件
 * @author tcy
 * @Date 02-08-2022
 */
public class Host implements HostAgreement {

    /**
     * 目標物件的原始方法
     */
    @Override
    public void rent() {
        System.out.println(" 這個房子要出租...");
    }
}

代理類（中介）：

/**
 * 實際物件的代理
 * @author tcy
 * @Date 02-08-2022
 */
public class HostProxy implements HostAgreement {

    // 目標物件，通過介面來聚合
    private HostAgreement target;

    //構造器
    public HostProxy(HostAgreement target) {
        this.target = target;
    }

    @Override
    public void rent() {
        System.out.println("房子出租前，裝修一下....");
        target.rent();
        System.out.println("房子出租后，與物業協調....");//方法
    }

}

客戶類：

/**
 * @author tcy
 * @Date 02-08-2022
 */
public class Client {

    public static void main(String[] args) {
        //創建目標物件(被代理物件)
        Host hostTarget = new Host();
        //創建代理物件, 同時將被代理物件傳遞給代理物件
        HostProxy hostProxy = new HostProxy(hostTarget);
        //通過代理物件，呼叫到被代理物件的方法
        hostProxy.rent();
    }

}

這樣就很好的解決了老王想到的問題，老王心滿意足的看著自己的成果，

但中介看著老王的方案開始小聲的嘀咕了，我一個人管那么多的房子，每一個房東都讓我實作一個代理類，那我就會有很多的代理類，這是個問題呀！還有就是，有一天協議變動了，我們倆都要做許多作業，

最好是不要讓我實作我們之間的協議（介面）了，

老王開始改造他的方案了，

三、動態代理Jdk

老王突然想到，使用jdk的動態代理可以很好的解決這個問題，

Jdk代理物件的生成，是利用JDK的API，動態的在記憶體中構建代理物件動態代理，也叫做：JDK代理、介面代理，

我們對代碼進行改造，

目標物件和目標物件的協議保持不變，我們需要修改也就是中介（代理類）的代碼，

代理類：

/**
 * 代理類
 * @author tcy
 * @Date 02-08-2022
 */
public class HostProxy {

    //維護一個目標物件 , Object
    private Object target;

    //構造器 ， 對target 進行初始化
    public HostProxy(Object target) {

        this.target = target;
    }

    //給目標物件 生成一個代理物件
    public Object getProxyInstance() {

        //說明
      /*
       *  //1. ClassLoader loader ： 指定當前目標物件使用的類加載器, 獲取加載器的方法固定
            //2. Class<?>[] interfaces: 目標物件實作的介面型別，使用泛型方法確認型別
            //3. InvocationHandler h : 事情處理，執行目標物件的方法時，會觸發事情處理器方法, 會把當前執行的目標物件方法作為引數傳入
       */
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {

                    /**
                     * 該方法會呼叫目標物件的方法
                     * @param proxy
                     * @param method
                     * @param args
                     * @return
                     * @throws Throwable
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("房子出租前，裝修一下....");
                        //反射機制呼叫目標物件的方法
                        Object returnVal = method.invoke(target, args);
                        System.out.println("房子出租后，與物業協調....");
                        return returnVal;
                    }
                });
    }

}

客戶端：

/**
 * @author tcy
 * @Date 02-08-2022
 */
public class Client {

    public static void main(String[] args) {

        //創建目標物件
        HostAgreement hostAgreement = new Host();
        //給目標物件，創建代理物件, 可以轉成 ITeacherDao
        HostAgreement hostProxy = (HostAgreement)new HostProxy(hostAgreement).getProxyInstance();
        // proxyInstance=class com.sun.proxy.$Proxy0 記憶體中動態生成了代理物件
        //通過代理物件，呼叫目標物件的方法
        hostProxy.rent();
    }

}

這樣就很好的解決了中介實作協議（介面）的問題，無論房子怎么變化，中介都能很完美的實作代理，

中介想讓老王給他講講，Proxy.newProxyInstance（）怎么就能完美的解決這個問題了，

老王擼起袖子開始給他講實作原理，

在我們用Proxy.newProxyInstance實作動態代理的時候，有三個引數，第一個便是classloader，

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

在我們的代碼中classloader就是目標物件的類加載器，

第二個引數是目標物件實作的介面型別，使用泛型方法確認型別，我們使用java的反射target.getClass().getInterfaces()獲取到了介面型別，

第三個引數是實作InvocationHandler介面，并實作它唯一的方法invoke()，invoke其實就會執行我們的目標方法，我們就可以在invoke前后去做一些事，比如，房子出租前，裝修一下或者房子出租后，與物業協調，

中介聽完心滿意足的離開了，老王總覺得哪里不對，中介都從協議中抽出來了，那我為什么還要被協議約束著呢？我何不也從協議（介面）中抽離出來，

我們查閱書籍覺得Cglib或許能幫到他，

四、動態代理Cglib

1、概念及實作

CGLIB是一個強大的、高性能的代碼生成庫，采用非常底層的位元組碼技術，對指定目標類生成一個子類，并對子類進行增強，其被廣泛應用于AOP框架（Spring、dynaop）中，用以提供方法攔截操作，

CGLIB代理主要通過對位元組碼的操作，為物件引入間接級別，以控制物件的訪問，我們知道Java中有一個動態代理也是做這個事情的，那我們為什么不直接使用Java動態代理，而要使用CGLIB呢？答案是CGLIB相比于JDK動態代理更加強大，JDK動態代理雖然簡單易用，但是其有一個致命缺陷是，只能對介面進行代理，如果要代理的類為一個普通類、沒有介面，那么Java動態代理就沒法使用了，

老王覺得這些概念都不說人話，不如老王直接著手改造專案，

CGLIB是一個第三方的類別庫，首先需要引入依賴，

<dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>2.2.2</version>
</dependency>

現在只需要兩個角色即可，代理類和目標類，

目標類：

/**
 * @author tcy
 * @Date 02-08-2022
 */
public class Host {
    /**
     * 租房方法
     */
    public void rent() {

        System.out.println("這個房子要出租...");

    }
}

代理類：

/**
 * 代理類
 * @author tcy
 * @Date 02-08-2022
 */
public class HostProxy implements MethodInterceptor {

    //維護一個目標物件
    private Object target;

    //構造器，傳入一個被代理的物件
    public HostProxy(Object target) {
        this.target = target;
    }

    //回傳一個代理物件:  是 target 物件的代理物件
    public Object getProxyInstance() {
        //1. 創建一個工具類
        Enhancer enhancer = new Enhancer();
        //2. 設定父類
        enhancer.setSuperclass(target.getClass());
        //3. 設定回呼函式
        enhancer.setCallback(this);
        //4. 創建子類物件，即代理物件
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

        System.out.println("房子出租前，裝修一下....");
        Object returnVal = method.invoke(target, args);
        System.out.println("房子出租后，與物業協調....");
        return returnVal;

    }

}

客戶類：

/**
 * @author tcy
 * @Date 02-08-2022
 */
public class Client {
    public static void main(String[] args) {

        //創建目標物件
        Host HostTarget = new Host();
        //獲取到代理物件，并且將目標物件傳遞給代理物件
        Host Hostproxy = (Host)new HostProxy(HostTarget).getProxyInstance();
        //執行代理物件的方法，觸發intecept 方法，從而實作 對目標物件的呼叫
        Hostproxy.rent();
    }

}

現在不僅老王和中介都不需要實作介面了，而且完美的實作了他們之間的功能，

jdk和CGLIB實作動態代理的區別我們對比一下：

2、JDK動態代理與CGLIB對比

JDK動態代理：基于Java反射機制實作，必須要實作了介面的業務類才生成代理物件，

CGLIB動態代理：基于ASM機制實作，通過生成業務類的子類作為代理類，

JDK Proxy的優勢：

最小化依賴關系、代碼實作簡單、簡化開發和維護、JDK原生支持，比CGLIB更加可靠，隨JDK版本平滑升級，而位元組碼類別庫通常需要進行更新以保證在新版Java上能夠使用，

基于CGLIB的優勢：

無需實作介面，達到代理類無侵入，只操作關心的類，而不必為其他相關類增加作業量，高性能，

靜態代理和JDK代理模式都要求目標物件是實作一個介面,但是有時候目標物件只是一個單獨的物件,并沒有實作任何的介面,這個時候可使用目標物件子類來實作代理-這就是Cglib，

為了讓代理模式理解的更加深刻，我們來看代理模式在兩個經典框架SpringAop和Mybtis中的應用，

五、典型應用

1、在SpringAop的運用

動態代理一個顯著的作用就是，在不改變目標物件的前提下，能增強目標物件的功能，這其實就是AOP的核心，

AOP（Aspect Oriented Programming）是基于切面編程的，可無侵入的在原本功能的切面層添加自定義代碼，一般用于日志收集、權限認證等場景，

SpringAop同時實作了Jdk的動態代理和Cglib的動態代理，

運用動態代理直接作用到需要增強的方法上面，而不改變我們原本的業務代碼，

2、在MyBatis的運用

在Mybitis實作的是Jdk的動態代理，

原始碼中有一個MapperProxyFactory類，其中有一個方法，

//構建handler的程序，
protected T newInstance(MapperProxy<T> mapperProxy) {
  //標準的類加載器，介面，以及invocationHandler介面實作，
  return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
}

Proxy.newProxyInstance()正是我們在Jdk動態代理中的使用，

結合典型應用，認真體會動態代理設計模式，參考軟體設計七大原則在實際應用中更加靈活的使用，不生搬硬套，

為了絲毫加入老王的故事，推薦你看前面的三篇創建型設計模式，以做到絲滑入戲，

一、設計模式之工廠方法和抽象工廠

二、設計模式之單例和原型

三、設計模式之建造者模式

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

標籤：其他

上一篇：Java 并發編程決議 | 關于Java領域中的執行緒機制，我們應該知道的那些事？

下一篇：面向物件的基礎知識