一文搞懂設計模式—代理模式

作者：碼農BookSea 2024-02-26 11:52:38

開發前端

總的來說，代理模式通過引入代理對象，實現了對真實對象的間接訪問和控制，為系統的設計提供了一種簡潔而有效的解決方案。在日常的軟件開發中，合理地運用代理模式可以為系統帶來更好的結構和性能表現。

代理模式（Proxy Pattern）是一種結構型設計模式，也叫做委托模式，它允許你提供一個間接訪問對象的方式。

用一句話描述代理模式就是：為其他對象提供一種代理以控制對這個對象的訪問

使用場景

遠程代理（Remote Proxy）：用于在不同地址空間中代表對象，使得客戶端可以訪問遠程的對象。
虛擬代理（Virtual Proxy）：用于按需創建昂貴對象的代表，延遲對象的實例化，提高系統性能。
保護代理（Protection Proxy）：用于控制對真實對象的訪問權限，在訪問真實對象之前進行安全檢查。
智能引用（Smart Reference）：用于在訪問對象時執行額外的操作，如引用計數、懶加載等。
日志記錄（Logging Proxy）：用于記錄方法調用的日志信息，方便調試和監控系統運行狀態。
權限控制（Access Control Proxy）：用于控制用戶對對象的訪問權限，限制某些用戶的操作。
延遲加載（Lazy Loading Proxy）：用于延遲加載對象的數據，直到真正需要使用時才進行加載。

代理模式在Java中的Spring框架和Dubbo框架中都有廣泛的應用：

Spring框架中的AOP（面向切面編程）：Spring使用代理模式實現AOP功能，允許開發者定義切面（Aspect），并通過代理機制將切面織入到目標對象的方法調用中，實現橫切關注點的管理，如日志記錄、事務管理等。
Dubbo框架中的遠程服務代理：Dubbo是一種高性能的分布式服務框架，其中的服務消費者與服務提供者之間的通信通過代理模式來實現。Dubbo會根據配置信息動態生成接口的代理實現類，在遠程調用時通過代理對象進行通信，隱藏了遠程調用的復雜性，使得調用方可以像調用本地方法一樣調用遠程服務。

通過代理模式，可以實現對對象的訪問控制、附加功能增強、性能優化等目的，提高系統的靈活性、可維護性和可擴展性。

具體實現

代理模式涉及以下幾個角色：

抽象主題（Subject）：是一個接口或抽象類，定義了真實主題和代理對象共同實現的方法，客戶端通過抽象主題訪問真實主題。
真實主題（Real Subject）：是真正執行業務邏輯的對象，實現了抽象主題定義的方法，是代理模式中被代理的對象。
代理（Proxy）：持有對真實主題的引用，可以控制對真實主題的訪問，在其自身的方法中可以調用真實主題的方法，同時也可以在調用前后執行一些附加操作。

實現代理模式步驟如下：

首先定義一個接口：

public interface Subject {
    void request();
}

然后實現真實主題類：

public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("Real Subject handles the request.");
    }
}

接著創建代理類：

public class Proxy implements Subject {
    private RealSubject realSubject;

    @Override
    public void request() {
        if (realSubject == null) {
            realSubject = new RealSubject();
        }
        preRequest();
        realSubject.request();
        postRequest();
    }
    //前置處理
    private void preRequest() {
        System.out.println("Proxy performs pre-request actions.");
    }
    //后置處理
    private void postRequest() {
        System.out.println("Proxy performs post-request actions.");
    }
}

客戶端調用：

public static void main(String[] args) {
        Proxy proxy = new Proxy();
        proxy.request();
    }

輸出：

Proxy performs pre-request actions.
Real Subject handles the request.
Proxy performs post-request actions.

Tips：一個代理類，可以代理多個真實角色，并且真實角色之間允許有耦合關系。

普通代理 & 強制代理

在代理模式中，可以區分普通代理和強制代理：

普通代理（Normal Proxy）：由代理類控制對真實主題的訪問，客戶端直接與代理類交互，代理類負責將請求轉發給真實主題，調用者只知代理而不用知道真實的角色是誰，屏蔽了真實角色的變更對高層模塊的影響。
強制代理（Force Proxy）：“強制”必須通過真實角色查找到代理角色，否則不能訪問。并且只有通過真實角色指定的代理類才可以訪問，也就是說由真實角色管理代理角色。強制代理不需要產生一個代理出來，代理的管理由真實角色自己完成。

上面提供的代碼例子就是普通代理，下面用代碼演示下強制代理：

// 抽象主題接口
public interface Subject {
    /**
     * 待具體實現的方法
     */
    void request();

    /**
     * 獲取每個具體實現對應的代理對象實例
     * @return 返回對應的代理對象
     */
    Subject getProxy();
}


// 強制代理對象
public class ForceProxy implements Subject {

