Java 动态代理 原理解析

概要

AOP的拦截功能是由java中的动态代理来实现的。说白了，就是在目标类的基础上增加切面逻辑，生成增强的目标类（该切面逻辑或者在目标类函数执行之前，或者目标类函数执行之后，或者在目标类函数抛出异常时候执行。Spring中的动态代理是使用Cglib进行实现的。我们这里分析的是JDK中的动态代理实现机制。

下面我们通过例子快速了解JDK中的动态代理实现方式。

示例

需要代理的接口

public interface IHello {
public void sayHello();
}

需要代理的类

public class HelloImpl implements IHello {
public void sayHello() {
System.out.println("Hello World...");
}
}

调用处理器实现类

public class ProxyHandler implements InvocationHandler {
private Object target;
public ProxyHandler(Object target) {
this.target = target;
}
public Object proxyInstance() {
return Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), this);
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("aspect before ... ");
Object result = method.invoke(this.target, args);
System.out.println("aspect after ... ");
return result;
}
}

测试类入口

public class Main {
public static void main(String[] args) {
ProxyHandler proxy = new ProxyHandler(new HelloImpl());
IHello hello = (IHello) proxy.proxyInstance();
hello.sayHello();
}
}

Proxy 源码解析

newProxyInstance() 方法

省略了不关心的代码

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,  InvocationHandler h)
throws IllegalArgumentException {

Class<?> cl = getProxyClass0(loader, intfs);
try {
final Constructor<?> cons = cl.getConstructor(constructorParams);
cons.setAccessible(true);
return cons.newInstance(new Object[]{h});
} catch (Exception e) {
......
}
}

调用 getProxyClass0() 方法获取代理类的 Class 对象

通过反射生成 代理类的实例，并返回。

getProxyClass0() 方法

private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) {
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
return proxyClassCache.get(loader, interfaces);
}

检查需要代理的类接口数量是否超过65535个，接口个数用2个byte存储，最大支持65535个。

把获取代理类的Class对象委托给 proxyClassCache() 方法。

private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

proxyClassCache.get() 方法

1. 首先通过 classLoader 获取该classLoader下所有的代理类缓存map。

2. 从该代理类缓存map中根据代理类所有实现的所有接口进行查找代理类。

如果都没有找到对应的代理类，则使用ProxyClassFactory.apply() 方法生成代理类

ProxyClassFactory.apply()

1. 生成代理类的报名和类名

2. 通过ProxyGenerator.generateProxyClass() 方法动态生成代理类字节码。

3. 通过classloader 动态加载 字节码，并生成动态代理类的Class实例，并返回

ProxyGenerator.generateProxyClass()

简单的列出 生成字节码的片段



添加默认的代理方法 hashCode、equals、toString 三个代理方法



循环迭代所有的接口，把接口中所有的方法都生成代理方法。



生成字节码：

从代码中我们可以看到，有class文件中的 魔术头、小版本号、主版本号、类方法标志、当前类、超类、接口个数、每个实现接口、属性个数、每个属性、方法个数、每个方法等信息。

动态生成代理类class文件

下面我们调用JDK内部提供的ProxyGenerator.generateProxyClass 方法把动态生成的代理类持久化到磁盘上。代码如下：

public static void main(String[] args) {
String name = "ProxyHello";
byte[] data = ProxyGenerator.generateProxyClass(name, new Class[] { IHello.class });
try {
FileOutputStream out = new FileOutputStream("d:\\"+name + ".class");
out.write(data);
out.close();
} catch (Exception e) {
e.printStackTrace();
}
}

在D盘根目录下生成ProxyHello.class文件。通过反编译工具，我们得到如下代码：

import cn.com.infcn.proxy.IHello;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class ProxyHello extends Proxy
implements IHello
{
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;

public ProxyHello(InvocationHandler paramInvocationHandler)
throws
{
super(paramInvocationHandler);
}

public final boolean equals(Object paramObject)
throws
{
try
{
return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}

public final void sayHello()
throws
{
try
{
this.h.invoke(this, m3, null);
return;
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}

public final String toString()
throws
{
try
{
return (String)this.h.invoke(this, m2, null);
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}

public final int hashCode()
throws
{
try
{
return ((Integer)this.h.invoke(this, m0, null)).intValue();
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}

static
{
try
{
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
m3 = Class.forName("cn.com.infcn.proxy.IHello").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]);
return;
}
catch (NoSuchMethodException localNoSuchMethodException)
{
throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
}
catch (ClassNotFoundException localClassNotFoundException)
{
}
throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
}
}

通过反编译后的代码我们可以看到，他内部包含4个代理方法：

equals、toString、hashCode 还有 IHello接口中的 sayHello 方法。

该代理类继承了Proxy，并把我们创建的ProxyHandler 类通过构造方法自动注入到 代理类中。

当我们调用代理类的sayHello方法时，sayHello方法就会调用我们实现的ProxyHandler 类中的invoke() 方法，ProxyHandler.invoke() 方法调用我们真正的目标类的sayHello方法。

想了解更多精彩内容请关注我的公众号



本人简书blog地址：http://www.jianshu.com/u/1f0067e24ff8    

点击这里快速进入简书

GIT地址：http://git.oschina.net/brucekankan/

点击这里快速进入GIT