代理模式 PROXY Surrogate 結構型設計模式（十四）

時間 2019-11-06

標籤代理模式 proxy surrogate 構型設計十四简体版

原文原文鏈接

代理模式 PROXY 別名Surrogate

意圖

爲其餘的對象提供一種代理以控制對這個對象的訪問。

代理模式含義比較清晰，就是中間人，中介公司，經紀人...

在計算機程序中，代理就表示一個客戶端不想或者不可以直接引用一個對象

而代理對象能夠在客戶端和目標對象之間起到中介的做用

結構

代理模式的根本在於隔離，以下圖所示，間接訪問

代理對象如何可以真的代理真實對象？

在Java語言中，看起來像的一個方式就是實現同一接口

代理角色和真實對象角色擁有共同的抽象類型，他們擁有相同的對外接口request（）方法

ProxySubject內部擁有一個RealSubject

你應該能感受到組合模式的思想-----他們都是Subject，屬於同一個Component

對外有一致的接口

抽象主題角色Subject

聲明瞭真實主題和代理主題的共同接口，任何使用真實主題的地方，均可以使用代理主題

代理主題角色ProxySubject

代理主題角色內部含有對真實對象的引用，從而能夠在任什麼時候候操做真實主題

代理主題提供與真實主題的相同的接口，以便任什麼時候刻，均可以替代真實主題

並且，代理主題還能夠在真實主題執行先後增長額外的處理，好比：經紀人要先收下費~

真實主題角色RealSubject

被代理的真實主題對象，真正工做的是他，好比經紀人總不會站在舞臺上去~

示例代碼

Subject 抽象角色定義了真正的處理請求的request()方法

package proxy;
public interface Subject {
void request();
}

RealSubject真實主題角色，實現了處理請求的方法

package proxy;
public class RealSubject implements Subject {
@Override
public void request() {
    System.out.println("realSubject process request....");
}
}

Proxy代理角色

實現了request（）方法，用於替代真實主題，內部調用真實主題完成請求

而且額外的提供了pre和after操做

package proxy;
public class Proxy implements Subject{
    private Subject realSubject;
    @Override
    public void request() {
        preRequest();
    realSubject.request();
        afterRequest();
    }
     
    public Proxy(Subject realSubject){
        this.realSubject = realSubject;
    }
    public void preRequest(){
        System.out.println("pre request do sth....");
    }
     
    public void afterRequest(){
        System.out.println("after request do sth....");
    }
}

測試類

package proxy;
public class Test {
/**請求subject執行請求
* @param subject
*/
public static void askForSth(Subject subject){
    subject.request();
    System.out.println("################");
 }
   
public static void main(String[] args){
     Subject real = new RealSubject();
     Subject proxy = new Proxy(real);
     askForSth(proxy);
     askForSth(real);
    }
}

定義了真實對象，也定義了一個代理對象

查看他們分別處理請求的結果

從下面的時序圖中，能更好的感覺到「間接」的感受

在真正調用真實對象方法前，須要先執行preRequest方法

真實對象方法調用後，在執行afterRequest方法

代理實現

代理的實現分類有兩種，靜態代理和動態代理

前面形式描述的代理，就是靜態代理

在編譯時期，就已經編寫生成好了代理類的源代碼，程序運行以前class文件就已經生成了

這種按照咱們上面模式編寫了代理類和真實類的形式就是靜態代理

靜態代理常常被用來對原有邏輯代碼進行擴展，原有的邏輯不須要變動，可是能夠增長更多的處理邏輯

可是，可是若是有不少的對象須要被代理怎麼辦？

若是按照靜態代理的形式，那麼將會出現不少的代理類，勢必致使代碼的臃腫。

因此後來出現了動態代理

JDK代理機制

所謂動態代理，按照字面意思就是動態的進行代理， 動態相對於靜態的含義是不須要事先主動的建立代理類， 能夠在運行時須要的時候，動態的建立一個代理類。

動態代理的動態關鍵在於代理類的動態生成，不須要咱們實現建立，從class文件的角度來看的話，是與靜態代理同樣的，仍舊有一個代理類的Class文件

在Java中提供了內置的動態代理的支持。

Java在 java.lang.reflect包中提供了三個核心 Proxy， InvocationHandler， Method 能夠用於動態代理的使用

Java動態代理簡單示例

package proxy.MyDynamicProxy;
public interface Subject {
void doSth();
}

package proxy.MyDynamicProxy;
public class RealSubject implements Subject {
@Override
public void doSth() {
System.out.println("real Object do something...");
}
}

