JDK動態代理[2]----JDK動態代理的底層實現之Proxy源碼分析

在上一篇里為大家簡單介紹了什么是代理模式？為什么要使用代理模式？並用例子演示了一下靜態代理和動態代理的實現，分析了靜態代理和動態代理各自的優缺點。在這一篇中筆者打算深入源碼為大家剖析JDK動態代理實現的機制，建議讀者閱讀本篇前可先閱讀一下筆者上一篇關於代理模式的介紹《JDK動態代理[1]----代理模式實現方式的概要介紹》

上一篇動態代理的測試類中使用了Proxy類的靜態方法newProxyInstance方法去生成一個代理類，這個靜態方法接收三個參數，分別是目標類的類加載器，目標類實現的接口集合，InvocationHandler實例，最后返回一個Object類型的代理類。我們先從該方法開始，看看代理類是怎樣一步一步造出來的，廢話不多說，直接上代碼

newProxyInstance方法：

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h) throws IllegalArgumentException {
    //驗證傳入的InvocationHandler不能為空
    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);
        }
        //獲取參數類型是InvocationHandler.class的代理類構造器
        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;
                }
            });
        }
        //傳入InvocationHandler實例去構造一個代理類的實例
        //所有代理類都繼承自Proxy, 因此這里會調用Proxy的構造器將InvocationHandler引用傳入
        return cons.newInstance(new Object[]{h});
    } catch (Exception e) {
        //為了節省篇幅, 筆者統一用Exception捕獲了所有異常
        throw new InternalError(e.toString(), e);
    }
}

可以看到，newProxyInstance方法首先是對參數進行一些權限校驗，之后通過調用getProxyClass0方法生成了代理類的類對象，然后獲取參數類型是InvocationHandler.class的代理類構造器。檢驗構造器是否可以訪問，最后傳入InvocationHandler實例的引用去構造出一個代理類實例，InvocationHandler實例的引用其實是Proxy持有着，因為生成的代理類默認繼承自Proxy，所以最后會調用Proxy的構造器將引用傳入。在這里我們重點關注getProxyClass0這個方法，看看代理類的Class對象是怎樣來的，下面貼上該方法的代碼

getProxyClass0方法：

private static Class<?> getProxyClass0(ClassLoader loader,
                                       Class<?>... interfaces) {
    //目標類實現的接口不能大於65535
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }
    //獲取代理類使用了緩存機制
    return proxyClassCache.get(loader, interfaces);
}

可以看到getProxyClass0方法內部沒有多少內容，首先是檢查目標代理類實現的接口不能大於65535這個數，之后是通過類加載器和接口集合去緩存里面獲取，如果能找到代理類就直接返回，否則就會調用ProxyClassFactory這個工廠去生成一個代理類。關於這里使用到的緩存機制我們留到下一篇專門介紹，首先我們先看看這個工廠類是怎樣生成代理類的。

ProxyClassFactory工廠類：

//代理類生成工廠
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) {
            //這里遍歷interfaces數組進行驗證, 主要做三件事情
            //1.intf是否可以由指定的類加載進行加載
            //2.intf是否是一個接口
            //3.intf在數組中是否有重復
        }
        //生成代理類的包名
        String proxyPkg = null;
        //生成代理類的訪問標志, 默認是public final的
        int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
        for (Class<?> intf : interfaces) {
            //獲取接口的訪問標志
            int flags = intf.getModifiers();
            //如果接口的訪問標志不是public, 那么生成代理類的包名和接口包名相同
            if (!Modifier.isPublic(flags)) {
                //生成的代理類的訪問標志設置為final
                accessFlags = Modifier.FINAL;
                //獲取接口全限定名, 例如：java.util.Collection
                String name = intf.getName();
                int n = name.lastIndexOf('.');
                //剪裁后得到包名:java.util
                String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                //生成的代理類的包名和接口包名是一樣的
                if (proxyPkg == null) {
                    proxyPkg = pkg;
                } else if (!pkg.equals(proxyPkg)) {
                    //代理類如果實現不同包的接口, 並且接口都不是public的, 那么就會在這里報錯
                    throw new IllegalArgumentException(
                        "non-public interfaces from different packages");
                }
            }
        }
        //如果接口訪問標志都是public的話, 那生成的代理類都放到默認的包下：com.sun.proxy
        if (proxyPkg == null) {
            proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
        }
        //生成代理類的序號
        long num = nextUniqueNumber.getAndIncrement();
        //生成代理類的全限定名, 包名+前綴+序號, 例如：com.sun.proxy.$Proxy0
        String proxyName = proxyPkg + proxyClassNamePrefix + num;
        //這里是核心, 用ProxyGenerator來生成字節碼, 該類放在sun.misc包下
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName,
                                  interfaces, accessFlags);
        try {
            //根據二進制文件生成相應的Class實例
            return defineClass0(loader, proxyName, proxyClassFile, 
                              0, proxyClassFile.length);
        } catch (ClassFormatError e) {
            throw new IllegalArgumentException(e.toString());
        }
    }
}

該工廠的apply方法會被調用用來生成代理類的Class對象，由於代碼的注釋比較詳細，我們只挑關鍵點進行闡述，其他的就不反復贅述了。

1. 在代碼中可以看到JDK生成的代理類的類名是“$Proxy”+序號。

2. 如果接口是public的，代理類默認是public final的，並且生成的代理類默認放到com.sun.proxy這個包下。

3. 如果接口是非public的，那么代理類也是非public的，並且生成的代理類會放在對應接口所在的包下。

4. 如果接口是非public的，並且這些接口不在同一個包下，那么就會報錯。

生成具體的字節碼是調用了ProxyGenerator這個類的generateProxyClass方法。這個類放在sun.misc包下，后續我們會扒出這個類繼續深究其底層源碼。到這里我們已經分析了Proxy這個類是怎樣生成代理類對象的，通過源碼我們更直觀的了解了整個的執行過程，包括代理類的類名是怎樣生成的，代理類的訪問標志是怎樣確定的，生成的代理類會放到哪個包下面，以及InvocationHandler實例的引用是怎樣傳入的。不過讀者可能還會有疑問，WeakCache緩存是怎樣實現的？為什么proxyClassCache.get(loader, interfaces)最后會調用到ProxyClassFactory工廠的apply方法？在下一篇中將會為讀者詳細介紹WeakCache緩存的實現原理。