cyxCoder
明天你会感谢今天奋力拼搏的你。
ヾ(o◕∀◕)ﾉヾ
JAVA动态代理源码分析
2020-03-04 14:10
3038
0
模拟一个用户接口：
public interface UserService {
public void findUser();
}
模拟一个简单的实现：
public class UserServiceImpl implements UserService {
@Override
public void findUser(){
System.out.println("从数据库查找用户>>>>>>");
}
}
实现JDK中的InvocationHandler接口，编写一个记录运行时间的处理器：
package com.cyx.demo.proxy;
import com.cyx.demo.service.UserService;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 打印运行时间的动态代理处理器
*/
public class RunTimeInvocationHandler implements InvocationHandler {
/**
* 被代理类对象 目标代理对象
*/
private Object target;
public RunTimeInvocationHandler(UserService userService) {
target = userService;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("生成的代理类："+proxy.getClass().toString());
Long start = System.currentTimeMillis();
Object reuslt = method.invoke(target, args);// java的反射机制执行方法 执行目标对象的方法
System.out.println("方法执行结束，共用时："+(System.currentTimeMillis()-start)+"毫秒");
return reuslt;
}
/**
* 使用jdk动态代理创建代理类
* @param <T>
* @return
*/
public <T> T getProxy() {
return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
}
编写一个测试类，执行
package com.cyx.demo;
import com.cyx.demo.proxy.RunTimeInvocationHandler;
import com.cyx.demo.service.UserService;
import com.cyx.demo.service.impl.UserServiceImpl;
public class Application {
public static void main(String[] args) {
//将JDK动态代理生成的class文件保存到本地
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
//使用jdk动态代理
UserService proxy = new RunTimeInvocationHandler(new UserServiceImpl()).getProxy();
proxy.findUser();
}
}
查看运行结果：
并且因为在测试类里，设置了把生成的动态代理类保存到本地，所以在工程目录下生成了com/sun/proxy/$Proxy0.class文件。
根据上面的测试代码运行结果，可以分析出一些东西：
JDK动态代理自己生成了一个类，如上叫$Proxy0，用其代替了new UserServiceImpl来进行后续业务操作。
动态代理处理类要实现InvocationHandler接口，重写invode方法，同时通过构造函数、setXXX等方式把需要代理的类传入进去
通过处理类中的invode方法对被代理类中所有方法实现了增强（在被代理接口上多加几个测试方法一试就知），当然因为拿到了Method对象，所以也可以编写逻辑只对某些指定方法增强。（是不是就想到了spring的AOP？）
因此就产生了下面几个问题：
生成的代理类里面是什么样子？
InvocationHandler处理器怎么和代理类相关联实现的方法增强？
保存在本地的是$Proxy0.class（注意这个不是java文件，而是编译好的class文件），那么是怎么生成的这个文件。
怎么把class文件加载到jvm中供程序调用。
带着问题继续进行分析。
回答上面的第一个问题：把上文保存的代理类$Proxy0.class反编译出来，看看JDK自动生成的代理类长的什么样子：
package com.sun.proxy;
import com.cyx.demo.service.UserService;
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 UserService {
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});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final void findUser() 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);
} 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"));
m3 = Class.forName("com.cyx.demo.service.UserService").getMethod("findUser");
m2 = Class.forName("java.lang.Object").getMethod("toString");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
上面的源码，从上到下，一步步进行分析：
1、代理类$Proxy0继承自Proxy,实现了要代理的接口。所以说JDK的动态代理通过接口实现（扩展：CGLIB通过继承，用SAM字节码技术实现。）。为什么不能通过继承实现？因为$Proxy0已经继承了Proxy。（一看就是个很厉害的类）
Proxy干啥的呢？一看名字就是JDK里专门处理动态代理的类，并且上文编写动态代理处理器（RunTimeInvocationHandler）的时候已经用到，再看看：
/**
* 使用jdk动态代理创建代理类
* @param <T>
* @return
*/
public <T> T getProxy() {
return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
代理类$Proxy0就是通过Proxy.newProxyInstance实现的，这个方法先放这里，稍后专门分析。
继续分析代理类$Proxy0的源码：
一看这个，原来就是通过Java反射把被代理接口中的方法注入进来。怎么到这里来的？Proxy.newProxyInstance的第二个参数传入进去的。
然后看看构造函数，就只有一个构造函数如下：
也就是实例化$Proxy0的时候必须得传入动态代理处理器（在此就是RunTimeInvocationHandler对象），怎么传入进去的呢？也是通过Proxy.newProxyInstance方法，RunTimeInvocationHandler类getProxy方法里调用Proxy.newProxyInstance其第三个参数传入了一个this。
在此自动生成的代理类$Proxy0的源码所需要传入的东西都清楚里，都是通过Proxy.newProxyInstance传入：
1、被代理类的接口，可以是多个，所以是个数组。用以知道要在代理类中生成多少个方法。
2、代理处理器对象，通过构造方法注入到要生成的代理类中，以实现方法增强。
最后来看看方法里怎么实现的方法增强，以findUser为例：
super.h是什么？就是$Proxy0构造函数中传入的动态代理处理器（在此就是RunTimeInvocationHandler对象），然后调用了父类的构造函数传入，如下：
在此就可以回答第二个问题了：InvocationHandler处理器怎么和代理类相关联实现的方法增强？
InvocationHandler处理器通过Proxy.newProxyInstance其第三个参数传入代理类中，newProxyInstance方法在实例化代理类$Proxy0时把InvocationHandler处理器注入到构造方法中，代理类$Proxy0每个方法的实现，都会调用处理器中的invode方法。
因为篇幅原因，如下所有代码都没把所有源代码都粘贴出来了，只把P其中的关键代码提取出来，去掉了里面很多不相关和验证代码。
第一步：首先看Proxy类的newProxyInstance：
public class Proxy{
private static final Class<?>[] constructorParams = { InvocationHandler.class };
/*
* 第一个参数类加载器
* 第二个参数类所继承的接口class（可以通过反射获得）
* 第三个参数InvocationHandler处理器
*/
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h){
final Class<?>[] intfs = interfaces.clone();
//1、生成了com.sun.proxy.$Proxy0的Class,这里还没初始化(会先去缓存中查找，没有再生成)
Class<?> cl = getProxyClass0(loader, intfs);
//2、获得构造器对象，参数是InvocationHandler.class
final Constructor<?> cons = cl.getConstructor(constructorParams);
//3、把InvocationHandler传入构造函数，实例化对象
return cons.newInstance(new Object[]{h});
}
}
如上可知，其实newProxyInstance里就干了3件事：
1、生成代理类的Class
2、通过class获得构造函数
3、通过构造函数实例化对象
关于2、3其实就是Java反射机制，这里就不去多讲了。
第二步：然后继续查看源码，分析如何自动生成的代理类的Class:
public class Proxy{
private static final WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) {
//相当于先从缓存中拿一下，有就返回缓存的副本，没有就从ProxyClassFactory里创建代理类
//ProxyClassFactory的实例就在上面new WeakCache的时候创建
return proxyClassCache.get(loader, interfaces);
}
}
如上（依然只贴了关键代码），这还不是关键点，只是把类加载器和需要代理的接口数组传入get方法中。proxyClassCache就是WeakCache类。
第三步：继续查看WeakCache中get方法：
final class WeakCache<K, P, V> {
public WeakCache(BiFunction<K, P, ?> subKeyFactory, BiFunction<K, P, V> valueFactory) {
this.subKeyFactory = Objects.requireNonNull(subKeyFactory);
this.valueFactory = Objects.requireNonNull(valueFactory);
}
/**
* @param key 类加载器
* @param parameter 接口数组，传入的Class<?>[] interfaces
*/
public V get(K key, P parameter) {
//缓存部分就不做详细讲解，就是尝试去缓存中获得以下供应商（supplier）,虽然说过程可能有点复杂
Supplier<V> supplier = valuesMap.get(subKey);
WeakCache.Factory factory = null;
//死循环，循环第一次会去创建supplier和factory
while (true) {
if (supplier != null) {
V value = supplier.get();//在此就进入到了内部类Factory的get方法中
if (value != null) {//如果有数据就取出来返回
return value;
}
}
//否则就说明缓存中没有供应商（supplier）或者供应商中没有数据 或者 工厂类没有成功加载
//懒加载的方式把供应商创建出来，关键代码就如下两行
//把类加载器和接口数组继续传入到Factory类中
factory = new Factory(key, parameter, subKey, valuesMap);
supplier = factory;
}
}
//Factory是WeakCache内部类，实现了Supplier接口
private final class Factory implements Supplier<V> {
//把类加载器和接口数组通过构造方法传入
Factory(K key, P parameter, Object subKey,
ConcurrentMap<Object, Supplier<V>> valuesMap) {
this.key = key;
this.parameter = parameter;
this.subKey = subKey;
this.valuesMap = valuesMap;
}
@Override
public synchronized V get() {
V value = null;
//valueFactory就是ProxyClassFactory的实例
//valueFactory是在Proxy类中(第二步所示代码中)new WeakCache时通过构造方法传入
value = Objects.requireNonNull(valueFactory.apply(key, parameter));
return value;
}
}
}
如上，精简之后看起来好像还是很多，但其实核心就两行：
1、V value = supplier.get();
2、value = Objects.requireNonNull(valueFactory.apply(key, parameter));
先调用内部类Factory中的get方法，,然后内部类Factory的get方法继续调用ProxyClassFactory的apply方法对代理类Class进行创建。
也就是最终是在ProxyClassFactory中的apply方法中，传入类加载器和被代理类的接口数组，生成了代理类$Proxy0的Class。
ProxyClassFactory对象在哪生成的？WeakCache的构造函数中传入的，看第二步代码，Proxy类实例化proxyClassCache时。
第四步：看看ProxyClassFactory中的apply方法
ProxyClassFactory是Proxy的一个私有的静态内部类，apply方法里面一大串验证，验证接口，验证，就不贴出来了，
private static final String proxyClassNamePrefix = "$Proxy";
private static final AtomicLong nextUniqueNumber = new AtomicLong();
@Override
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
String proxyPkg = null; // package to define proxy class in
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
if (proxyPkg == null) {
// if no non-public proxy interfaces, use com.sun.proxy package
// 如果没有非公共代理接口，则使用com.sun.proxy 包
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
/*
* Choose a name for the proxy class to generate.
* 为要生成的代理类选择一个名称,其实就是在类名$Proxy后面增加自增的数字
*/
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
/*
* Generate the specified proxy class.
* 干货来了，在这里生成代理类的class字节码
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
//这里调用的defineClass0是native方法，跟不了了，功能就是把字节数组加入类加载器。
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
}
如上代码，其实就干了3件事：
1、创建名字
2、通过ProxyGenerator.generateProxyClass生成代理类的class字节码
3、把字节码加载到JVM中
在此基本完了也能回答最开始提的第三、第四个问题：
问题三：保存在本地的是$Proxy0.class（注意这个不是java文件，而是编译好的class文件），那么是怎么生成的这个文件？
通过ProxyGenerator类对jdk动态代理进行生成，直接生成的class字节码，没有生成Java文件，然后直接加载到JVM中。
要在程序中加入System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");代码，就会生成上文反编译看到的class文件。
问题四：怎么把class文件加载到jvm中供程序调用。
JDK动态代理是在ProxyClassFactory中的apply方法里调用了native方法defineClass0加载到JVM中。但其实ClassLoader其实也可以加载字节数组，在后续文章中写一个高仿JDK动态代理，再来用ClassLoader实现试试。
总结和后续
newProxyInstance里干的3件事：1、生成代理类的Class；2、通过class获得构造函数；3、通过构造函数实例化对象；
生成代理类的Class，看上面看起来复杂，其实如果把里面的缓存部分都去掉，其实就是调用ProxyClassFactory类中的apply方法，不过因为ProxyClassFactory是Proxy的一个私有的静态内部，所以只能在Proxy中调用它。
ProxyGenerator是jre的lib文件夹下的rt.jar包里的类，具体有什么用可以参考文章末尾的参考链接。
JDK动态代理是对接口进行代理实现，上文中的示例代码是用JDK的动态代理对实现类进行增强。其用处不仅于此，还可以用动态代理直接生成接口的实现类，达到对接口动态的实现。
后续：抽时间写一个高仿低配的JDK动态代理，会自定义代理类、处理器接口、通过自定义类加载器加载class的字节数组。
参考链接：
代理模式详解：https://www.cyxcoder.com/article/17
蚂蚁课堂： http://www.mayikt.com/front/couinfo/194/0
ProxyGenerator介绍：https://www.cnblogs.com/liuyun1995/p/8144706.html
怎样从OpenJDK下载源码：https://my.oschina.net/u/2518341/blog/1931088
全部评论