java設計模式之代理模式
阿新 • • 發佈：2020-11-14
代理模式的定義：
代理模式指為其他物件提供一種代理，以控制對這個物件的訪問，屬於結構型設計模式。
在某種情況下，一個物件不適合或者不能直接引用另一個物件，而代理物件可以在客戶端和目標物件之間起到中介的作用。
代理模式的應用場景：
- 生活中的租房中介、婚姻介紹、經紀人、快遞、事物代理、日誌監聽等，都是代理模式的實際體現。
- 當無法或不想直接引用某個物件或訪問某個物件存在困難時，可以通過代理物件來間接訪問。使用代理模式主要有兩個目的：一是保護目標物件，二是增強目標物件。
代理模式的UML類圖：
由上圖可以看到，代理模式一般包含3個角色。
- 抽象主體角色（ISubject）：抽象主題類的主要職責是宣告真實主題和代理的共同介面方法，例如途中的dosomething()方法，該類可以是介面，也可以是方法。
- 真實主題角色（RealSubject）：該類也被稱為被代理類，該類定義了代理所表示的真實物件，是負責執行系統的真正的業務邏輯物件。
- 代理主題角色（Proxy）：也被稱為代理類，其內部持有RealSubject的引用，因此具備完全對RealSubjct的代理權。客戶端呼叫代理物件的方法，也呼叫被代理物件的方法，但是會在
代理物件前後增加一些處理代理。
在程式碼中，一般代理會被理解為程式碼增強，實際上就是在原始碼的邏輯前後增加一些程式碼邏輯，而使呼叫在無感。代理模式分為靜態代理和動態代理。
從靜態代理到動態代理：
舉個例子，有些人到了適婚年齡，會被父母催婚。於是父母就開始到處為子女相親，比子女自己還著急。下面來看程式碼實現。
建立頂層介面IPerson的程式碼如下：
package com.liuyi.designmode.structure.proxy.statics; /* * * @Author liuyi * @Description //TODO * @Date 2020/11/13 0:09 **/ public interface IPerson { //尋找伴侶抽象方法 public void findLove(); }
張三要找物件，實現Zhangsan類。
package com.liuyi.designmode.structure.proxy.statics; /** * @ClassName Zhangsan * @description： *@author：liuyi * @Date：2020/11/13 0:11 */ public class Zhangsan implements IPerson{ @Override public void findLove() { System.out.println("兒子張三提出找物件要求"); } }
父親張老師幫兒子找物件，實現ZhangLaoSan類：
package com.liuyi.designmode.structure.proxy.statics; /** * @ClassName ZhangLaoSan * @description： * @author：liuyi * @Date：2020/11/13 0:13 */ public class ZhangLaoSan implements IPerson{ private Zhangsan zhangsan; public ZhangLaoSan(Zhangsan zhangsan){ this.zhangsan = zhangsan; } @Override public void findLove() { System.out.println("父親張老三開始幫兒子物色物件"); zhangsan.findLove(); System.out.println("開始交往"); } }
來看客戶端測試程式碼：
這樣我們就實現了父親幫助兒子去物色物件的目的（代理），雖然在沒有對代理類進行修改的前提下就對代理類實現了功能增強的目的。但是如果現在需要母親去幫住兒子物色物件，我們又需要建立一個代理類，還有七大姑八大姨，這光是
建立代理類就夠嗆的，所以這個時候我們就動態代理就閃亮登場了，下面我們來看看使用JDK自帶的動態代理在本例中是如如何運用的：
首選建立媒婆類JdkMeipo：
package com.liuyi.designmode.structure.proxy.dynamic; import com.liuyi.designmode.structure.proxy.statics.IPerson; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; /** * @ClassName JdkMeipo * @description：jdk自帶的動態代理實現 * @author：liuyi * @Date：2020/11/13 23:36 */ public class JdkMeipo implements InvocationHandler{ private IPerson target; //獲取處理後的被代理物件 public IPerson getInstance(IPerson iPerson){ this.target = iPerson; Class<? extends IPerson> aClass = iPerson.getClass(); IPerson iPersonProxy = (IPerson)Proxy.newProxyInstance(aClass.getClassLoader(), aClass.getInterfaces(), (InvocationHandler) this); return iPersonProxy; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { before(); Object invoke = method.invoke(this.target, args); after(); return invoke; } private void before(){ System.out.println("我是媒婆，以及收集到你的需求，開始物色"); } private void after(){ System.out.println("雙方同意，開始交往"); } }
然後建立一個類ZhaoLiu：
package com.liuyi.designmode.structure.proxy.dynamic; import com.liuyi.designmode.structure.proxy.statics.IPerson; /** * @ClassName Zhaoliu * @description： * @author：liuyi * @Date：2020/11/13 23:47 */ public class Zhaoliu implements IPerson { @Override public void findLove() { System.out.println("符合趙六要求"); } }
測試結果如下：
程式碼這樣寫我們可以發現，只要實現了IPerson介面的單身人士，媒婆（代理類）都可以為其物色物件。
JDK動態代理原理分析：
不僅知其然，還要知其所以然。既然JDK動態代理的功能如此強大，那麼它是如何實現的呢？現在我們來研究一下原理，並模仿JDK動態代理手寫一個屬於自己的動態代理。
我們知道JDK動態代理採用位元組重組，重新生成物件來替代原始物件，以達到動態代理的目的。JDK動態代理生成物件的步驟如下：
- 獲取被代理物件的引用，並且通過反射獲取它的所有介面。
- JDK動態代理重新生成一個新的類，並且新的類要實現被代理類實現的所有介面。
- 動態生成java程式碼，新加的業務邏輯方法由一定的邏輯程式碼呼叫。
- 編譯生成新的java程式碼.class檔案。
- 重新載入到JVM中執行。
以上過程就叫做位元組碼重組。JDK中有一個規範，在ClassPath下主要以$開頭的.class檔案，一般都是自動生成的。那麼我們有沒有辦法看到替代後的物件的"真容呢"？當然可以，
我們在測試類的main方法最前面加上這句話System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");就會在當前工作空間目錄的com.sun.proxy下生成
$Proxy0的class檔案。通過反編譯如下圖所示：
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
package com.sun.proxy;
import com.liuyi.designmode.structure.proxy.statics.IPerson;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy0 extends Proxy implements IPerson {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final void findLove() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final String toString() throws {
try {
return (String)super.h.invoke(this, m2, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final int hashCode() throws {
try {
return (Integer)super.h.invoke(this, m0, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m3 = Class.forName("com.liuyi.designmode.structure.proxy.statics.IPerson").getMethod("findLove");
m2 = Class.forName("java.lang.Object").getMethod("toString");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
我們發現，$Proxy0繼承了Proxy類，同時實現了IPerson介面，而且重寫了findLove()等方法。在靜態塊中用反射查詢到了目標物件的所有方法，而且儲存了所有方法的引用，重寫
的方法用反射呼叫目標物件的方法。我們來分析一下執行過程，我們在測試類中呼叫findLove()方法，其實是呼叫的JDK自動生成的代理類（$Proxy0）中的findLove()方法。從上面的
$Proxy0類可以檢視該方法的內容如下super.h.invoke(this, m3, (Object[])null)，此時它就會去呼叫JdkMeipo的invoke物件。並且你會發現$Proxy0中的每個重寫代理物件的方法都是這樣
的寫法。這樣如果我們想對整個類所有的方法進行增強，比如統計各個方法的執行時長，只需要在代理類的invoke方法上下功夫即可。
使用CGLib實現動態代理：
這裡我們使用spring CGlib來實現，首先建立CglibMeipo代理類：
package com.liuyi.designmode.structure.proxy.dynamic.cglib;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
* @ClassName CGlibMeipo
* @description：
* @author：liuyi
* @Date：2020/11/14 18:06
*/
public class CGlibMeipo implements MethodInterceptor {
//獲取代理類方法
public Object getInstance(Class<?> clazz) throws Exception{
//相當於JDK中的Proxy類，是完成代理的工具類
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
return enhancer.create();
}
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
before();
Object objcet = methodProxy.invokeSuper(o, objects);
after();
return objcet;
}
private void before(){
System.out.println("我是媒婆，已經收集到你的需求，開始物色");
}
private void after(){
System.out.println("雙方同意，開始交往");
}
}
建立單身客戶類：
package com.liuyi.designmode.structure.proxy.dynamic.cglib; /** * @ClassName Custmoer * @description： * @author：liuyi * @Date：2020/11/14 18:13 */ public class Custmoer { public void findLove(){ System.out.println("符合要求"); } }
測試類和結果：
CGlib動態代理原理分析：
我們先來修改一下測試類，生成CGlib生成的代理類class。程式碼如下：
package com.liuyi.designmode.structure.proxy.dynamic.cglib; import org.springframework.cglib.core.DebuggingClassWriter; import org.springframework.core.io.ClassPathResource; import org.springframework.core.io.FileSystemResource; import org.springframework.core.io.Resource; /** * @ClassName Test * @description： * @author：liuyi * @Date：2020/11/14 18:14 */ public class Test { public static void main(String[] args) throws Exception { String property = System.getProperty("user.dir")+"\\src\\main\\java"; System.out.println(property); String debugLocationProperty = DebuggingClassWriter.DEBUG_LOCATION_PROPERTY; System.setProperty(debugLocationProperty, property); CGlibMeipo cGlibMeipo = new CGlibMeipo(); Custmoer custmoer = (Custmoer)cGlibMeipo.getInstance(Custmoer.class); custmoer.findLove(); } }
會在當前包下生成三個class檔案，如圖：
通過除錯發現，Custmoer$$EnhancerByCGLIB$$6d34774c.class就是CGlib動態生成的代理類，繼承了Customer類。Custmoer$$EnhancerByCGLIB$$6d34774c$$FastClassByCGLIB$$85b603b1.class
和Custmoer$$FastClassByCGLIB$$64367e13分別是代理類和被代理類的fastClass，稍後會講解fastClass是什麼。我們先來看看代理類的原始碼：
// // Source code recreated from a .class file by IntelliJ IDEA // (powered by FernFlower decompiler) // package com.liuyi.designmode.structure.proxy.dynamic.cglib; import java.lang.reflect.Method; import org.springframework.cglib.core.ReflectUtils; import org.springframework.cglib.core.Signature; import org.springframework.cglib.proxy.Callback; import org.springframework.cglib.proxy.Factory; import org.springframework.cglib.proxy.MethodInterceptor; import org.springframework.cglib.proxy.MethodProxy; public class Custmoer$$EnhancerByCGLIB$$6d34774c extends Custmoer implements Factory { private boolean CGLIB$BOUND; public static Object CGLIB$FACTORY_DATA; private static final ThreadLocal CGLIB$THREAD_CALLBACKS; private static final Callback[] CGLIB$STATIC_CALLBACKS; private MethodInterceptor CGLIB$CALLBACK_0; private static Object CGLIB$CALLBACK_FILTER; private static final Method CGLIB$findLove$0$Method; private static final MethodProxy CGLIB$findLove$0$Proxy; private static final Object[] CGLIB$emptyArgs; private static final Method CGLIB$equals$1$Method; private static final MethodProxy CGLIB$equals$1$Proxy; private static final Method CGLIB$toString$2$Method; private static final MethodProxy CGLIB$toString$2$Proxy; private static final Method CGLIB$hashCode$3$Method; private static final MethodProxy CGLIB$hashCode$3$Proxy; private static final Method CGLIB$clone$4$Method; private static final MethodProxy CGLIB$clone$4$Proxy; static void CGLIB$STATICHOOK1() { CGLIB$THREAD_CALLBACKS = new ThreadLocal(); CGLIB$emptyArgs = new Object[0]; Class var0 = Class.forName("com.liuyi.designmode.structure.proxy.dynamic.cglib.Custmoer$$EnhancerByCGLIB$$6d34774c"); Class var1; CGLIB$findLove$0$Method = ReflectUtils.findMethods(new String[]{"findLove", "()V"}, (var1 = Class.forName("com.liuyi.designmode.structure.proxy.dynamic.cglib.Custmoer")).getDeclaredMethods())[0]; CGLIB$findLove$0$Proxy = MethodProxy.create(var1, var0, "()V", "findLove", "CGLIB$findLove$0"); Method[] var10000 = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods()); CGLIB$equals$1$Method = var10000[0]; CGLIB$equals$1$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$1"); CGLIB$toString$2$Method = var10000[1]; CGLIB$toString$2$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$2"); CGLIB$hashCode$3$Method = var10000[2]; CGLIB$hashCode$3$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$3"); CGLIB$clone$4$Method = var10000[3]; CGLIB$clone$4$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$4"); } final void CGLIB$findLove$0() { super.findLove(); } public final void findLove() { MethodInterceptor var10000 = this.CGLIB$CALLBACK_0; if (var10000 == null) { CGLIB$BIND_CALLBACKS(this); var10000 = this.CGLIB$CALLBACK_0; } if (var10000 != null) { var10000.intercept(this, CGLIB$findLove$0$Method, CGLIB$emptyArgs, CGLIB$findLove$0$Proxy); } else { super.findLove(); } } final boolean CGLIB$equals$1(Object var1) { return super.equals(var1); } public final boolean equals(Object var1) { MethodInterceptor var10000 = this.CGLIB$CALLBACK_0; if (var10000 == null) { CGLIB$BIND_CALLBACKS(this); var10000 = this.CGLIB$CALLBACK_0; } if (var10000 != null) { Object var2 = var10000.intercept(this, CGLIB$equals$1$Method, new Object[]{var1}, CGLIB$equals$1$Proxy); return var2 == null ? false : (Boolean)var2; } else { return super.equals(var1); } } final String CGLIB$toString$2() { return super.toString(); } public final String toString() { MethodInterceptor var10000 = this.CGLIB$CALLBACK_0; if (var10000 == null) { CGLIB$BIND_CALLBACKS(this); var10000 = this.CGLIB$CALLBACK_0; } return var10000 != null ? (String)var10000.intercept(this, CGLIB$toString$2$Method, CGLIB$emptyArgs, CGLIB$toString$2$Proxy) : super.toString(); } final int CGLIB$hashCode$3() { return super.hashCode(); } public final int hashCode() { MethodInterceptor var10000 = this.CGLIB$CALLBACK_0; if (var10000 == null) { CGLIB$BIND_CALLBACKS(this); var10000 = this.CGLIB$CALLBACK_0; } if (var10000 != null) { Object var1 = var10000.intercept(this, CGLIB$hashCode$3$Method, CGLIB$emptyArgs, CGLIB$hashCode$3$Proxy); return var1 == null ? 0 : ((Number)var1).intValue(); } else { return super.hashCode(); } } final Object CGLIB$clone$4() throws CloneNotSupportedException { return super.clone(); } protected final Object clone() throws CloneNotSupportedException { MethodInterceptor var10000 = this.CGLIB$CALLBACK_0; if (var10000 == null) { CGLIB$BIND_CALLBACKS(this); var10000 = this.CGLIB$CALLBACK_0; } return var10000 != null ? var10000.intercept(this, CGLIB$clone$4$Method, CGLIB$emptyArgs, CGLIB$clone$4$Proxy) : super.clone(); } public static MethodProxy CGLIB$findMethodProxy(Signature var0) { String var10000 = var0.toString(); switch(var10000.hashCode()) { case -508378822: if (var10000.equals("clone()Ljava/lang/Object;")) { return CGLIB$clone$4$Proxy; } break; case 1192015562: if (var10000.equals("findLove()V")) { return CGLIB$findLove$0$Proxy; } break; case 1826985398: if (var10000.equals("equals(Ljava/lang/Object;)Z")) { return CGLIB$equals$1$Proxy; } break; case 1913648695: if (var10000.equals("toString()Ljava/lang/String;")) { return CGLIB$toString$2$Proxy; } break; case 1984935277: if (var10000.equals("hashCode()I")) { return CGLIB$hashCode$3$Proxy; } } return null; } public Custmoer$$EnhancerByCGLIB$$6d34774c() { CGLIB$BIND_CALLBACKS(this); } public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] var0) { CGLIB$THREAD_CALLBACKS.set(var0); } public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] var0) { CGLIB$STATIC_CALLBACKS = var0; } private static final void CGLIB$BIND_CALLBACKS(Object var0) { Custmoer$$EnhancerByCGLIB$$6d34774c var1 = (Custmoer$$EnhancerByCGLIB$$6d34774c)var0; if (!var1.CGLIB$BOUND) { var1.CGLIB$BOUND = true; Object var10000 = CGLIB$THREAD_CALLBACKS.get(); if (var10000 == null) { var10000 = CGLIB$STATIC_CALLBACKS; if (var10000 == null) { return; } } var1.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])var10000)[0]; } } public Object newInstance(Callback[] var1) { CGLIB$SET_THREAD_CALLBACKS(var1); Custmoer$$EnhancerByCGLIB$$6d34774c var10000 = new Custmoer$$EnhancerByCGLIB$$6d34774c(); CGLIB$SET_THREAD_CALLBACKS((Callback[])null); return var10000; } public Object newInstance(Callback var1) { CGLIB$SET_THREAD_CALLBACKS(new Callback[]{var1}); Custmoer$$EnhancerByCGLIB$$6d34774c var10000 = new Custmoer$$EnhancerByCGLIB$$6d34774c(); CGLIB$SET_THREAD_CALLBACKS((Callback[])null); return var10000; } public Object newInstance(Class[] var1, Object[] var2, Callback[] var3) { CGLIB$SET_THREAD_CALLBACKS(var3); Custmoer$$EnhancerByCGLIB$$6d34774c var10000 = new Custmoer$$EnhancerByCGLIB$$6d34774c; switch(var1.length) { case 0: var10000.<init>(); CGLIB$SET_THREAD_CALLBACKS((Callback[])null); return var10000; default: throw new IllegalArgumentException("Constructor not found"); } } public Callback getCallback(int var1) { CGLIB$BIND_CALLBACKS(this); MethodInterceptor var10000; switch(var1) { case 0: var10000 = this.CGLIB$CALLBACK_0; break; default: var10000 = null; } return var10000; } public void setCallback(int var1, Callback var2) { switch(var1) { case 0: this.CGLIB$CALLBACK_0 = (MethodInterceptor)var2; default: } } public Callback[] getCallbacks() { CGLIB$BIND_CALLBACKS(this); return new Callback[]{this.CGLIB$CALLBACK_0}; } public void setCallbacks(Callback[] var1) { this.CGLIB$CALLBACK_0 = (MethodInterceptor)var1[0]; } static { CGLIB$STATICHOOK1(); } }
可以看到，代理類重寫了Customer的所有方法，並且每個方法都有一個代理自動生成的方法與之對應，比如findLove()方法對應的就是CGLIB$findLove$0方法。
我們來分析下呼叫流程，當我們在測試類中呼叫findLove方法，進入代理類的findLove()方法，程式碼如下：
public final void findLove() { MethodInterceptor var10000 = this.CGLIB$CALLBACK_0; if (var10000 == null) { CGLIB$BIND_CALLBACKS(this); var10000 = this.CGLIB$CALLBACK_0; } if (var10000 != null) { var10000.intercept(this, CGLIB$findLove$0$Method, CGLIB$emptyArgs, CGLIB$findLove$0$Proxy); } else { super.findLove(); } }
這裡會呼叫父類的intercept()方法，至於為什麼說是呼叫父類的intercept()方法，通過檢視var10000變數的來源，可以發現就是Callback物件，我們再來看CGlibMeipo類：
Callback就是CGlibMeipo，所以var10000對應的就是代理的物件，那這裡呼叫intercept()自然就來到了代理類的intercept()方法，程式碼如下：
檢視invokeSuper方法
上面的程式碼呼叫獲取代理類對應的FastClass，並執行代理方法。CGLib動態代理執行代理方法的效率之所以被JDK高，就是因為CGLib採用了FastClass機制，它的原理簡單來說就是：
為代理類和被代理類各生成一個類，這個類會為代理類或被代理類的方法分配一個index；然後呼叫對應的方法時，只需要傳入對應的index，就可以快速執行該方法，而不是需要根據
反射去呼叫。因此呼叫效率要比JDK動態代理高。FastClass並不是跟代理類一起生成的，而是在呼叫具體方法的時候生成的，並被放到緩衝中。
所以再回到我們的呼叫流程，這裡會生成兩個對應的FastClass，並最終會通過被代理類的FastClass呼叫被代理類的findLove()方法，然後再執行after()方法，整個呼叫流程結束。
至此，我們基本清楚了CGLib動態代理的原理，對程式碼細節感興趣的小夥伴可以自行深入研究。
CGLib和JDK動態代理的對比分析：
- JDK動態代理實現了被代理物件的介面，CGLib動態代理繼承了被代理物件，也就是說要實現JDK動態代理，被代理的物件必須要有介面，而CGLib不需要。
- JDK動態代理和CGLib動態代理都在執行時生成位元組碼，JDK動態代理直接寫Class位元組碼，CGLib動態代理使用ASM框架寫Class位元組碼。CGLib動態代理實現更復雜，生成代理類比JDK動態代理效率低。
- JDK動態代理呼叫代理方法是通過反射機制呼叫的，而CGLib動態代理是通過FastClass機制直接呼叫方法的，並自帶快取機制，所以CGLib的執行效率要高。
靜態代理和動態代理的區別：
- 靜態代理只能通過手動完成代理操作，如果被代理類增加了方法，則代理類也需要同步增加，違背開閉原則。
- 動態代理採用在執行時動態生成程式碼的方法，取消了對被代理類的擴充套件限制，遵循開閉原則。
- 若動態代理要對目標類的增強邏輯進行擴充套件，結合策略模式，只需要新增策略便可完成，無須修改代理類的程式碼。
代理模式的優點：
- 代理模式能將代理物件與真實被呼叫目標物件分離。
- 在一定程度上降低了系統的耦合性，擴充套件性好。
- 可以起到保護目標物件的作用。
- 可以增強目標物件的功能。
代理模式的缺點：
- 代理模式會造成系統設計中類的數量增加。
- 在客戶端和目標物件中增加一個代理物件，會導致處理請求的速度變慢。
- 增加了系統的複雜度。