前言
不知道，起這個名字算不算是標題黨呢？內容很長，如果小夥伴們可以耐心看下去，相信會覺得不算標題黨~
自己一直很想好好了解一波動態代理，無論是從技術角度，還是工作角度。而且就衝這個很洋氣的名字，學是必須得學的。就算餓死,死外邊,從這跳下去，我也要學明白動態代理。
如果感覺太囉嗦，可以直接拉至結尾處，看總結~
個人理解
首先，先談一談我們對動態代理的理解。網上很多資源喜歡把動態代理和靜態代理放在一起去對比。這裡我們就先不這麼來做了，個人感覺靜態代理本身重的是一種思想，而本篇動態代理著重去思考它程式碼套路背後的流程，所以就不放在一起啦。如果有對靜態代理感興趣的小夥伴，可以直接自行了解吧~
關於動態代理，個人喜歡把動態和代理分開理解：
動態：可隨時變化的。對應我們程式設計，可以理解為在執行期去搞事情。
代理：接管我們真正的事務，去代我們執行。在我們生活中有很多充當代理的角色，比如：租房中介。
接下來讓我們通過一個：租客通過中介租房子的demo，來展開動態代理的過程。（demo結束之後，我們會從原始碼的角度，去理解動態代理）
由淺
Demo效果
demo的開始，我們依舊是按照動態代理的語法規則開始入手。簡單交代一下demo的劇情~我們有一個租客，身上揣著5000元錢，來到一個陌生的城市裡。他想租一個房子，但是人生地不熟的，所以他選擇了一個房屋中介...結果中介收了他4500元錢，我們的租客被坑了...
編寫程式碼之前，讓我們先看一下效果。
記住這個效果，接下來讓我們一步步，看看租客是怎麼被坑的~
開始編碼
第一步，我們先把上當受騙的租客寫出來，定義一個租客的介面
public interface IRentHouseProcessor {
String rentHouse(String price);
}
複製程式碼接下來，實現這個介面，充當我們倒黴的租客：
public class RentHouseProcessorImpl implements IRentHouseProcessor {
@Override
public String rentHouse(String price) {
Log.d(MainActivity.TAG, "我還剩："+price+"元");
String content = "我是租客，我找中介租了一個房子，我感覺被坑了";
return content;
}
}
複製程式碼接下來，便是實現InvocationHandler，編寫我們動態代理的重頭角色。
按照官方的docs文章，對InvocationHandler的解釋：每個代理例項（Proxy）都有一個關聯的呼叫處理程式（InvocationHandler）。在代理例項上呼叫方法時，方法會被排程到invoke中。
這裡提到的Proxy代理例項是哪個？不要著急，往下看。
public class RentHouseProcessorHandler implements InvocationHandler {
private Object target;
public RentHouseProcessorHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Log.d(MainActivity.TAG, "-----------------------------");
Log.d(MainActivity.TAG, "我是中介，有人找我租房子了，看看他能出多少錢：" + args[0]);
Log.d(MainActivity.TAG, "我既然是中介，那我收他4000元的好處費，500塊錢給你組個地下室，不過分吧？！！");
Object result = method.invoke(target, new Object[]{"500"});
Log.d(MainActivity.TAG, "賺了一大筆錢，美滋滋~");
return result;
}
}
複製程式碼開始執行
開始我們的動態代理之路： 我們不使用代理，我們直接通過租客的例項呼叫自身實現的介面。這裡沒啥好說的~只是為了劇情需要，更好的理解流程。
RentHouseProcessorImpl dpImpl = new RentHouseProcessorImpl();
dpImpl.rentHouse("5000");
Log.d(TAG,"我準備找中介去組個房子。");
複製程式碼使用動態代理:
RentHouseProcessorHandler handler = new RentHouseProcessorHandler(dpImpl);
IRentHouseProcessor proxy = (IRentHouseProcessor) Proxy.newProxyInstance(
dpImpl.getClass().getClassLoader(),
dpImpl.getClass().getInterfaces(),
handler);
String content = proxy.rentHouse("5000");
Log.d(TAG, content);
複製程式碼這一步我們來解釋一下上述提到的那個疑問：代理例項在哪？這個代理例項其實就是Proxy.newProxyInstance()的返回值，也就是IRentHouseProcessor proxy這個物件。這裡有一個很嚴肅的問題？IRentHouseProcessor是一個介面，介面是不可能被new出來的。
所以說proxy物件是一個特別的存在。沒錯它就是：動態代理，動態生成出來的代理例項。而這個例項擁有我們介面物件的方法結構，因此它可以是我們的介面型別，進而也就可以呼叫我們的介面方法。
上述docs文件提到，當我們呼叫proxy物件中的介面方法時，實際上會排程到InvocationHandler方法中的invoke方法中。
當方法到invoke中，那麼問題就出現了：invoke是我們自己重寫的，那我也就是說我們擁有至高無上的權利！
所以在我們的租房這個故事中，中介就是在這個invoke方法中，黑掉了我們租戶的錢！因為invoke方法中它擁有絕對的操作許可權。想幹什麼就幹什麼，甚至不執行我們真正想要執行的方法我們也沒辦法怎麼樣。
入深
走到這，不知道小夥伴對動態代理的流程是不是有了一個清晰的感受。動態代理的過程還是比較的套路性很強的：我們實現一個InvocationHandler類，在invoke中接受處理proxy物件排程過來的方法（Method）資訊，方法執行到此，我們就可以為所欲為的做我們想做的事情啦。而我們的代理類例項是由系統幫我們建立了，我們只需要處理invoke中被排程的方法即可。
接下來讓我們瞭解一下這個被動態生成的代理類例項。是如何被建立出來的~
開啟程式碼之旅
第一步，讓我們通過動態代理最開始的方法，Proxy.newProxyInstance()入手。
下面的程式碼，省略了一些判空/try-catch的過程，如果覺得省略不當，可以自行搜尋對應的原始碼。
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h) throws IllegalArgumentException {
//省略：一些判空，許可權校驗的操作
//[ 標註1 ]
//想辦法獲取一個代理類的Class物件
Class<?> cl = getProxyClass0(loader, intfs);
//省略：try-catch/許可權檢驗
//獲取引數型別是InvocationHandler.class的代理類的構造方法物件
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
//省略：cons.setAccessible(true)過程
//傳入InvocationHandler的例項去，構造一個代理類的例項
return cons.newInstance(new Object[]{h});
}
}
複製程式碼[ 標註1 ]
這部分程式碼，我們可以看到，呼叫了一個引數是ClassLoader、以及介面型別陣列的方法。並且返回值是一個Class物件。實際上這裡返回的c1實際上是我們的代理類的Class物件。何以見得？讓我們點進去一看究竟：
//從快取中取代理類的Class物件，如果沒有通過ProxyClassFactory->ProxyGenerator去生成
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
// 如果存在實現給定介面的給定載入器定義的代理類，則只返回快取副本; 否則，它將通過ProxyClassFactory建立代理類
return proxyClassCache.get(loader, interfaces);
}
複製程式碼跳過快取，看背後
進來之後我們會發現，程式碼量及其的少。這裡很明顯是通過了一個Cache物件去想辦法獲取我們所需要的Class物件。這部分設計到了動態代理的快取過程，其中用的思想和資料結構比較的多，暫時就先不展開了。如果有感興趣的小夥伴，可以自行搜尋瞭解呦。
Cache的get過程，最終會轉向ProxyClassFactory這個類，由這個類先生成需要的代理類的Class物件。
//代理類生成工廠
//一個工廠函式，在給定ClassLoader和介面陣列的情況下生成，定義和返回代理類。
private static final class ProxyClassFactory
implements BiFunction<ClassLoader, Class<?>[], Class<?>> {
//代理類名稱字首
private static final String proxyClassNamePrefix = "$Proxy";
//用原子類來生成代理類的序號, 以此來確定唯一的代理類
private static final AtomicLong nextUniqueNumber = new AtomicLong();
@Override
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
for (Class<?> intf : interfaces) {
//這裡遍歷interfaces陣列進行驗證, 主要做三件事情
//1.intf是否可以由指定的類載入進行載入
//2.intf是否是一個介面
//3.intf在陣列中是否有重複
}
//生成代理類的包名
String proxyPkg = null;
//生成代理類的訪問許可權, 預設是public和final
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
for (Class<?> intf : interfaces) {
//[ 標註1 ]
// 省略：驗證所有非public的代理介面是否在同一個包中。不在則拋異常
throw new IllegalArgumentException("non-public interfaces from different packages");
}
//如果介面都是public的話, 那生成的代理類都放到預設的包下：com.sun.proxy
if (proxyPkg == null) {
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
//生成代理類的序號
long num = nextUniqueNumber.getAndIncrement();
//生成代理類的全限定名, 包名+字首+序號, 例如：com.sun.proxy.$Proxy0
String proxyName = proxyPkg + proxyClassNamePrefix + num;
//！！接下來便進入重點了，用ProxyGenerator來生成位元組碼, 以byte[]的形式存放
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName,
interfaces, accessFlags);
try {
//根據二進位制檔案生成相應的Class例項
return defineClass0(loader, proxyName, proxyClassFile,
0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
}
}
複製程式碼[ 標註1 ]
這部分，可能省略的比較多，因為內容主要是一些判斷。這部分的做的事情是：遍歷所有介面，看一下是不是public。如果不是，需要看一些些介面是不是在同一個包下，如果不是拋異常。這個很容易理解，非public介面還不在同一個包下，這沒得搞啊~
構造代理Class
接下來我們需要注意的是generateProxyClass，這個方法便是：這個Class被構造出來的緣由：
private byte[] generateClassFile() {
//第一步, 將所有的方法組裝成ProxyMethod物件
//首先為代理類生成toString, hashCode, equals等代理方法
addProxyMethod(hashCodeMethod, Object.class);
addProxyMethod(equalsMethod, Object.class);
addProxyMethod(toStringMethod, Object.class);
//遍歷每一個介面的每一個方法, 並且為其生成ProxyMethod物件
for (int i = 0; i < interfaces.length; i++) {
Method[] methods = interfaces[i].getMethods();
for (int j = 0; j < methods.length; j++) {
addProxyMethod(methods[j], interfaces[i]);
}
}
//對於具有相同簽名的代理方法, 檢驗方法的返回值是否相容
for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
checkReturnTypes(sigmethods);
}
//第二步, 組裝要生成的class檔案的所有的欄位資訊和方法資訊
try {
//新增構造器方法
methods.add(generateConstructor());
//遍歷快取中的代理方法
for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
for (ProxyMethod pm : sigmethods) {
//新增代理類的靜態欄位, 例如:private static Method m1;
fields.add(new FieldInfo(pm.methodFieldName,
"Ljava/lang/reflect/Method;", ACC_PRIVATE | ACC_STATIC));
//新增代理類的代理方法
methods.add(pm.generateMethod());
}
}
//新增代理類的靜態欄位初始化方法
methods.add(generateStaticInitializer());
} catch (IOException e) {
throw new InternalError("unexpected I/O Exception");
}
//驗證方法和欄位集合不能大於65535
if (methods.size() > 65535) {
throw new IllegalArgumentException("method limit exceeded");
}
if (fields.size() > 65535) {
throw new IllegalArgumentException("field limit exceeded");
}
//第三步, 寫入最終的class檔案
//驗證常量池中存在代理類的全限定名
cp.getClass(dotToSlash(className));
//驗證常量池中存在代理類父類的全限定名, 父類名為:"java/lang/reflect/Proxy"
cp.getClass(superclassName);
//驗證常量池存在代理類介面的全限定名
for (int i = 0; i < interfaces.length; i++) {
cp.getClass(dotToSlash(interfaces[i].getName()));
}
//接下來要開始寫入檔案了,設定常量池只讀
cp.setReadOnly();
ByteArrayOutputStream bout = new ByteArrayOutputStream();
DataOutputStream dout = new DataOutputStream(bout);
try {
//1.寫入魔數
dout.writeInt(0xCAFEBABE);
//2.寫入次版本號
dout.writeShort(CLASSFILE_MINOR_VERSION);
//3.寫入主版本號
dout.writeShort(CLASSFILE_MAJOR_VERSION);
//4.寫入常量池
cp.write(dout);
//5.寫入訪問修飾符
dout.writeShort(ACC_PUBLIC | ACC_FINAL | ACC_SUPER);
//6.寫入類索引
dout.writeShort(cp.getClass(dotToSlash(className)));
//7.寫入父類索引, 生成的代理類都繼承自Proxy
dout.writeShort(cp.getClass(superclassName));
//8.寫入介面計數值
dout.writeShort(interfaces.length);
//9.寫入介面集合
for (int i = 0; i < interfaces.length; i++) {
dout.writeShort(cp.getClass(dotToSlash(interfaces[i].getName())));
}
//10.寫入欄位計數值
dout.writeShort(fields.size());
//11.寫入欄位集合
for (FieldInfo f : fields) {
f.write(dout);
}
//12.寫入方法計數值
dout.writeShort(methods.size());
//13.寫入方法集合
for (MethodInfo m : methods) {
m.write(dout);
}
//14.寫入屬性計數值, 代理類class檔案沒有屬性所以為0
dout.writeShort(0);
} catch (IOException e) {
throw new InternalError("unexpected I/O Exception");
}
//轉換成二進位制陣列輸出
return bout.toByteArray();
}
複製程式碼以上註釋的內容，如果小夥伴們看過位元組碼格式的話，應該不陌生。這一部分內容就是去建立我們的代理類的Class位元組碼檔案。並通過ByteArrayOutputStream的作用，將我們手動生成的位元組碼內容轉成byte[]，並呼叫defineClass0方法，將其載入到記憶體當中。
末尾return方法，是一個native方法，我們不需要看實現，應該也能猜到，這裡的內容是把我們的構造的byte[]載入到記憶體當中，然後獲得對應的Class物件，也就是我們的代理類的Class。
private static native Class<?> defineClass0(ClassLoader var0, String var1, byte[] var2, int var3, int var4);
複製程式碼總結
OK，到這一步，我們的代理類的Class物件就生成出來了。因此我們Proxy.newProxyInstance()所返回出來的類也就很明確了。就是一個：擁有我們所實現介面類的所有方法結構的全新Class物件。也就是我們所說的代理類。
因為擁有我們介面的方法結構，所以可能呼叫我們的方法。不過著這個過程中，我們所呼叫的方法，被排程到InvocationHandler中的invoke方法裡了。這一步，可能有小夥伴會問，為什麼說我們的方法被排程到invoke之中了？要回答這個問題，我們需要看一下我們生成的Proxy代理類是什麼樣子的。
我總結了網上各種各樣檢視動態代理生成的.class檔案的方法，貼一種成本最小的方式： 使用Eclipse，執行我們的動態代理的方法。執行之前，加上這麼一行程式碼：
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
複製程式碼當然這樣執行大概率，ide會報錯
Exception in thread "main" java.lang.InternalError:
I/O exception saving generated file: java.io.FileNotFoundException: com\sun\proxy\$Proxy0.class (系統找不到指定的路徑。)
複製程式碼那怎麼辦呢？很簡單，在src同級的建三級的資料夾分別是：com/sun/proxy。然後執行，就可以看到我們的$Proxy0.class啦。然後我們把它拖到AndroidStudio當中：
public final class $Proxy0 extends Proxy implements IRentHouseProcessor {
private static Method m3;
private static Method m1;
private static Method m0;
private static Method m2;
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
public final String rentHouse(String var1) throws {
try {
return (String)super.h.invoke(this, m3, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final boolean equals(Object var1) throws {
try {
return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final int hashCode() throws {
try {
return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
} 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);
}
}
static {
try {
m3 = Class.forName("proxy.IRentHouseProcessor").getMethod("rentHouse", new Class[]{Class.forName("java.lang.String")});
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
複製程式碼看了Proxy的程式碼，介面方法為什麼會被排程到invoke方法中就很清晰了吧？
結語
小夥伴們一步步追了下來，不知道有沒有對動態代理的過程有了比較清晰的認識。 接下來的內容，會針對動態代理進行實際應用場景的編寫；以及對Retrofit動態代理相關內容的分析。
最後打個廣告（我們一起維護的學習公眾號）
公眾號主要面向的是初級/應屆生。內容包含我們從應屆生轉換為職場開發所踩過的坑，以及我們每週的學習計劃和學習總結。 內容會涉及計算機網路、演算法等基礎；也會涉及前端，後臺，Android等內容~