代理模式的理解
首先代理二字的含義，程式中代理與字面意思的代理並無區別。比如現實生活中辦理車輛審車，我們經常會聽說花錢找代理（又稱黃牛）辦手續，即辦手續這個事，不是我們親自執行，而是通過代理（即黃牛）去車管所辦理。再比如聯絡明星商業出演，那明星一般也不會直接和商家對線，而是通過明星的經紀人協商時間地點出場費等。
換到程式中代理二字也是上述含義：即呼叫一個物件時，不是直接與此物件示例互動，而是通過物件的代理來完成互動。這就是代理最基本的含義。
那增加這層代理的好處也可類比現實生活進行理解：
- 直觀的，可以避免呼叫方和被呼叫的物件產生直接的聯絡。也就是程式設計中耦合度問題。
- 其次，通過代理可以實現目標物件本身所不具備的行為功能。比如明星只負責演出，而經紀人則負責安排檔期、經費、繳稅等工作。
基於上述的現實案例做鋪墊，我們梳理並識別代理模式涉及的幾個組成部分：
- 目標物件：車主、明星
- 代理人：黃牛、經紀人
- 行為：辦稽核手續、唱歌跳舞
- 提出方、呼叫方：警察、商人
說回到程式中，代理主要有以下兩種形式：
代理的形式之一：靜態代理
這裡採用明星商演的場景來演示：
public interface IStar {
void SingAsong(String songName);
}public class Star implements IStar {
private String _name;
public Star(String name) {
this._name = name;
}
@Override
public void SingAsong(String songName) {
System.out.println("i am " + _name + ",I'm singing....");
}
}public class StaticStarProxy implements IStar {
Star zhangsanStar = new Star("zhangsan");
@Override
public void SingAsong(String songName) {
this.PlanSingDate();
zhangsanStar.SingAsong(songName);
this.PayingTax();
}
private String PlanSingDate() {
Calendar calendar = Calendar.getInstance();
calendar.setTime(new Date());
calendar.add(Calendar.MONTH, 2);
Date singDate = calendar.getTime();
System.out.println("sing date =" + singDate);
return singDate.toString();
}
private void PayingTax() {
System.out.println("payint tex....");
}
}
public class Main {
public static void main(String[] args) {
System.out.println("starting....");
//直接呼叫，直接與明星對線
IStar zhangsanStar = new Star("zhangsan");
zhangsanStar.SingAsong("molihua");
System.out.println();
System.out.println("stoping");
}上述示例程式碼中，Star就是明星本人，StarProxy就是代理人，IStar就是行為，Main就是呼叫方。
程式中靜態一般是代表穩定不變的、相對固定的描述。靜態代理也就是說代理是相對不變化的，代理程式（StarProxy）怎麼寫的一般就不會變化。
很顯然，明星不止一個，並且明星的行為也不僅僅是唱歌。採用靜態代理就會產生幾個問題：
- 如果採用多個明星對應多個代理類的話，那麼就會產生大量的代理類出現。【雖然在現實生活中是合理的，但是程式中一般追求精簡】
- 如果採用多個明星對應一個代理類，那麼這個代理類的實現就會很複雜，且代理類變更頻繁。
- 還有一個問題，如果明星增加技能（比如跳舞），那麼代理類就需要同步的變更。
於是，程式中提出了動態代理來解決這些問題。
代理的形式之二：動態代理
所謂動態代理，直觀理解就是代理是動態生成的，而不需要提前編寫好。
public class DnyamicStarProxy implements InvocationHandler {
IStar _targetStar;
public DnyamicStarProxy(IStar star) {
this._targetStar = star;
}
@Override
public Object invoke(Object proxyInstance, Method method, Object[] objects) throws Throwable {
this.PlanSingDate();
Object invokeResult = method.invoke(_targetStar, objects);
this.PayingTax();
return invokeResult;
}
private String PlanSingDate() {
Calendar calendar = Calendar.getInstance();
calendar.setTime(new Date());
calendar.add(Calendar.MONTH, 2);
Date singDate = calendar.getTime();
System.out.println("sign date =" + singDate);
return singDate.toString();
}
private void PayingTax() {
System.out.println("the agent is paying tex....");
}
}
public class Main {
public static void main(String[] args) {
System.out.println("starting....");
//直接呼叫，直接與明星對線
IStar zhangsanStar = new Star("zhangsan");
zhangsanStar.SingAsong("molihua");
System.out.println();
//代理模式，通過經紀人對線
IStar zhangsanProxy = (IStar) new StaticStarProxy();
zhangsanProxy.SingAsong("molihua");
System.out.println();
//代理模式，動態代理呼叫
System.out.println("邀請李四演出：");
IStar lisiStar = new Star("lisi");
IStar lisiStarProxy = (IStar) Proxy.newProxyInstance(IStar.class.getClassLoader()
, new Class[]{IStar.class}
, new DnyamicStarProxy(lisiStar));
lisiStarProxy.SingAsong("molihua");
System.out.println();
System.out.println("邀請王五演出：");
IStar wangwuStar = new Star("wangwu");
IStar wangwuStarProxy = (IStar) Proxy.newProxyInstance(IStar.class.getClassLoader()
, new Class[]{IStar.class}
, new DnyamicStarProxy(wangwuStar));
wangwuStarProxy.SingAsong("molihua");
System.out.println();
System.out.println("stoping");
}輸出結果：
starting....
i am zhangsan,I'm singing....
sing date =Wed Mar 16 18:14:17 CST 2022
i am zhangsan,I'm singing....
payint tex....
邀請李四演出：
sign date =Wed Mar 16 18:14:17 CST 2022
i am lisi,I'm singing....
the agent is paying tex....
邀請王五演出：
sign date =Wed Mar 16 18:14:17 CST 2022
i am wangwu,I'm singing....
the agent is paying tex....
stoping
程式已結束，退出程式碼為 0
首先對程式碼中陌生的類和方法做一個說明：
InvocationHandler類的Object invoke(Object o, Method method, Object[] objects)
- 入參o代表：動態生成的代理類物件
- 入參method代表；呼叫方呼叫的哪個方法，演示程式碼中即代表SingAsong方法
- 入參objects代表：呼叫方法傳入的引數，即實參
Proxy類的static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
- 引數loader：代表java反射中的類載入器
- 引數interfaces：代表依賴的介面
- 引數h：代表動態代理類的的物件，即DnyamicStarProxy
站在呼叫方角度來說，可以這麼理解：呼叫SingAsong時不是直接new一個Star例項就呼叫了，而是通過Proxy.newProxyInstance動態的建立一個代理類的物件，然後通過此代理類的物件來呼叫。
通過演示程式碼，可以看出以下特徵：
- 只有一個DnyamicStarProxy類，而省掉了具體的各個代理人的類；
- 對商人（呼叫方）來說，只需要提前知道想要邀請的明星（李四、王五），然後通過特定的程式碼就生成了明星經紀人物件（lisiStarProxy、wangwuStarProxy）
- 得到經紀人物件後，就可以通過經紀人物件呼叫執行具體的行為（唱歌）。
同時，我們梳理分析看看動態代理方式的各個組成部分的依賴情況：
- 目標物件：Star，沒有額外的變化
- 代理人：省掉了具體的xxx代理人，轉為DnyamicStarProxy類，從而依賴InvocationHandler類。
- 行為：IStar，沒有額外的變化
- 呼叫方：依賴IStar介面、特定的Star類物件、Proxy類、DnyamicStarProxy類
現在，我們考慮一個問題：演示程式碼中是如何呼叫了Star類的Sing方法？
根據程式執行輸出，可以判斷是在DnyamicStarProxy.Invoke中呼叫的。於是可以看到反射技術的應用，即method.invoke()處利用反射真正執行了Star的SingAsong()方法。
動態代理的一些常見思考題：
※Java常用的動態代理技術有哪些？
本次演示程式雖然用到反射技術來實現動態代理，但也有其它技術來實現比如CGLIB等
※演示程式碼中，呼叫方還是new了具體的明星類（lisiStar、wangwutar），這就產生了嚴重的依賴。有什麼辦法可以解除這個依賴？
※DnyamicStarProxy.Invoke中通過反射執行了目標物件的方法（Star.SingAsong），此時執行的程式碼是本地的程式碼。如果這裡通過socket將方法名、入參傳送到另一臺server上執行，然後把結果在再通過網路返回，這就是RPC框架中常用的動態代理了。
※雖然是動態代理，但根據前面的鋪墊，按說也是會生成代理類的吧，那動態生成的代理長什麼樣？
確實是執行期間動態生成了代理類，如下所示：
注意動態代理類的SingAsong方法；
檢視程式碼
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
import Stars.IStar;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class DynamicGeneratedStarProxyClass extends Proxy implements IStar {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
public DynamicGeneratedStarProxyClass(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 SingAsong(String var1) throws {
try {
super.h.invoke(this, m3, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
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("Stars.IStar").getMethod("SingAsong", Class.forName("java.lang.String"));
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());
}
}
}