JDK动态代理源码解析

发表于 | 分类于 | 阅读次数：

0.前言

在好多框架源码中接触过动态代理，也发现动态有好多种不同的实现，但就是这么常见的特性我居然没有深入解析过，那么知耻而后勇的我即将把这块空缺补上。这里将根据一段简单的demo来讲解最常见的jdk中的动态代理。

1.示例

做为demo入口的main实现如下

1
2
3
4
5
6
7
8
9
10
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的定义如下

1
2
3
4
5
6
7
8
9
10
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的定义如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
@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()，来看一下源码

1
2
@CallerSensitive
public static native Class<?> getCallerClass();

这是一个native的方法，其实它还有一个同样的有参方法如下

1
2
3
/** @deprecated */
@Deprecated
public static native Class<?> getCallerClass(int var0);

这个方法的入参小于等于0时返回 Reflection类，1时返回自己的类，2时返回调用者的类，一直往上直到没有调用者时返回null。但很显然这个方法已经过时了，代替它的就是getCallerClass()方法。该方法会忽略所有带有@CallerSensitive注解的方法的类，返回碰到的第一个不含该注解的调用类。这样回过来看Reflection.getCallerClass()将会返回最初的调用者DynamicProxyExample类。
接着来看checkProxyAccess()方法

1
2
3
4
5
6
7
8
9
10
11
12
13
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)

1
2
3
4
5
6
7
8
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的定义

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

这里的KeyFactory()是二级缓存key的工厂，ProxyClassFactory()是二级缓存值的工厂，这两个先不深入研究。
接着来看WeakCache类的get方法的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
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);
            }
        }
    }
}

这里有几个重要的属性需要事先说明一下

1
2
3
4
5
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)的具体实现

1
2
3
4
5
6
7
8
9
@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类的具体实现为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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()方法的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
@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()方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
@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)生成代理类的字节码，其具体实现为

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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，根据其判断是否要将生成的代理类保存到本地文件中，其实现为

1
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，反编译后来看一下这个类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
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动态代理的底层实现，包括了其中的两级缓存机制，以及具体代理类的生成，对动态代理的实现机制有了更深的认识。