JDK 动态代理源码解读

在Jdk 动态代理使用的过程中，程序入口为 Proxy.newProxyInstance， 通过对程序调用的跟踪，可以得到如下时序图。

在 newProxyInstance 方法里面，主要做了两件事情：

一、生成指定的代理类;

二、使用 InvocationHandler 创建一个代理类实例;

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
    ...

    /*
     * 查找并生成指定的代理类。
     */
    Class<?> cl = getProxyClass0(loader, intfs);

    /*
     * 使用特定的 InvocationHandler 调用其构造方法。
     */
    try {
        ...
        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 (IllegalAccessException|InstantiationException e) {
        ...
    }
}

代理类的Class对象由 ProxyClassFactory 进行生成，流程主要包括类名生成，字节码文件生成及字节码加载。其中类名主要由三部分组成，包名（一般com.sun.proxy）、代理类名前缀（写死为 $Proxy）、一个自增的数字（保证类名唯一）。

// prefix for all proxy class names
private static final String proxyClassNamePrefix = "$Proxy";

// next number to use for generation of unique proxy class names
private static final AtomicLong nextUniqueNumber = new AtomicLong();

public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

    ...

    String proxyPkg = null;     // package to define proxy class in
    int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

    ...

    if (proxyPkg == null) {
        // if no non-public proxy interfaces, use com.sun.proxy package
        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) {
        ...
    }
}

类名规则知道了，但具体生成的字节码文件，仍然不太清晰，下面我们将动态生成的字节码文件输出。在源码中可以看到，字节码文件是由 ProxyGenerator 生成的，在该类里面存在一个配置项用于判定是否输出生成的字节码内容。

private static final boolean saveGeneratedFiles = (Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"));

在调用代理生成前面，设置将该项系统配置设置成 true 即可输入字节码文件。

public static void main(String[] args) {
    System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
    SystemMgr proxyInstance = (SystemMgr) Proxy.newProxyInstance(SystemMgr.class.getClassLoader(),
            new Class[]{SystemMgr.class},
            new SystemMgrTxnInvocationHandler(new SystemMgrImpl()));
    System.out.println(proxyInstance.updateRole());
}

生成的 class 文件一般会放到 ${project.dir}/com/sun/proxy/ 目录下，通过反编译，可得到原代码如下：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.sun.proxy;

import com.qchery.basics.design.pattern.proxy.SystemMgr;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements SystemMgr {
    private static Method m1;
    private static Method m2;
    private static Method m0;
    private static Method m3;

    public $Proxy0(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 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);
        }
    }

    public final String updateUser() throws  {
        try {
            return (String)super.h.invoke(this, m3, (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"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            m3 = Class.forName("com.qchery.basics.design.pattern.proxy.SystemMgr").getMethod("updateUser");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

可以看到，代理类 $Proxy0 继承了 Proxy ，并通过其构造方法持有 InvocationHandler 对象，然后实现了自定义的接口 SystemMgr ，重写了接口中声明的方法 updateUser 以及 equals 等通用方法，将调用委托给 InvocationHandler 。

最终可以得到 JDK 动态代理的类图结构如下：