上篇文章我們學習了如何自己實現(xiàn)一個動態(tài)代理汰扭，這篇文章我們從源碼角度來分析下JDK的動態(tài)代理囤躁。
先看一個Demo:
public class MyInvocationHandler implements InvocationHandler {
private MyService target;
public MyInvocationHandler(MyService target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object invoke = method.invoke(target, args);
System.out.println("proxy invoke");
if (method.getReturnType().equals(Void.TYPE)) {
return null;
} else {
System.out.println(invoke);
return invoke+"proxy";
}
}
}
public interface MyService {
void test01();
void test02(String s);
}
public class MyServiceImpl implements MyService {
@Override
public void test01() {
System.out.println("test01");
}
@Override
public void test02(String s) {
System.out.println(s);
}
}
main方法：
public class Main {
public static void main(String[] args) {
MyServiceImpl target = new MyServiceImpl();
Class<? extends MyServiceImpl> clazz = target.getClass();
MyService proxyInstance = (MyService) Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces()
, new MyInvocationHandler(target));
proxyInstance.test01();
proxyInstance.test02("test02");
}
}
我們運行Debug觀察下生成的proxyInstance對象：
可以得出以下幾個結論：
- 生成的代理類的類名是$Proxy0
- 代理類持有我們的MyInvocationHandler對象
這里我們越過不重要的代碼，直接端點到java.lang.reflect.Proxy.ProxyClassFactory#apply這個方法狸演，
我們分段分析這個方法的代碼（簡單的代碼我們就直接跳過了）：
Class<?> interfaceClass = null;
try {
interfaceClass = Class.forName(intf.getName(), false, loader);
} catch (ClassNotFoundException e) {
}
if (interfaceClass != intf) {
throw new IllegalArgumentException(
intf + " is not visible from class loader");
}
</pre>
這段代碼主要是為了確保類加載器對這個class文件解析后得到的是同一個對象言蛇。如果我們要確保兩個對象相等的話，那么它們的類加載器必定是一樣的宵距。
for (Class<?> intf : interfaces) {
int flags = intf.getModifiers();
if (!Modifier.isPublic(flags)) {
accessFlags = Modifier.FINAL;
String name = intf.getName();
int n = name.lastIndexOf('.');
String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
if (proxyPkg == null) {
proxyPkg = pkg;
} else if (!pkg.equals(proxyPkg)) {
throw new IllegalArgumentException(
"non-public interfaces from different packages");
}
}
}
if (proxyPkg == null) {
// if no non-public proxy interfaces, use com.sun.proxy package
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
</pre>
這段代碼主要是在判斷接口是否是public的腊尚，如果不是public的那么需要將代理類生成在接口同名的包下。否則生成的代理類在com.sun.proxy包下满哪。
這里我們可以做一個驗證：
1.我們測試接口如果不是public的婿斥，代理類會生成在接口的同一個包下，在這種情況下哨鸭，我們可以在接口的同名包下新建一個類民宿，類名為$Proxy0，如下：
// 接口換為包訪問權限
interface MyService {
void test01();
void test02(String s);
}
新建一個類像鸡，類名為$Proxy0
2.main函數(shù)進行測試
public static void main(String[] args) {
MyServiceImpl target = new MyServiceImpl();
Class<? extends MyServiceImpl> clazz = target.getClass();
// 加載這個類到JVM中
$Proxy0 proxy0 = new $Proxy0();
MyService proxyInstance = (MyService) Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces()
, new MyInvocationHandler(target));
proxyInstance.test01();
proxyInstance.test02("test02");
}
運行后發(fā)現(xiàn)報錯：顯示有重復的類定義
Exception in thread "main" java.lang.LinkageError: loader (instance of sun/misc/Launcher$AppClassLoader): attempted duplicate class definition for name: "com/dmz/proxy/target/$Proxy0"
at java.lang.reflect.Proxy.defineClass0(Native Method)
at java.lang.reflect.Proxy.access$300(Proxy.java:228)
at java.lang.reflect.Proxy$ProxyClassFactory.apply(Proxy.java:642)
at java.lang.reflect.Proxy$ProxyClassFactory.apply(Proxy.java:557)
at java.lang.reflect.WeakCache$Factory.get(WeakCache.java:230)
at java.lang.reflect.WeakCache.get(WeakCache.java:127)
at java.lang.reflect.Proxy.getProxyClass0(Proxy.java:419)
at java.lang.reflect.Proxy.newProxyInstance(Proxy.java:719)
at com.dmz.proxy.target.Main.main(Main.java:14)
從上面我們就驗證了活鹰，如果不是public的那么需要將代理類生成在接口同名的包下
接下來我們驗證，正常情況下坟桅，代理類會被生成在com.sun.proxy包下
1.同理华望，我們可以創(chuàng)建一個類，全類名為com.sun.proxy.$Proxy0
2.同時我們將接口改為public的仅乓，同樣的我們會發(fā)現(xiàn)會報同一個錯。
至此蓬戚，證明完畢夸楣。我們繼續(xù)看代碼
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
// 省略部分代碼......
我們可以看到，通過ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags)生成一個字節(jié)流后子漩，直接調用了defineClass0(…)方法豫喧，而且我們跟蹤這個方法可以發(fā)現(xiàn)，這是一個本地方法幢泼。并且它直接返回了一個Class對象紧显。
private static native Class<?> defineClass0(ClassLoader loader, String name,
byte[] b, int off, int len);
回顧我們上一篇文章的實現(xiàn)思路：
對比后我們可以發(fā)現(xiàn)，我們自己實現(xiàn)時缕棵，是通過生成java文件孵班，然后進行編譯生成class文件涉兽，再將其加載到JVM中得到class對象。而對于jdk動態(tài)代理篙程，直接通過一個字節(jié)流調用本地方法后直接生成class對象枷畏。
我們再回過頭去看下jdk是如何給我們生成這個字節(jié)流的，這里我們主要關注sun.misc.ProxyGenerator#generateClassFile這個方法虱饿，這里我就不貼代碼了拥诡。因為也是一些字符串的拼接動作，然后寫入到一個字節(jié)流中氮发，我們關注下最后生成的這個字節(jié)流是什么樣子的渴肉，我們將其寫入到一個文件中：
MyServiceImpl target = new MyServiceImpl();
Class<? extends MyServiceImpl> clazz = target.getClass();
MyService proxyInstance = (MyService) Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces()
, new MyInvocationHandler(target));
byte[] bytes = ProxyGenerator.generateProxyClass("proxy", clazz.getInterfaces());
File file = new File("G:\\com\\dmz\\proxy\\proxy.class");
FileOutputStream outputStream = new FileOutputStream(file);
outputStream.write(bytes);
proxyInstance.test01();
proxyInstance.test02("test02");
我們將得到的這個class文件放入idea反編譯：
public final class proxy extends Proxy implements MyService {
private static Method m1;
private static Method m4;
private static Method m2;
private static Method m3;
private static Method m0;
public proxy(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 test01() throws {
try {
super.h.invoke(this, m4, (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 void test02(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 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"));
m4 = Class.forName("com.dmz.proxy.target.MyService").getMethod("test01");
m2 = Class.forName("java.lang.Object").getMethod("toString");
m3 = Class.forName("com.dmz.proxy.target.MyService").getMethod("test02", Class.forName("java.lang.String"));
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
觀察上面代碼，我們可以發(fā)現(xiàn)以下幾點：
代理類繼承了Proxy這個類爽冕，正因為如此仇祭，所以jdk動態(tài)代理只能實現(xiàn)基于接口的代理，而不能實現(xiàn)對整個類進行代理扇售，因為java是單繼承的前塔。那么為什么代理類一定要繼承Proxy這個類呢？我們可以發(fā)現(xiàn)代理類并沒有使用Proxy中的什么屬性或者方法（雖然使用了InvocationHandler對象承冰，但是也可以在生成class之初就將InvocationHandler放入到代理類中）华弓。所以實際上不進行繼承也是沒有任何關系的。查了很多資料后發(fā)現(xiàn)困乒，找到一個比較合理的解釋如下：
DK的動態(tài)代理只允許動態(tài)代理接口是設計使然寂屏，因為動態(tài)代理一個類存在一些問題。在代理模式中代理類只做一些額外的攔截處理娜搂，實際處理是轉發(fā)到原始類做的迁霎。這里存在兩個對象，代理對象跟原始對象百宇。如果允許動態(tài)代理一個類考廉，那么代理對象也會繼承類的字段，而這些字段是實際上是沒有使用的携御，對內存空間是一個浪費昌粤。因為代理對象只做轉發(fā)處理，對象的字段存取都是在原始對象上處理啄刹。更為致命的是如果代理的類中有final的方法涮坐，動態(tài)生成的類是沒法覆蓋這個方法的，沒法代理誓军，而且存取的字段是代理對象上的字段袱讹，這顯然不是我們希望的結果。spring aop框架就是這種模式昵时。
總結
我們在進行代理時捷雕，實際的方法執(zhí)行邏輯仍然是交給目標類處理椒丧，這個時候代理類持有目標類中的字段只不過是對內存空間的一種浪費，其余沒有任何作用非区。
即使我們能接受對內存空間的浪費瓜挽，然而如果我們在代理對象中操作代理對象中的字段，目標對象的字段不受任何影響征绸，這顯然也是不合理的久橙。
如果是基于繼承實現(xiàn)代理，那么有final的方法的情況下管怠，無法完成對final方法的代理淆衷。
代理類實現(xiàn)了我們目標對象實現(xiàn)的接口，所以說JDK動態(tài)代理是基于接口實現(xiàn)的渤弛。
代理對象不僅僅是對接口中的方法進行了代理祝拯，還對hashCode,equals,toString三個方法進行了代理，這也是為了覆蓋目標類中的所有方法她肯。
最后為了感謝大家一直支持魯班學院佳头，這里為大家特別準備了一套架構師的系列教程，針對目前最熱門的架構技術進行解析晴氨。
領取方式：關注小編康嘉，添加q群：90439810，備注：01籽前，免費領取哦