    private Subject subject;

    public ForceProxy(Subject subject) {
        this.subject = subject;
    }

    /**
     * 待具體實現的方法
     */
    @Override
    public void request() {
        preRequest();
        subject.request();
        postRequest();
    }

    /**
     * @return 返回對應的代理對象就是自己
     */
    @Override
    public Subject getProxy() {
        return this;
    }

    private void postRequest() {
        System.out.println("訪問真實主題以后的后續處理");
    }

    private void preRequest() {
        System.out.println("訪問真實主題之前的預處理");
    }
}


// 具體的實現對象
public class RealSubject implements Subject {

    /**
     * 該具體實現對象的代理對象
     */
    private Subject proxy;

    @Override
    public Subject getProxy() {
        proxy = new ForceProxy(this);
        return proxy;
    }

    /**
     * 待具體實現的方法
     */
    @Override
    public void request() {
        if (isProxy()) {
            System.out.println("訪問真實主題方法");
        } else {
            System.out.println("請使用指定的代理訪問");
        }
    }

    private boolean isProxy() {
        return proxy != null;
    }
}

客戶端調用：

public static void main(String[] args) {
        Subject subject = new RealSubject();
        subject.request();
    }
    Output：
    請使用指定的代理訪問
      
      
      
    public static void main(String[] args) {
        Subject subject = new RealSubject();
        Subject proxy = new ForceProxy(subject);
        proxy.request();
    }
    Output：
    訪問真實主題之前的預處理
    請使用指定的代理訪問
    訪問真實主題以后的后續處理
      
      
      
  public static void main(String[] args) {
        Subject subject = new RealSubject();
        Subject proxy = subject.getProxy();
        proxy.request();
    }
    Output：
    訪問真實主題之前的預處理
    訪問真實主題方法
    訪問真實主題以后的后續處理

通過代碼可以觀察到，強制代理模式下，不允許通過真實角色來直接訪問，只有通過真實角色來獲取代理對象，才能訪問。

高層模塊只需調用getProxy就可以訪問真實角色的所有方法，它根本就不需要產生一個代理出來，代理的管理已經由真實角色自己完成。

動態代理

前面講的普通代理和強制代理都屬于靜態代理，也就是說自己寫代理類的方式就是靜態代理。

靜態代理有一個缺點就是要在實現階段就要指定代理類以及被代理者，很不靈活。

而動態代理是一種在運行時動態生成代理類的機制，可以在不預先知道接口的情況下動態創建接口的實現類，允許在運行階段才指定代理哪一個對象，比如Spring AOP就是非常經典的動態代理的應用

下面是兩個動態代理常用的實現方式：

JDK 動態代理：基于 Java 反射機制，在運行時動態創建代理類和對象。JDK 動態代理要求被代理的類實現一個或多個接口，通過 java.lang.reflect.Proxy 和 java.lang.reflect.InvocationHandler 接口來實現代理對象的生成和方法調用。
CGLIB 動態代理：不要求被代理的類實現接口，通過繼承被代理類來生成代理對象。CGLIB 使用字節碼生成庫ASM來動態生成代理類，因此性能略高于 JDK 動態代理。

JDK動態代理

JDK實現動態代理的核心機制就是java.lang.reflect.Proxy類和java.lang.reflect.InvocationHandler接口。

JDK動態代理的動態代理類需要去實現JDK自帶的java.lang.reflect.InvocationHandler接口，該接口中的invoke()方法能夠讓動態代理類實例在運行時調用被代理類需要對外實現的所有接口中的方法，也就是完成對真實主題類方法的調用。

具體實現步驟如下：

創建一個接口Subject表示被代理的對象需要實現的方法。
創建一個真實主題類RealSubject，實現Subject接口，定義真正的業務邏輯。
創建一個實現InvocationHandler接口的代理處理器類DynamicProxyHandler，在invoke方法中執行額外的操作，并調用真實主題的方法。
在主程序中使用Proxy.newProxyInstance()方法動態生成代理對象，并調用代理對象的方法。

下面是動態代理的示例代碼，一起來感受一下：

// 1. 創建接口
public interface Subject {
    void request();
}

// 2. 創建真實主題類
public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject handles the request.");
    }
}

// 3. 創建代理處理器類
public class DynamicProxyHandler implements InvocationHandler {
    private Object target;

    DynamicProxyHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 執行額外操作
        System.out.println("Before requesting...");
        
        // 調用真實主題對象的方法
        Object result = method.invoke(target, args);
        
        // 執行額外操作
        System.out.println("After requesting...");
        
        return result;
    }
}

public class DynamicProxyExample {

