jdk 动态代理源码分析

闲来无事，撸撸源码

食用方法

直接看代码吧。。

package com.test.demo.proxy;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;/** * 每个代理对象 内部都有一个实现了InvocationHandler接口的 类的实例 * * InvocationHandler 顾名思义就是 代理对象的方法调用的处理类(调用它的invoke方法) * * @author lizhecao 2018/4/19 * @version 1.0 */public class InvocationHandlerImpl implements InvocationHandler {  // 目标对象  private Object target;  public InvocationHandlerImpl(Object target) {    this.target = target;  }  @Override  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {    // 代理方法简单地打下日志，这其实就是spring aop的简单实现    System.out.println("start");// 调用目标对象的实际方法    Object result = method.invoke(target, args);    System.out.println("end");    return  result;  }  /**   * 通过Proxy.newProxyInstance 生成代理对象（重要的方法）   */  public Object getProxy() {    return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),        target.getClass().getInterfaces(), this);  }  public static void main(String[] args) {    // 实例化目标对象    User user = new UserImpl();    // 用目标对象实例化InvocationHandler    InvocationHandlerImpl invocationHandler = new InvocationHandlerImpl(user);    // 生成代理对象    User proxyUser = (User) invocationHandler.getProxy();    // 调用代理对象的方法，实际上就是调用了invocationHandler的invoke方法    proxyUser.sayHello();  }}

package com.test.demo.proxy;/** * 目标类的接口，jdk动态代理的类一定要实现某一个接口 * * @author lizhecao 2018/4/19 * @version 1.0 */public interface User {  void sayHello();}

package com.test.demo.proxy;/** * 目标对象的具体类 * * @author lizhecao 2018/4/19 * @version 1.0 */public class UserImpl implements User {  @Override  public void sayHello() {    System.out.println("hello");  }}

运行了InvocationHandlerImpl中的main方法我们会得到结果：

starthelloend

理解原理

通过上面的例子可以看到，生成代理对象的重点是

Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),        target.getClass().getInterfaces(), this);

这个方法，我们进入这个方法看看jdk动态代理的具体实现。
去繁就简，删掉一些不关注的东西，有兴趣的自己一一过下