package proxy.MyDynamicProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class DynamicProxyHandler implements InvocationHandler {
private Object realSubject;
public DynamicProxyHandler(Object realSubject) {
this.realSubject = realSubject;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("proxy do something....");
return method.invoke(realSubject, args);
}
}

package proxy.MyDynamicProxy;
import java.lang.reflect.Proxy;
public class Test {
public static void main(String[] args){
RealSubject realSubject = new RealSubject();
Subject proxy = (Subject) Proxy
.newProxyInstance(Test.class.getClassLoader(), new Class[]{Subject.class}, new DynamicProxyHandler(realSubject));
proxy.doSth();
}
}

測試結果爲：

動態代理到底都作了什麼？

對於靜態代理，咱們有一個RealSubject，以及他的超接口Subject

Subject定義了方法，RealSubject實現了方法。

而後咱們建立了代理類，這個代理類實現了Subject接口，而且將新增的邏輯添加進來，而後經過代理類進行方法調用。

在上面的例子中， RealSubject，以及他的超接口Subject含義不變，與靜態代理中的邏輯同樣。

而後咱們 建立了一個調用處理器DynamicProxyHandler 實現了 InvocationHandler接口

該接口只有一個方法 invoke

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable

他有三個參數

proxy - 在其上調用方法的代理實例

method - 對應於在代理實例上調用的接口方法的 Method 實例。Method 對象的聲明類將是在其中聲明方法的接口，該接口能夠是代理類賴以繼承方法的代理接口的超接口。

args - 包含傳入代理實例上方法調用的參數值的對象數組，若是接口方法不使用參數，則爲 null。基本類型的參數被包裝在適當基本包裝器類（如 java.lang.Integer 或 java.lang.Boolean）的實例中。

最後經過Java提供的代理機制建立了一個代理

Subject proxy = (Subject) Proxy

.newProxyInstance(Test.class.getClassLoader(), new Class[]{Subject.class}, new DynamicProxyHandler(realSubject));

核心就是 newProxyInstance方法，他建立了一個實現了Subject接口的代理類

public static Object newProxyInstance(ClassLoader loader,

Class<?>[] interfaces,

InvocationHandler h)

throws IllegalArgumentException

這個方法也有三個參數

loader - 定義代理類的類加載器

interfaces - 代理類要實現的接口列表

h - 指派方法調用的調用處理程序

爲何須要這三個參數呢？

首先，Proxy.newProxyInstance幫你動態的建立方法，確定要有一個類加載器，上面的示例中咱們直接使用的測試類的類加載，這個通常是應用程序類加載器

再者，動態代理與靜態代理同樣，須要實現一樣的接口，那你實現了哪些接口呢？因此你得把接口列表告訴我

最後，你但願有哪些處理呢？你要把處理器給我

proxy.doSth();執行時，會將當前代理實例，以及當前方法，以及當前方法的參數傳遞給invoke方法，因此就完成代理的功能。

再來重頭理一下：

如同靜態代理，須要被代理的對象RealSubject，以及他的超接口Subject
須要實現InvocationHandler接口建立一個處理器，新增長的方法邏輯封裝在invoke方法中
Proxy.newProxyInstance建立代理實例
使用建立的代理實例執行方法

簡言之，動態代理與靜態代理如出一轍，差異就在於不用你事先去本身主動地建立一個代理類

靜態的時候編寫了代理類，而後編譯爲class而後須要時被加載到JVM，而後調用

動態是運行時在須要的時候，直接生成class文件

依照上面的步驟流程，你就能夠藉助於Java的機制實現動態代理

可是你會發現，Proxy.newProxyInstance方法的參數須要一個 Class<?>[] interfaces，這意味着什麼？這意味着被代理的對象必須實現一個接口

若是被代理的對象未曾實現任何接口怎麼辦？

給每一個被代理的對象增長一個標記接口（形式接口）？若是隻是爲了使用JDK的動態代理實現，而添加了無心義的接口這是否穩當？

CGLIB

還有另一種形式的動態代理CGLIB

須要兩個Jar

package proxy.cglib;
public class RealSubject{
public void doSth() {
System.out.println("realSubject process request....");
}
}

package proxy.cglib;
import java.lang.reflect.Method;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class MyHandler implements MethodInterceptor {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy)
throws Throwable {
System.out.println("before do something...");
Object object = methodProxy.invokeSuper(o,objects);
System.out.println("after do something...");
return object;
}
}

package proxy.cglib;
import net.sf.cglib.proxy.Enhancer;
public class Test {
public static void main(String[] args){
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(RealSubject.class);
enhancer.setCallback(new MyHandler());
RealSubject subject = (RealSubject)enhancer.create();
subject.doSth();
}
}