Java - JDK动态代理原理
前言
如果不熟悉动态代理的，可以看下这篇文章：Java - 动态代理实现方式，简单了解下动态代理的使用。
一. JDK动态代理源码分析
那么我们开始进行源码的分析，我们看下JDK代理的关键代码：
public Object getProxy() {
return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), target.getClass().getInterfaces(), this);
}
↓↓↓↓↓↓
public class Proxy implements java.io.Serializable {
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException {
Objects.requireNonNull(h);
final Class<?>[] intfs = interfaces.clone();
// 判断是否有创建代理的权限
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
// 获取(缓存中如果有）或者生成目标代理类
Class<?> cl = getProxyClass0(loader, intfs);
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
// 通过构造函数去生成一个目标代理类的实例。
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
// 如果构造函数并不是public修饰的，那么设置代理类可以通过反射来访问
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
// 创建代理类对象
return cons.newInstance(new Object[]{h});
}
// ...catch
}
}
那么这里我们首先需要关注生成目标代理类的函数getProxyClass0：
1.1 生成目标代理类 getProxyClass0
Class<?> cl = getProxyClass0(loader, intfs);
↓↓↓↓↓↓
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
return proxyClassCache.get(loader, interfaces);
}
这段代码逻辑并不复杂，重点在于proxyClassCache。我们来跟进下。首先看下这个代理缓存的初始化操作，在Proxy类中，通过static来修饰。
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
首先proxyClassCache这个对象是WeakCache类型的，他有这么个特点：
- 如果缓存中包含对应的目标代理类对象，就直接返回副本。
- 如果缓存中不存在，那么会通过
ProxyClassFactory来生成一个对象。
其次，这个WeakCache类型的对象，依赖于两个对象作为入参：
KeyFactory。ProxyClassFactory。
1.1.1 KeyFactory 生成接口的虚引用
那么我们先来看下KeyFactory的作用是什么，它是Proxy类中的一个私有静态内部类，实现了一个函数性接口。apply主要返回对应接口的虚引用。
private static final class KeyFactory
implements BiFunction<ClassLoader, Class<?>[], Object>
{
@Override
public Object apply(ClassLoader classLoader, Class<?>[] interfaces) {
// 目标类实现的接口个数
switch (interfaces.length) {
// 如果目标类只实现了一个接口。那么返回该接口的虚引用。Key1继承了WeakReference类。
// 保证实现了同一个接口的对象是同一个（接口个数也一个）。
case 1: return new Key1(interfaces[0]); // the most frequent
// 如果目标类只实现了两个接口。那么返回该接口的虚引用。Key2继承了WeakReference类。
// 保证实现了同样2个接口的对象是同一个。
case 2: return new Key2(interfaces[0], interfaces[1]);
// 如果目标类没有实现接口就返回一个Object对象
// private static final Object key0 = new Object();
case 0: return key0;
// 返回一个虚引用数组，KeyX继承了WeakReference，并重写了equals方法，以保证多个相同接口名是的对象是同一个
default: return new KeyX(interfaces);
}
}
}
那么这个类总结下就是用来生成目标类实现的接口的虚引用。
1.1.2 ProxyClassFactory 返回代理类对象
那么再看下另外一个类：ProxyClassFactory。用于返回代理类的class对象。
private static final class ProxyClassFactory
implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
// 代理类类名前缀
private static final String proxyClassNamePrefix = "$Proxy";
// 代理类类名后缀
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) {
// 判断相同名字的接口是否是同一个Class对象
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");
}
// 验证是否是接口类型
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
}
// 验证是否有重复的实现
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;
//
for (Class<?> intf : interfaces) {
int flags = intf.getModifiers();
// 如果目标类实现的接口，有不是public修饰的。那么目标代理类生成的路径会在该接口所在目录下
if (!Modifier.isPublic(flags)) {
accessFlags = Modifier.FINAL;
String name = intf.getName();
int n = name.lastIndexOf('.');
String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
// 如果有非public接口，并且不是在同一个包下，那么会抛出异常。
if (proxyPkg == null) {
proxyPkg = pkg;
} else if (!pkg.equals(proxyPkg)) {
throw new IllegalArgumentException(
"non-public interfaces from different packages");
}
}
}
if (proxyPkg == null) {
// 如果目标类所实现的接口都是被public修饰的，那么会动态生成在com.sun.proxy下，而且被public final修饰
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
// 生成代理类的二进制文件
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
// 动态生成代理类，该函数由native修饰，因此就不展开细说了。
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
}
// 。。catch
}
}
那么总结下这个类的作用就是：
1.判断实现的接口是否是接口类型、是否有重复。否则抛出异常。
2.设置代理类所在的包路径。判断依据：
- 如果存在非
public的接口并且不在同一个包内，那么抛出异常。 - 如果存在非
public的接口，但是在同一个包内，那么在该接口所在的路径就是目标类的生成路径。 - 如果所有接口都是
public类型的，那么目标类的路径设置为com.sum.proxy.
如图，调试一下代码，看下生成的代理类对象的名称（目标类和实现的接口在同一个包下）：
1.1.3 获取目标代理类核心函数 get
上面讲完了WeakCache这个缓存数据结构中息息相关的两个类。WeakCache它的结构，我们从源码上来看是一二级key整合起来对应一个value的组合，即：
- (key,sub-key)->(value)
对应关系如下：
接下来就应该去看核心实现proxyClassCache.get(loader, interfaces)了：
public V get(K key, P parameter) {
Objects.requireNonNull(parameter);
expungeStaleEntries();
// 确定一级key，依赖于类加载器。同一个类加载器是同一个cacheKey。
Object cacheKey = CacheKey.valueOf(key, refQueue);
// 根据一级键，查到对应的值。
ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
if (valuesMap == null) {
ConcurrentMap<Object, Supplier<V>> oldValuesMap
= map.putIfAbsent(cacheKey,
valuesMap = new ConcurrentHashMap<>());
if (oldValuesMap != null) {
valuesMap = oldValuesMap;
}
}
// 调用KeyFactory实例对象的apply方法，返回目标类实现的接口的虚引用
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
// 根据二级键subKey尝试获取supplier，就是缓存数据的值
Supplier<V> supplier = valuesMap.get(subKey);
Factory factory = null;
while (true) {
if (supplier != null) {
// 尝试返回动态代理类的Class实例
V value = supplier.get();
if (value != null) {
return value;
}
}
// 第一次创建目标类代理的时候，这里都是null，就直接初始化一个Factory对象
if (factory == null) {
factory = new Factory(key, parameter, subKey, valuesMap);
}
// 一般用于第一次循环的一个初始化操作
if (supplier == null) {
supplier = valuesMap.putIfAbsent(subKey, factory);
if (supplier == null) {
// successfully installed Factory
supplier = factory;
}
// else retry with winning supplier
} else {
if (valuesMap.replace(subKey, supplier, factory)) {
supplier = factory;
} else {
// retry with current supplier
supplier = valuesMap.get(subKey);
}
}
}
}
这里总结下就是：
- 根据一级键（根据类加载器
classLoader）、二级键（根据接口interfaces）从缓存中来获取目标代理类对象supplier。 supplier可能是一个创建成功的动态代理对象。也可能是一个创建代理对象的工厂Factory（第一次的话就是他）。- 因为第一次动态代理的时候，缓存肯定是
null。因此实际上就会做一些初始化操作。 - 就是创建一个
Factory工厂，通过工厂来创建一个动态代理对象（最终的对象）。如图：
这个Factory是啥呢？它是WeakCache中的一个私有静态内部类：我们看下它的get函数：
private final class Factory implements Supplier<V> {
public synchronized V get() { // serialize access
// re-check
Supplier<V> supplier = valuesMap.get(subKey);
if (supplier != this) {
return null;
}
V value = null;
try {
// 调用了上面提到的ProxyClassFactory实例对象的apply()方法，返回代理类的Class对象
value = Objects.requireNonNull(valueFactory.apply(key, parameter));
} finally {
if (value == null) { // remove us on failure
valuesMap.remove(subKey, this);
}
}
// 校验下其不能为空。
assert value != null;
// 将对应的代理对象进行封装
CacheValue<V> cacheValue = new CacheValue<>(value);
// put into reverseMap
reverseMap.put(cacheValue, Boolean.TRUE);
// 如果创建代理对象成功，尝试将他放到缓存中。
if (!valuesMap.replace(subKey, this, cacheValue)) {
throw new AssertionError("Should not reach here");
}
// successfully replaced us with new CacheValue -> return the value
// wrapped by it
return value;
}
}
1.2 生成的代理类是什么样的？
我们关注上面1.1.2小节中的一段代码：
// 生成代理类的二进制文件
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
// 动态生成代理类，该函数由native修饰，因此就不展开细说了。
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
}
看下第一个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();
if (saveGeneratedFiles) {
// 总的来说就是如果要保存生成的代理文件，就会写到本地。
}
return var4;
}
private static final boolean saveGeneratedFiles = (Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"));
我们可以发现saveGeneratedFiles 这个变量和环境变量sun.misc.ProxyGenerator.saveGeneratedFiles有关。那么我们可以再代码运行的时候，手动添加一下变量，
-Dsun.misc.ProxyGenerator.saveGeneratedFiles=true
如图：
运行之后，会生成对应的代理类文件：因为案例是代理了UserService的实现类。因此我们找到对应的文件就可以。
我们看下生成类中的代码的构造：
public final class $Proxy4 extends Proxy implements UserService {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
public $Proxy4(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 hello() 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.jdk.UserService").getMethod("hello");
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());
}
}
}
上述代码我们可以发现这么几个点：
- 从构造函数中，我们可以发现，他需要传入一个
InvocationHandler类型的对象。 - 有一个静态
static语句块，里面会执行对应的函数，获取该对象中拥有的方法。 - 我们执行的代理类的
hello()函数中，调用的是这段代码：super.h.invoke(this, m3, (Object[])null);
那么这个super.h指的是啥呢？实际上就是上述构造函数中，传入的InvocationHandler方法。也就是我们自定义的InvocationHandler实现类。它存在于Proxy这个类中。而JDK动态代理生成的代理类，都是继承了Proxy类。因此最终在执行函数调用的时候，相当于实现了我们自定义的InvocationHandler类中的invoke函数。从而实现了动态代理。
二. 总结
总结下JDK动态代理的几个知识点：
1.首先，JDK动态代理要求被代理对象需要实现接口。
2.动态代理会有一个缓存，用当前被代理类的类加载器和实现接口（虚引用）来作为一二级Key，两个组合起来可以拿到一个动态代理对象。返回的类型可能是代理对象本身，也可能是用于创建代理对象的Factory。
3.动态代理的对象最终都是通过ProxyClassFactory来返回。
4.比较重要的就是，会判断目标类实现的接口中，是否是public修饰。来决定最终的代理类对象生成在哪个目录下。判断依据：
- 如果存在非
public的接口并且不在同一个包内，那么抛出异常。 - 如果存在非
public的接口，但是在同一个包内，那么在该接口所在的路径就是目标类的生成路径。 - 如果所有接口都是
public类型的，那么目标类的路径设置为com.sum.proxy.
5.动态代理实际上就是通过被代理的接口来动态生成对应的代理类字节码文件。创建出来的源文件（字节码文件），其名称一般是$ProxyX，继承于Proxy类。最后通过反射机制，来形成对应的类。
6.创建动态代理对象实例的时候，就会调用其构造函数，就会传入一个InvocationHandler对象。最终在方法执行的时候会调用InvocationHandler对象的invoke方法。因此我们在使用JDK动态代理的时候，会自定义实现一个InvocationHandler的子类，然后重写invoke函数。
8188
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