/**     * 返回指定接口的代理类实例，并分配方法的调用给指定的invocationHandler     *     * @param   loader 用来define代理类的 类加载器     * @param   interfaces 代理类要实现的接口（这里也说明了jdk动态代理对象必须实现接口）     * @param   h 用来分配方法调用的 invocation handler     * @return  一个实现了特定接口，用特定的class loader define的包含特定的invocation hanlder的代理类的实例     */    @CallerSensitive    public static Object newProxyInstance(ClassLoader loader,                                          Class<?>[] interfaces,                                          InvocationHandler h)        throws IllegalArgumentException    {    // 不允许hanlder 为空（不然搞啥）        Objects.requireNonNull(h);// 防止接口被改        final Class<?>[] intfs = interfaces.clone();        /*         * 查找或生产指定代理类（也就是说有缓存机制）（这里是重点，生产了代理类的Class！！）         */        Class<?> cl = getProxyClass0(loader, intfs);        /*         * 用我们的handler 作为proxy class的构造方法的参数，创建proxy 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;                }            });        }        return cons.newInstance(new Object[]{h});    }

继续看这个getProxyClass0(loader, intfs) 是怎么生产代理类的

    private static Class<?> getProxyClass0(ClassLoader loader,                                           Class<?>... interfaces) {        // 接口的数量不能超过65535个（呵呵）        if (interfaces.length > 65535) {            throw new IllegalArgumentException("interface limit exceeded");        }                // 从WeakCache的缓存中获取，如果没有就创建        return proxyClassCache.get(loader, interfaces);    }

这里是通过WeakCache缓存了代理类的实例，就是这货

    /**     * a cache of proxy classes     */    private static final WeakCache<ClassLoader, Class<?>[], Class<?>>        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

这里简单讲下WeakCache，不然没玩过的朋友可能看不下去了。
WeakCache<K, P, V> 缓存的是<key, sub-key> -> value这样的键值对，key和value是弱引用的，sub-key是强引用的（当然，这不重要）K， P， V分别表示key，参数，value的类型。有人会好奇，那sub-key呢？参数用来干嘛？我们重点看它的构造方法

    /**     * @param subKeyFactory 一个这样 (key, parameter) -> sub-key 的函数     * @param valueFactory  一个那样 (key, parameter) -> value的函数     */    public WeakCache(BiFunction<K, P, ?> subKeyFactory,                     BiFunction<K, P, V> valueFactory) {        this.subKeyFactory = Objects.requireNonNull(subKeyFactory);        this.valueFactory = Objects.requireNonNull(valueFactory);    }

可以看到，只要传入两个函数类，就可以通过key 和 parameter 分别生成 sub-key和value了，这样我们就可以理解生成代理对象的这一句

// 第一次获取proxy class就会通过loader 和 interfaces 分别生成缓存的subkey 和 value， 并且返回valuereturn proxyClassCache.get(loader, interfaces);

那么我们也知道了这个value是通过valueFactory生成的，参数是loader 和 interface，那么看下proxyClassCache的实例化方法： new WeakCache<>(new KeyFactory(), new ProxyClassFactory()) 就知道了这个ProxyClassFactory类就是真正实现了(loader, interface) -> proxyClass 的函数式类了，赶紧看下

   /**     * 使用给定的ClassLoader 和 接口数组来 生成，define，返回代理类的函数工厂     */    private static final class ProxyClassFactory        implements BiFunction<ClassLoader, Class<?>[], Class<?>>    {        // 所有代理类名称的前缀（有时候debug不是会经常看到这个名称吗哈哈）        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 loader根据类的名称 解析出来的 class跟我们传进来的是否一样（相当于看下是不是同一个loader加载的吧）                 */                Class<?> interfaceClass = null;                try {                    interfaceClass = Class.forName(intf.getName(), false, loader);                } catch (ClassNotFoundException e) {                }                // 如果不一样，抛异常（loader说我不认识这个接口class）                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;            /*             * 这下面一大段就是确定下代理类要放在哪个包下             * 如果存在非public的接口，那么proxy class就要放在跟她同一个目录下             * 而且非public的接口一定要在同一个目录下（不然放哪里都有问题）             */            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");                    }                }            }// 如果接口都public，那么就是放到com.sun.proxy 包下            if (proxyPkg == null) {                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";            }            /*             * 用原子数字自增产生的一个代理类的唯一的代号             */            long num = nextUniqueNumber.getAndIncrement();            String proxyName = proxyPkg + proxyClassNamePrefix + num;            /*             * 上面啪啦啪啦一大堆，其实都是一些验证啊，确定包的位置啊，名称啊的细碎的东西             * 下面这一句才是重点，通过ProxyGenerator产生了代理类的 class 文件的字节数组             */            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(                proxyName, interfaces, accessFlags);            try {            // 最后通过native方法 来生成Class 对象                return defineClass0(loader, proxyName,                                    proxyClassFile, 0, proxyClassFile.length);            } catch (ClassFormatError e) {                throw new IllegalArgumentException(e.toString());            }        }    }

ProxyGenerator 是sun.misc包里面的方法，没有开源，所以我们简单撸一下即可

  public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {    ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);    // 生成class文件的字节数组    final byte[] var4 = var3.generateClassFile();    // 如果saveGeneratedFiles为true，那么将.class文件写到硬盘中    if (saveGeneratedFiles) {      // 省略具体保存文件方法    }    return var4;  }

看下这个保存文件的条件

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

也就是说只要我们设置了这个"sun.misc.ProxyGenerator.saveGeneratedFiles" 系统值为true就可以保存文件了
话不多说来看看jdk动态代理给我们自动生成的这个class文件长什么样吧，用以下代码来测试

package com.test.demo.proxy;import sun.misc.ProxyGenerator;import java.io.FileOutputStream;import java.io.IOException;/** * 写代理类文件到磁盘中 * * @author lizhecao 2018/4/20 * @version 1.0 */public class ProxyClassGen {  public static void main(String[] args) throws IOException {//    // 第一种方法，直接将生成的字节数组写到文件中//    byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy33", UserImpl.class.getInterfaces());////    try(FileOutputStream outputStream = new FileOutputStream(//        "/Users/lizhecao/java/demo/src/main/java/com/test/demo/proxy/$Proxy33.class")) {//      outputStream.write(bytes);//    }    // 第二种方法，设置系统属性值，有jdk自动写    System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");    ProxyGenerator.generateProxyClass("$Proxy34", UserImpl.class.getInterfaces());  }}

运行之后可以看到在项目的根目录下产生了$Proxy34.class 这么一个文件，用ide直接打开可以看到如下内容

//// Source code recreated from a .class file by IntelliJ IDEA// (powered by Fernflower decompiler)//import com.test.demo.proxy.User;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import java.lang.reflect.UndeclaredThrowableException;public final class $Proxy34 extends Proxy implements User {  private static Method m1;  private static Method m3;  private static Method m2;  private static Method m0;  public $Proxy34(InvocationHandler var1) throws  {    super(var1);  }  // 除了接口方法之外，还实现了Object的equals, hashCode和toString方法  public final boolean equals(Object var1) throws  {    try {      return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();    } catch (RuntimeException | Error var3) {      throw var3;    } catch (Throwable var4) {      throw new UndeclaredThrowableException(var4);    }  }  // 实现了我们的User接口的sayHello方法  public final void sayHello() throws  {    try {      // 内部其实就是调用了invokeHandler实例的invoke方法      // 在最下面可以看到m3 就是通过反射获取的User接口的sayHello Method      // Class.forName("com.test.demo.proxy.User").getMethod("sayHello");      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)).intValue();    } 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.test.demo.proxy.User").getMethod("sayHello");      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());    }  }}

到了这里，jdk动态代理就已经是拨开云雾见青天，一清二楚了