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
函数。