JDK動態代理實現原理----JDK1.8

阿新 • • 發佈：2019-01-30

1.代理模式

Proxy裡面有個RealSubject物件，初始化的時候將RealSubject物件傳入，進行Proxy中RealSubject的物件進行初始化，然後Proxy中的方法，都是呼叫Proxy物件的方法，可在前後加需求，客戶端只需使用多型，構造一個介面，即可。呼叫介面的方法，實際上就是呼叫Proxy方法，即RealSubject方法。

2.靜態代理

按上述類圖進行操作就是靜態代理，靜態代理如果要對多個方法進行處理，就得在多個方法前後進行修改，不方便，因此產生動態代理。

3.動態代理

代理類在程式執行時建立的代理方式，可以方便的對代理類的函式進行統一的處理，而不用修改代理類的每個方法。

3.1整體的用法

介面

具體物件

代理類

測試類

3.2底層原理

主要關於InvocationHandler和Proxy，前面看不懂沒事，堅持看完你就懂了，我也是這麼過來的

InvocationHandler介面

子類重寫的時候，需要將具體實現類物件（不是代理類）傳遞進去，然後用反射呼叫具體實現類的方法，同時增加其他業務邏輯。

Proxy類

publicstatic Object newProxyInstance(ClassLoader loader,

Class<?>[]

interfaces,

InvocationHandler h)

throws IllegalArgumentException

{

Objects.requireNonNull(h);handler的非空判斷

final Class<?>[] intfs = interfaces.clone();

final SecurityManager sm = System.getSecurityManager();

(sm != null) {

checkProxyAccess(Reflection.getCallerClass(), loader, intfs);

}

Class<?> cl = getProxyClass0(loader, intfs);根據classloader和介面陣列生成代理類的class物件

try {

if (sm != null) {

checkNewProxyPermission(Reflection.getCallerClass(), cl);

}

獲取動態生成的代理類中引數為InvocationHandler的構造方法

//private static final Class<?>[] constructorParams = { InvocationHandler.class };

final Constructor<?> cons = cl.getConstructor(constructorParams);

final InvocationHandler ih = h;

得到cl代理類class中類的修飾符，然後判斷是不是public型別，如果是，就返回指定構造器cons的例項，即代理物件的例項，如果不是，就將cons構造方法設定為可訪問。

if (!Modifier.isPublic(cl.getModifiers())) {

AccessController.doPrivileged(new PrivilegedAction<Void>() {

public Void run() {

cons.setAccessible(true);

returnnull;

}

});

}

returncons.newInstance(new Object[]{h});

} catch (IllegalAccessException|InstantiationException e) {

thrownew InternalError(e.toString(), e);

} catch (InvocationTargetException e) {

Throwable t = e.getCause();

if (tinstanceof RuntimeException) {

throw (RuntimeException) t;

} else {

thrownew InternalError(t.toString(), t);

}

} catch (NoSuchMethodException e) {

thrownew InternalError(e.toString(), e);

}

1、根據傳遞進來的ClassLoader，以及我們的代理物件的父介面陣列，來動態建立二進位制的class檔案，然後根據建立好的Class二進位制檔案，獲取到建立的動態代理類的Class物件。

2、通過代理類的class物件，獲取class物件中引數為InvocationHandler的構造方法

3、判斷構造方法的訪問修飾符，如果不是public的，將其設定成可以訪問的

4、呼叫構造器的newInstance方法，引數為InvocationHandler，返回代理類的例項

private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) {

if (interfaces.length > 65535) {

throw new IllegalArgumentException("interface limit exceeded");

}

proxyClassCache是WeakCache型別，如果快取中包含介面陣列和classloader的class類已經存在，就返回快取副本，否則通過ProxyClassFactory建立一個對應的class物件

return proxyClassCache.get(loader, interfaces);

}

WeakCache這個物件當中會在get取不到值時，去生成一個值，放入進去；

ProxyClassFactory是Proxy的一個靜態內部類，主要就是用來根據classLoader和介面陣列來生成Class物件的。

subKeyFactory.apply(key, parameter) 方法呼叫的是[email protected](ClassLoader loader, Class<?>[] interfaces) 方法

public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);用來存傳入的介面

