0.前言
在好多框架源码中接触过动态代理，也发现动态有好多种不同的实现，但就是这么常见的特性我居然没有深入解析过，那么知耻而后勇的我即将把这块空缺补上。这里将根据一段简单的demo来讲解最常见的jdk中的动态代理。
1.示例
做为demo入口的main实现如下
public static void main(String[] args) {
ConcreteClass c = new ConcreteClass();// 元对象(被代理对象)
InvocationHandler ih = new ProxyHandler(c);// 代理实例的调用处理程序。
// 创建一个实现业务接口的代理类,用于访问业务类(见代理模式)。
// 返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序，如ProxyHandler。
TargetInterface targetInterface = (TargetInterface) Proxy.newProxyInstance(c.getClass().getClassLoader(), c.getClass().getInterfaces(), ih);
// 调用代理类方法,Java执行InvocationHandler接口的方法.
int i = targetInterface.targetMethodA(5);
System.out.println(i);
}
被代理对象ConcreteClass的定义如下
public class ConcreteClass implements TargetInterface {
public int targetMethodA(int number) {
System.out.println("开始调用目标类的方法targetMethodA...");
System.out.println("操作-打印数字:" + number);
System.out.println("结束调用目标类的方法targetMethodA...");
return number;
}
}
代理类ProxyHandler的定义如下
public class ProxyHandler implements InvocationHandler {
private Object concreteClass;
public ProxyHandler(Object concreteClass) {
this.concreteClass = concreteClass;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("proxy:" + proxy.getClass().getName());
System.out.println("method:" + method.getName());
System.out.println("args:" + args[0].getClass().getName());
System.out.println("Before invoke method...");
Object object = method.invoke(concreteClass, args);
// 普通的Java反射代码,通过反射执行某个类的某方法
// System.out.println(((ConcreteClass)concreteClass).targetMethod(10)+(Integer)args[0]);
System.out.println("After invoke method...");
return object;
}
}
运行main方法后输出的结果为
proxy:com.sun.proxy.$Proxy0
method:targetMethodA
args:java.lang.Integer
Before invoke method...
开始调用目标类的方法targetMethodA...
操作-打印数字:5
结束调用目标类的方法targetMethodA...
After invoke method...
5
这是一个很标准的jdk动态代理实现，基于此运行结果，我们从main方法开始分析源码实现
2.源码解析
ConcreteClass c = new ConcreteClass()和InvocationHandler ih = new ProxyHandler(c)就不分析了，只是简单的生成了一个被代理的对象和代理实例的处理程序对象。重点其实就在(TargetInterface) Proxy.newProxyInstance(c.getClass().getClassLoader(), c.getClass().getInterfaces(), ih);。我们来看一下Proxy类的newProxyInstance方法
@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;
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方法
}
首先是System.getSecurityManager()进行权限的判断，程序有运行权限的情况下才会执行checkProxyAccess(Reflection.getCallerClass(), loader, intfs)。这里要首先说一下Reflection.getCallerClass()，来看一下源码
@CallerSensitive
public static native Class<?> getCallerClass();
这是一个native的方法，其实它还有一个同样的有参方法如下
/** @deprecated */
@Deprecated
public static native Class<?> getCallerClass(int var0);
这个方法的入参小于等于0时返回 Reflection类，1时返回自己的类，2时返回调用者的类，一直往上直到没有调用者时返回null。但很显然这个方法已经过时了，代替它的就是getCallerClass()方法。该方法会忽略所有带有@CallerSensitive注解的方法的类，返回碰到的第一个不含该注解的调用类。这样回过来看Reflection.getCallerClass()将会返回最初的调用者DynamicProxyExample类。
接着来看checkProxyAccess()方法
private static void checkProxyAccess(Class<?> caller,
ClassLoader loader,
Class<?>... interfaces)
{
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
ClassLoader ccl = caller.getClassLoader();
if (VM.isSystemDomainLoader(loader) && !VM.isSystemDomainLoader(ccl)) {
sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
}
ReflectUtil.checkProxyPackageAccess(ccl, interfaces);
}
}
这里if的判断条件必须满足loader的ClassLoader为null，而ccl的ClassLoader不为null，才会执行。但这里显然两者都是AppClassLoader，所以会直接跳出if执行ReflectUtil.checkProxyPackageAccess(ccl, interfaces)判断ccl和interfaces的ClassLoader是否相同，若不同则在创建代理类时会抛出IllegalAccessError。
接着跳回来看Class<?> cl = getProxyClass0(loader, intfs)
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
if (interfaces.length > 65535) {//接口数量不大于65535
throw new IllegalArgumentException("interface limit exceeded");
}
//缓存中存在则从缓存中获取代理类，否则通过ProxyClassFactory创建代理类
return proxyClassCache.get(loader, interfaces);
}
这里主要看proxyClassCache.get(loader, interfaces)如何生成代理类，首先看一下proxyClassCache的定义
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
这里的KeyFactory()是二级缓存key的工厂，ProxyClassFactory()是二级缓存值的工厂，这两个先不深入研究。
接着来看WeakCache类的get方法的实现
public V get(K key, P parameter) {
Objects.requireNonNull(parameter);
expungeStaleEntries();//清除已经被GC回收的弱引用
Object cacheKey = CacheKey.valueOf(key, refQueue);// 通过类加载器classLoader生成一级缓存的key
// map为一级缓存，从中获取二级缓存，不存在则新建
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;
}
}
// 生成二级缓存的key
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
// 通过key获取二级缓存value,即缓存的代理类。不存在则新建代理类并加入缓存。
Supplier<V> supplier = valuesMap.get(subKey);
Factory factory = null;
while (true) {
if (supplier != null) {
// supplier might be a Factory or a CacheValue<V> instance
V value = supplier.get();
if (value != null) {
return value;
}
}
// else no supplier in cache
// or a supplier that returned null (could be a cleared CacheValue
// or a Factory that wasn't successful in installing the CacheValue)
// lazily construct a 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)) {
// successfully replaced
// cleared CacheEntry / unsuccessful Factory
// with our Factory
supplier = factory;
} else {
// retry with current supplier
supplier = valuesMap.get(subKey);
}
}
}
}
这里有几个重要的属性需要事先说明一下
private final ReferenceQueue<K> refQueue = new ReferenceQueue<>();//弱引用的关联队列
private final ConcurrentMap<Object, ConcurrentMap<Object, Supplier<V>>> map = new ConcurrentHashMap<>();//一级缓存
private final ConcurrentMap<Supplier<V>, Boolean> reverseMap = new ConcurrentHashMap<>();//用于记录所有缓存中的CacheKey
refQueue为弱引用的关联队列，当这个弱引用的对象触发GC时，会将其加入到该关联队列中。reverseMap用于记录所有缓存中的CacheKey。map是一级缓存，其key通过CacheKey.valueOf(key, refQueue)生成，因此与classLoader相关；value存储的是二级缓存，即valuesMap。
valuesMap由ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey)取得，当valuesMap为空时则创建一个ConcurrentHashMap<>()。由此来看，这里相当于不同的classLoader对应了不同的二级缓存。那么二级缓存里面又存了什么呢，我们接着来看Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter))，这里的subKey即是二级缓存对应的key，来看看subKeyFactory.apply(key, parameter)的具体实现
@Override
public Object apply(ClassLoader classLoader, Class<?>[] interfaces) {
switch (interfaces.length) {
case 1: return new Key1(interfaces[0]); // the most frequent
case 2: return new Key2(interfaces[0], interfaces[1]);
case 0: return key0;
default: return new KeyX(interfaces);
}
}
这里返回的对象，根据传入的接口数组长度而定，我的demo中传入的接口数量为1，因此走的是new Key1(interfaces[0])分支，Key1类的具体实现为：
private static final class Key1 extends WeakReference<Class<?>> {
private final int hash;
Key1(Class<?> intf) {
super(intf);
this.hash = intf.hashCode();
}
@Override
public int hashCode() {
return hash;
}
@Override
public boolean equals(Object obj) {
Class<?> intf;
return this == obj ||
obj != null &&
obj.getClass() == Key1.class &&
(intf = get()) != null &&
intf == ((Key1) obj).get();
}
}
获取到subkey后，根据valuesMap.get(subKey)从二级缓存获取supplier对象，接着进入一个while（true）死循环中。
当supplier非空时，说明已经有缓存的对象，通过supplier.get()会获取到代理类并返回。当supplier为空时，会放入一个Factory类型的factory对象，这也就是后来取出的supplier。那么我们来具体看看其get()方法的实现：
@Override
public synchronized V get() { // serialize access
// re-check
Supplier<V> supplier = valuesMap.get(subKey);
if (supplier != this) {
// 异常情况，返回WeakCache.get() 的循环中
return null;
}
V value = null;
try {
value = Objects.requireNonNull(valueFactory.apply(key, parameter));
} finally {
if (value == null) { // remove us on failure
valuesMap.remove(subKey, this);
}
}
// 将value包装为CacheValue (WeakReference)
CacheValue<V> cacheValue = new CacheValue<>(value);
// 放入reverseMap
reverseMap.put(cacheValue, Boolean.TRUE);
//CacheValue代替旧值
if (!valuesMap.replace(subKey, this, cacheValue)) {
throw new AssertionError("Should not reach here");
}
return value;
}
这里的重点是通过valueFactory.apply(key, parameter)生成value，然后将其包装为CacheValue (WeakReference)类型的对象cacheValue，放入valuesMap和reverseMap中。那么这里就要重点来看一下valueFactory.apply(key, parameter)是如何生成value的，这里的valueFactory就是之前提过的二级缓存值的工厂ProxyClassFactory，那么来具体看一下其apply()方法
@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");
}
/*
* 验证该类对象确实是一个接口
*/
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();
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) {
// 如果全部都是公有的代理接口，则使用com.sun.proxy这个包名
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
/*
* 为创建的代理类选择一个名字
*/
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
/*
* 生成指定代理类.
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
}
这个方法看似很长，其实大部分都是在做接口验证、包名和类名生成等，最核心的其实是ProxyGenerator.generateProxyClass( proxyName, interfaces, accessFlags)生成代理类的字节码，其具体实现为
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) {//判断是否要保存到本地文件中
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
try {
int var1 = var0.lastIndexOf(46);
Path var2;
if (var1 > 0) {
Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar));
Files.createDirectories(var3);
var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
} else {
var2 = Paths.get(var0 + ".class");
}
Files.write(var2, var4, new OpenOption[0]);
return null;
} catch (IOException var4x) {
throw new InternalError("I/O exception saving generated file: " + var4x);
}
}
});
}
return var4;
}
这里有一个判断条件saveGeneratedFiles，根据其判断是否要将生成的代理类保存到本地文件中，其实现为
private static final boolean saveGeneratedFiles = (Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"));
从这里看出当我们设置系统变量System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true")后就可以持久化生成的代理类，据此我们在工程根目录的com/sun/proxy文件夹下找到了代理类$Proxy0.class，反编译后来看一下这个类
package com.sun.proxy;
import TargetInterface;
import java.lang.reflect.*;
public final class $Proxy0 extends Proxy
implements TargetInterface
{
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m4;
private static Method m0;
public $Proxy0(InvocationHandler invocationhandler)
{
super(invocationhandler);
}
public final boolean equals(Object obj)
{
try
{
return ((Boolean)super.h.invoke(this, m1, new Object[] {
obj
})).booleanValue();
}
catch (Error ) { }
catch (Throwable throwable)
{
throw new UndeclaredThrowableException(throwable);
}
}
public final String toString()
{
try
{
return (String)super.h.invoke(this, m2, null);
}
catch (Error ) { }
catch (Throwable throwable)
{
throw new UndeclaredThrowableException(throwable);
}
}
public final int targetMethodA(int i)
{
try
{
return ((Integer)super.h.invoke(this, m3, new Object[] {
Integer.valueOf(i)
})).intValue();
}
catch (Error ) { }
catch (Throwable throwable)
{
throw new UndeclaredThrowableException(throwable);
}
}
public final int targetMethodB(int i)
{
try
{
return ((Integer)super.h.invoke(this, m4, new Object[] {
Integer.valueOf(i)
})).intValue();
}
catch (Error ) { }
catch (Throwable throwable)
{
throw new UndeclaredThrowableException(throwable);
}
}
public final int hashCode()
{
try
{
return ((Integer)super.h.invoke(this, m0, null)).intValue();
}
catch (Error ) { }
catch (Throwable throwable)
{
throw new UndeclaredThrowableException(throwable);
}
}
static
{
try
{
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {
Class.forName("java.lang.Object")
});
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m3 = Class.forName("TargetInterface").getMethod("targetMethodA", new Class[] {
Integer.TYPE
});
m4 = Class.forName("TargetInterface").getMethod("targetMethodB", new Class[] {
Integer.TYPE
});
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
}
catch (NoSuchMethodException nosuchmethodexception)
{
throw new NoSuchMethodError(nosuchmethodexception.getMessage());
}
catch (ClassNotFoundException classnotfoundexception)
{
throw new NoClassDefFoundError(classnotfoundexception.getMessage());
}
}
}
可以看出$Proxy0继承了Proxy，并且实现了需要代理的TargetInterface接口，当执行代理类的方法时首先会执行super.h.invoke方法，即传入的invocationhandler对象的invoke方法，这里具体执行的即是代理类ProxyHandler的invoke方法，在该invoke方法中再具体执行业务代码，这里就不再分析下去了。
3.总结
本文分析了JDK动态代理的底层实现，包括了其中的两级缓存机制，以及具体代理类的生成，对动态代理的实现机制有了更深的认识。
