JDK動態代理詳解
本文主要介紹JDK動態代理的基本原理，讓大家更深刻的理解JDK Proxy,知其然知其所以然。明白JDK動態代理真正的原理及其生成的過程，我們以後寫JDK Proxy可以不用去查demo，就可以徒手寫個完美的Proxy。
下面首先來個簡單的Demo,後續的分析過程都依賴這個Demo去介紹，例子採用JDK1.8執行。
JDK Proxy HelloWorld
package com.yao.proxy;
/**
* Created by robin
*/
public interface Helloworld {
void sayHello();
}
package com.yao.proxy;
import com.yao.HelloWorld;
/**
* Created by robin
*/
public class HelloworldImpl implements HelloWorld {
public void sayHello() {
System.out.print("hello world");
}
}
package com.yao.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
* Created by robin
*/
public class MyInvocationHandler implements InvocationHandler{
private Object target;
public MyInvocationHandler(Object target) {
this.target=target;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("method :"+ method.getName()+" is invoked!");
return method.invoke(target,args);
}
}
package com.yao.proxy;
import com.yao.HelloWorld;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Proxy;
/**
* Created by robin
*/
public class JDKProxyTest {
public static void main(String[]args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//這裡有兩種寫法，我們採用略微複雜的一種寫法，這樣更有助於大家理解。
Class<?> proxyClass= Proxy.getProxyClass(JDKProxyTest.class.getClassLoader(),HelloWorld.class);
final Constructor<?> cons = proxyClass.getConstructor(InvocationHandler.class);
final InvocationHandler ih = new MyInvocationHandler(new HelloworldImpl());
HelloWorld helloWorld= (HelloWorld)cons.newInstance(ih);
helloWorld.sayHello();
//下面是更簡單的一種寫法，本質上和上面是一樣的
/*
HelloWorld helloWorld=(HelloWorld)Proxy.
newProxyInstance(JDKProxyTest.class.getClassLoader(),
new Class<?>[]{HelloWorld.class},
new MyInvocationHandler(new HelloworldImpl()));
helloWorld.sayHello();
*/
}
}
執行上面的程式碼，這樣一個簡單的JDK Proxy就實現了。
代理生成過程
我們之所以天天叫JDK動態代理，是因為這個代理class是由JDK在執行時動態幫我們生成。在解釋代理生成過程前，我們先把-Dsun.misc.ProxyGenerator.saveGeneratedFiles=true這個引數加入到JVM 啟動引數中，它的作用是幫我們把JDK動態生成的proxy class 的位元組碼儲存到硬碟中，幫助我們檢視具體生成proxy的內容。我用的Intellij IDEA ,代理class生成後直接放在專案的根目錄下的，以具體的包名為目錄結構。
代理類生成的過程主要包括兩部分：
- 代理類位元組碼生成
- 把位元組碼通過傳入的類載入器載入到虛擬機器中
Proxy類的getProxyClass方法入口：需要傳入類載入器和interface
然後呼叫getProxyClass0方法，裡面的註解解釋很清楚，如果實現當前介面的代理類存在，直接從快取中返回，如果不存在，則通過ProxyClassFactory來建立。
這裡可以明顯看到有對interface介面數量的限制，不能超過65535。其中proxyClassCache具體初始化資訊如下：
proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
其中建立代理類的具體邏輯是通過ProxyClassFactory的apply方法來建立的。
ProxyClassFactory裡的邏輯包括了包名的建立邏輯，呼叫ProxyGenerator. generateProxyClass生成代理類，把代理類位元組碼載入到JVM。
- 包名生成邏輯預設是com.sun.proxy，如果被代理類是 non-public proxy interface，則用和被代理類介面一樣的包名，類名預設是$Proxy 加上一個自增的整數值。
- 包名類名準備好後，就是通過ProxyGenerator. generateProxyClass根據具體傳入的介面建立代理位元組碼，-Dsun.misc.ProxyGenerator.saveGeneratedFiles=true 這個引數就是在該方法起到作用，如果為true則儲存位元組碼到磁碟。代理類中，所有的代理方法邏輯都一樣都是呼叫invocationHander的invoke方法，這個我們可以看後面具體代理反編譯結果。
- 把位元組碼通過傳入的類載入器載入到JVM中: defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);。
private static final class ProxyClassFactory
implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
// prefix for all proxy class names
private static final String proxyClassNamePrefix = "$Proxy";
// next number to use for generation of unique proxy class names
private static final AtomicLong nextUniqueNumber = new AtomicLong();
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
for (Class<?> intf : interfaces) {
/*
* Verify that the class loader resolves the name of this
* interface to the same Class object.
*/
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");
}
/*
* Verify that the Class object actually represents an
* interface.
*/
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
}
/*
* Verify that this interface is not a duplicate.
*/
if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
throw new IllegalArgumentException(
"repeated interface: " + interfaceClass.getName());
}
}
String proxyPkg = null; // package to define proxy class in
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
/*
* Record the package of a non-public proxy interface so that the
* proxy class will be defined in the same package. Verify that
* all non-public proxy interfaces are in the same package.
*/
//生成包名和類名邏輯
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 + ".";
}
/*
* Choose a name for the proxy class to generate.
*/
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
/*
* Generate the specified proxy class. 生成代理類的位元組碼
* -Dsun.misc.ProxyGenerator.saveGeneratedFiles=true 在該部起作用
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
//載入到JVM中
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
/*
* A ClassFormatError here means that (barring bugs in the
* proxy class generation code) there was some other
* invalid aspect of the arguments supplied to the proxy
* class creation (such as virtual machine limitations
* exceeded).
*/
throw new IllegalArgumentException(e.toString());
}
}
}
我們可以根據代理類的位元組碼進行反編譯，可以得到如下結果，其中HelloWorld只有sayHello方法，但是代理類中有四個方法 包括了Object上的三個方法：equals,toString,hashCode。
代理的大概結構包括4部分：
- 靜態欄位：被代理的介面所有方法都有一個對應的靜態方法變數；
- 靜態塊：主要是通過反射初始化靜態方法變數；
- 具體每個代理方法：邏輯都差不多就是 h.invoke，主要是呼叫我們定義好的invocatinoHandler邏輯,觸發目標物件target上對應的方法;
- 建構函式：從這裡傳入我們InvocationHandler邏輯；
package com.sun.proxy;
import com.yao.HelloWorld;
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 HelloWorld {
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})).booleanValue();
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final void sayHello() 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)).intValue();
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
m3 = Class.forName("com.yao.HelloWorld").getMethod("sayHello", new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
常見問題：
- toString() hashCode() equal()方法 呼叫邏輯：這個三個Object上的方法，如果被呼叫將和其他介面方法方法處理邏輯一樣，都會經過invocationHandler邏輯，從上面的位元組碼結果就可以明顯看出。其他Object上的方法將不會走代理處理邏輯，直接走Proxy繼承的Object上方法邏輯。
- interface 含有equals,toString hashCode方法時，和處理普通介面方法一樣，都會走invocation handler邏輯，以目標物件重寫的邏輯為準去觸發方法邏輯；
- interface含有重複的方法簽名,以介面傳入順序為準，誰在前面就用誰的方法，代理類中只會保留一個，不會有重複的方法簽名；
- 如果想學習Java工程化、高效能及分散式、深入淺出。微服務、Spring，MyBatis，Netty原始碼分析的朋友可以加我的Java高階交流：787707172，群裡有阿里大牛直播講解技術，以及Java大型網際網路技術的視訊免費分