JDK動態代理詳解

時間 2019-11-10

標籤 jdk 動態代理詳解欄目 Java 简体版

原文原文鏈接

本文主要介紹JDK動態代理的基本原理，讓你們更深入的理解JDK Proxy,知其然知其因此然。明白JDK動態代理真正的原理及其生成的過程，咱們之後寫JDK Proxy能夠不用去查demo，就能夠徒手寫個完美的Proxy。java

下面首先來個簡單的Demo,後續的分析過程都依賴這個Demo去介紹，例子採用JDK1.8運行。緩存

JDK Proxy HelloWorldapp

package com.yao.proxy;分佈式

/**ide

* 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();

@Override

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大型互聯網技術的視頻免費分享給你們。