for (Class<?> intf : interfaces) {

Class<?> interfaceClass = null;

try {

根據介面全限定類名和classLoader，獲取到介面class物件

interfaceClass = Class.forName(intf.getName(), false, loader);

} catch (ClassNotFoundException e) {

}

如果兩次介面class物件不一致，直接丟擲異常，說明建立錯誤

if (interfaceClass != intf) {

throw new IllegalArgumentException(

intf + " is not visible from class loader");

}

判斷創建出來的介面是不是介面型別，不是就拋異常

if (!interfaceClass.isInterface()) {

throw new IllegalArgumentException(

interfaceClass.getName() + " is not an interface");

}

判斷介面的set集合是否已經存在了該介面類，存在丟擲異常，不存在就新增進去

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;

判斷非public介面是不是在同一個包內，如果不是，丟擲異常；

宣告代理類所在的包位置，

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");

}

如果都是public介面設定全限定類名com.sun.proxy.$proxy0

if (proxyPkg == null) {

// if no non-public proxy interfaces, use com.sun.proxy package

proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";

}

long num = nextUniqueNumber.getAndIncrement();

String proxyName = proxyPkg + proxyClassNamePrefix + num;

根據代理類全限定類名，介面陣列，訪問修飾符，生成代理類的位元組碼

byte[] proxyClassFile = ProxyGenerator.generateProxyClass(

proxyName, interfaces, accessFlags);

try {

根據生成的位元組碼，建立class物件並返回。Native方法

return defineClass0(loader, proxyName,

proxyClassFile, 0, proxyClassFile.length);

} catch (ClassFormatError e) {

throw new IllegalArgumentException(e.toString());

}

可以看到這段程式碼就是設定好需要生成的類的類名，然後呼叫ProxyGenerator.generateProxyClass來生成代理類的位元組碼

public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {

ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);

final byte[] var4 = var3.generateClassFile();

//中間省略掉一部分程式碼

return var4;

}

private byte[] generateClassFile() {

//將object類當中的 hashcode，equals，toString方法新增到動態代理類當中

this.addProxyMethod(hashCodeMethod, Object.class);

this.addProxyMethod(equalsMethod, Object.class);

this.addProxyMethod(toStringMethod, Object.class);

Class[] var1 = this.interfaces;

int var2 = var1.length;

int var3;

Class var4;

//遍歷父介面資料

for(var3 = 0; var3 < var2; ++var3) {

var4 = var1[var3];

//獲取每個介面當中的方法

Method[] var5 = var4.getMethods();

int var6 = var5.length;

//遍歷介面當中的方法，將介面當中的方法都新增至動態代理類當中

for(int var7 = 0; var7 < var6; ++var7) {

Method var8 = var5[var7];

this.addProxyMethod(var8, var4);

}

Iterator var11 = this.proxyMethods.values().iterator();

//檢查代理類當中的返回型別

List var12;

while(var11.hasNext()) {

var12 = (List)var11.next();

checkReturnTypes(var12);

}

Iterator var15;

try {

// 將構造方法新增至代理類當中的方法集合中

this.methods.add(this.generateConstructor());

var11 = this.proxyMethods.values().iterator();

//遍歷代理類當中的方法，此處使用兩層迴圈，是因為方法簽名相同的，可能有多個方法

while(var11.hasNext()) {

var12 = (List)var11.next();

var15 = var12.iterator();

while(var15.hasNext()) {

ProxyGenerator.ProxyMethod var16 = (ProxyGenerator.ProxyMethod)var15.next();

this.fields.add(new ProxyGenerator.FieldInfo(var16.methodFieldName, "Ljava/lang/reflect/Method;", 10));

this.methods.add(var16.generateMethod());

}

// 將靜態程式碼塊新增進去

this.methods.add(this.generateStaticInitializer());

} catch (IOException var10) {

throw new InternalError("unexpected I/O Exception", var10);

}

if(this.methods.size() > '\uffff') {

throw new IllegalArgumentException("method limit exceeded");

} else if(this.fields.size() > '\uffff') {

throw new IllegalArgumentException("field limit exceeded");

} else {

/**

* 省略部分程式碼

**/

return var13.toByteArray();

} catch (IOException var9) {

throw new InternalError("unexpected I/O Exception", var9);

}

生成了代理類物件，繼承自Proxy，實現了subject介面，其構造方法是傳遞了InvocationHandler引數，同時實現了equals ，hashcode，toString方法，以及我們自己定義的request方法。

這裡就能清楚的看到，代理類中，request方法，其實就是呼叫InvocationHandler實現類中invoke方法，m3就是RealSubject中定義的request方法

這裡就能知道，呼叫Subject的request的時候，為什麼能夠呼叫動態代理類的invoke方法了。因為在呼叫bind中的Proxy.newProxyInstance的時候，傳入的是我們classLoader，代理類的父介面，和自定義的InvocationHandler，因此生成的代理類物件中的h就是自定義的InvocationHandler。

整體流程：

使用方法：

定義一個介面Subject，裡面有抽象方法request，一個介面的實現類RealSubject，裡面有真正的request方法，定義個ProxyHandler，實現InvocationHandler介面，有ProxyHandler中有個目標物件target，用於傳入RealSubject的例項；裡面有兩個方法，bind方法，將傳入的RealSubject物件，賦值給target，並呼叫Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this)返回代理類物件的例項；還有一個方法，invoke（Object proxy, Method method, Object[] args）方法，在method.invoke前後可以加邏輯功能；method方法物件包含方法的相關資訊，method.invoke就會去找target物件中，指定引數與該方法匹配的方法。

底層原理：

首先分析代理物件的產生過程，最後分析代理物件的產生後的樣子

產生過程：

Proxy.newInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this) 方法，該方法主要做了

①獲取代理類的介面Subject.class物件的副本intfs。

②呼叫getProxyClass0(loader, intfs)方法，獲取代理類的class物件

--2.1 getProxyClass方法會去呼叫proxyClassCache.get(loader,interfaces)方法，該方法的作用，如果快取中已經有該介面對應的代理類的副本，那麼返回代理類的副本，否則使用ProxyClassFactory的apply方法建立一個class物件；get方法中有一句表現了這個過程，如下圖

SubkeyFactory與ProxyClassFactory都是BiFunction介面的的實現類，此處呼叫的是ProxyClassFactory的apply方法。

----2.1.1 apply方法：根據介面的全限定類名以及指定的classLoader，呼叫class.forName方法得到介面的class物件interfaceClass，進行判斷是否是介面型別，是否有重複，

----2.1.2 設定代理類所在的包路徑，如果有非public介面，且不是在同一個包內，拋異常，如果在同一個包內，就設定代理類的包路徑為proxyPkg，如果都是public介面，那麼生成的代理類的包路徑proxyPkg設定為com.sum.proxy.

----2.1.3 根據包路徑，類名字首和num數字，確定代理類的名字

----2.1.4 呼叫ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);內部生成一個ProxyGenerator物件，呼叫ProxyGenerator.generateClassFile()得到代理類的位元組碼檔案；