    public static void main(String[] args) {
        // 創建真實主題對象
        Subject realSubject = new RealSubject();

        // 創建代理處理器對象
        InvocationHandler handler = new DynamicProxyHandler(realSubject);

        // 創建動態代理對象
        Subject proxy = (Subject) Proxy.newProxyInstance(
                realSubject.getClass().getClassLoader(),
                realSubject.getClass().getInterfaces(),
                handler);

        // 調用代理對象的方法
        proxy.request();
    }
}

這段代碼演示了使用 JDK 動態代理實現動態代理的過程：

首先，創建了一個真實主題對象 realSubject，表示被代理的真實對象。
接著，創建了一個代理處理器對象 handler，類型為 InvocationHandler，并將真實主題對象傳入代理處理器中，用于處理代理對象的方法調用。
然后，通過 Proxy.newProxyInstance() 方法創建了一個動態代理對象 proxy，該方法接受三個參數：

類加載器：使用真實主題對象的類加載器。
接口數組：指定代理對象需要實現的接口，這里使用真實主題對象的接口數組。
處理器：指定代理對象的調用處理器，即前面創建的代理處理器對象 handler。

最后，通過代理對象 proxy 調用 request() 方法，實際上會委托給代理處理器 handler 的 invoke() 方法來處理方法調用，進而調用真實主題對象的對應方法。

這段代碼通過 JDK 動態代理機制實現了代理對象的動態創建和方法調用處理，實現了對真實主題對象的間接訪問，并在調用真實主題對象方法前后進行了額外的處理。

其動態調用過程如圖所示：

cglib動態代理

JDK的動態代理機制只能代理實現了接口的類，否則不能實現JDK的動態代理，具有一定的局限性。

CGLIB（Code Generation Library）是一個功能強大的字節碼生成庫，可以用來在運行時擴展Java類和實現動態代理。

相對于JDK動態代理基于接口的代理，cglib動態代理基于子類的代理，可以代理那些沒有接口的類，通俗說cglib可以在運行時動態生成字節碼。

cglib的原理是對指定的目標類生成一個子類，并覆蓋其中方法實現增強，因為采用的是繼承，所以不能對final修飾符的類進行代理。

下面是一個使用cglib實現動態代理的示例代碼，包括實現步驟：

創建一個真實主題類RealSubject，無需實現任何接口。
創建一個實現MethodInterceptor接口的代理處理器類DynamicProxyHandler，在intercept方法中執行額外的操作，并調用真實主題的方法。
在主程序中使用Enhancer類創建代理對象，并設置代理處理器。

使用 cglib 需要添加對應的依賴：

<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

// 1. 創建真實主題類
public class RealSubject {
    public void request() {
        System.out.println("RealSubject handles the request.");
    }
}

// 2. 創建代理處理器類
public class DynamicProxyHandler implements MethodInterceptor {

    /**
     * 通過Enhancer 創建代理對象
     */
    private Enhancer enhancer = new Enhancer();

    /**
     * 通過class對象獲取代理對象
     * @param clazz class對象
     * @return 代理對象
     */
    public Object getProxy(Class<?> clazz) {
        // 設置需要代理的類
        enhancer.setSuperclass(clazz);
        // 設置enhancer的回調
        enhancer.setCallback(this);
        return enhancer.create();
    }
  
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        // 執行額外操作
        System.out.println("Before requesting...");

        // 調用真實主題對象的方法
        Object result = proxy.invokeSuper(obj, args);

        // 執行額外操作
        System.out.println("After requesting...");

        return result;
    }
}

public class CglibProxyExample {
    public static void main(String[] args) {
        DynamicProxyHandler proxy = new DynamicProxyHandler();
        RealSubject realSubject = (RealSubject) proxy.getProxy(RealSubject.class);

        // 調用代理對象的方法
        realSubject.request();
    }
}

輸出：

Before requesting...
RealSubject handles the request.
After requesting...

cglib動態代理相比于JDK動態代理的優缺點如下：

優點：

可以代理沒有實現接口的類。
性能更高，因為直接操作字節碼，無需反射。

缺點：

生成的代理類會繼承被代理類，可能會影響某些設計。
無法代理static方法，因為cglib是基于繼承來生成代理類的，而靜態方法是屬于類而非對象的
對于final方法，cglib無法覆蓋，仍然會調用父類方法。

總結

代理模式是一種常用的設計模式，在軟件開發中有著廣泛的應用。通過引入代理對象，可以實現對真實對象的訪問控制、附加功能增強、性能優化等目的。

優點

可以控制對真實對象的訪問，在不改變原始類代碼的情況下擴展其行為。
代理模式能將客戶端與目標對象分離，在一定程序上降低了系統的耦合度.

缺點

增加了系統復雜性，引入了多余的代理類，因此有些類型的代理模式可能會造成請求的處理速度變慢。
實現代理模式需要額外的工作，有些代理模式的實現非常復雜。

責任編輯：武曉燕來源： Java隨想錄

代理模式設計

成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看