------2.1.4.1 ProxyGenerator.generateClassFile()方法，為代理類添加了三個object類的hashcode，equals，toString方法，遍歷父介面，獲取每個介面中的方法，新增方法，新增構造方法等，都加入到代理中；返回二進位制位元組碼檔案

----2.1.5 呼叫defineClass0(loader, proxyName, proxyClassFile, 0,proxyClassFile.length);將位元組碼檔案建立為class物件，返回

③獲取到代理類的class物件後，得到代理類引數為InvocationHandler的構造方法，如果是非public型別，就使用setAccessible設定為true，然後呼叫cons.newInstance(new Object[]{h})來生成代理類物件；

④在代理類物件中，有個request方法，方法中預設會呼叫Proxy類裡面的InvocationHandler也就是我們自定義的InvocationHandler的invoke方法。這就實現了動態代理

JDK動態代理實現原理----JDK1.8

JDK動態代理實現原理----JDK1.8

JDK動態代理實現原理

Java中HashMap底層實現原理(JDK1.8)源碼分析

攔截器(由JDK動態代理實現的攔截器)

Java,JDK動態代理的原理分析

轉：jdk動態代理實現

Cglib動態代理實現原理.md

Java中HashMap底層實現原理(JDK1.8)原始碼分析

（轉載）Java中HashMap底層實現原理(JDK1.8)原始碼分析

JDK 動態代理執行原理

cglib動態代理實現原理

Java動態代理實現原理淺析

java 動態代理實現原理

JDK動態代理實現

Spring 之 AOP 動態代理實現原理

Java面試必問之Hashmap底層實現原理(JDK1.8)

【乾貨】JDK動態代理的實現原理以及如何手寫一個JDK動態代理

jdk動態代理與cglib程式碼實現--SpringAop底層原理

細說JDK動態代理的實現原理

Java JDK 動態代理使用及實現原理分析

JDK動態代理實現原理----JDK1.8

相關推薦