cyxCoder

一、相关测试代码

模拟一个用户接口：

public interface UserService {
    public void findUser();
}

模拟一个简单的实现：

public class UserServiceImpl implements UserService {
    @Override
    public void findUser(){
        System.out.println("从数据库查找用户>>>>>>");
    }
}

二、JDK动态代理实现

实现JDK中的InvocationHandler接口，编写一个记录运行时间的处理器：

package com.cyx.demo.proxy;

import com.cyx.demo.service.UserService;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 打印运行时间的动态代理处理器
 */
public class RunTimeInvocationHandler implements InvocationHandler {
    /**
     * 被代理类对象 目标代理对象
     */
    private Object target;

    public RunTimeInvocationHandler(UserService userService) {
        target = userService;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("生成的代理类："+proxy.getClass().toString());
        Long start = System.currentTimeMillis();
        Object reuslt = method.invoke(target, args);// java的反射机制执行方法 执行目标对象的方法
        System.out.println("方法执行结束，共用时："+(System.currentTimeMillis()-start)+"毫秒");
        return reuslt;
    }

    /**
     * 使用jdk动态代理创建代理类
     * @param <T>
     * @return
     */
    public <T> T getProxy() {
        return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }
}

编写一个测试类，执行

package com.cyx.demo;

import com.cyx.demo.proxy.RunTimeInvocationHandler;
import com.cyx.demo.service.UserService;
import com.cyx.demo.service.impl.UserServiceImpl;

public class Application {
    public static void main(String[] args) {
        //将JDK动态代理生成的class文件保存到本地
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        //使用jdk动态代理
        UserService proxy = new RunTimeInvocationHandler(new UserServiceImpl()).getProxy();
        proxy.findUser();
    }
}

查看运行结果：

并且因为在测试类里，设置了把生成的动态代理类保存到本地，所以在工程目录下生成了com/sun/proxy/$Proxy0.class文件。

三、JDK动态代理分析

根据上面的测试代码运行结果，可以分析出一些东西：

JDK动态代理自己生成了一个类，如上叫$Proxy0，用其代替了new UserServiceImpl来进行后续业务操作。

动态代理处理类要实现InvocationHandler接口，重写invode方法，同时通过构造函数、setXXX等方式把需要代理的类传入进去

通过处理类中的invode方法对被代理类中所有方法实现了增强（在被代理接口上多加几个测试方法一试就知），当然因为拿到了Method对象，所以也可以编写逻辑只对某些指定方法增强。（是不是就想到了spring的AOP？）

因此就产生了下面几个问题：

生成的代理类里面是什么样子？

InvocationHandler处理器怎么和代理类相关联实现的方法增强？

保存在本地的是$Proxy0.class（注意这个不是java文件，而是编译好的class文件），那么是怎么生成的这个文件。

怎么把class文件加载到jvm中供程序调用。

 

带着问题继续进行分析。

3.1、分析自动生成的代理类源码

回答上面的第一个问题：把上文保存的代理类$Proxy0.class反编译出来，看看JDK自动生成的代理类长的什么样子：

package com.sun.proxy;

import com.cyx.demo.service.UserService;
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 UserService {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    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 void findUser() throws  {
        try {
            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);
        } 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.cyx.demo.service.UserService").getMethod("findUser");
            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());
        }
    }
}

 

上面的源码，从上到下，一步步进行分析：

1、代理类$Proxy0继承自Proxy,实现了要代理的接口。所以说JDK的动态代理通过接口实现（扩展：CGLIB通过继承，用SAM字节码技术实现。）。为什么不能通过继承实现？因为$Proxy0已经继承了Proxy。（一看就是个很厉害的类）

      Proxy干啥的呢？一看名字就是JDK里专门处理动态代理的类，并且上文编写动态代理处理器（RunTimeInvocationHandler）的时候已经用到，再看看：

    /**
     * 使用jdk动态代理创建代理类
     * @param <T>
     * @return
     */
    public <T> T getProxy() {
        return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

代理类$Proxy0就是通过Proxy.newProxyInstance实现的，这个方法先放这里，稍后专门分析。

继续分析代理类$Proxy0的源码：

一看这个，原来就是通过Java反射把被代理接口中的方法注入进来。怎么到这里来的？Proxy.newProxyInstance的第二个参数传入进去的。

然后看看构造函数，就只有一个构造函数如下：

也就是实例化$Proxy0的时候必须得传入动态代理处理器（在此就是RunTimeInvocationHandler对象），怎么传入进去的呢？也是通过Proxy.newProxyInstance方法，RunTimeInvocationHandler类getProxy方法里调用Proxy.newProxyInstance其第三个参数传入了一个this。

在此自动生成的代理类$Proxy0的源码所需要传入的东西都清楚里，都是通过Proxy.newProxyInstance传入：

1、被代理类的接口，可以是多个，所以是个数组。用以知道要在代理类中生成多少个方法。

2、代理处理器对象，通过构造方法注入到要生成的代理类中，以实现方法增强。

最后来看看方法里怎么实现的方法增强，以findUser为例：

super.h是什么？就是$Proxy0构造函数中传入的动态代理处理器（在此就是RunTimeInvocationHandler对象），然后调用了父类的构造函数传入，如下：

在此就可以回答第二个问题了：InvocationHandler处理器怎么和代理类相关联实现的方法增强？

InvocationHandler处理器通过Proxy.newProxyInstance其第三个参数传入代理类中，newProxyInstance方法在实例化代理类$Proxy0时把InvocationHandler处理器注入到构造方法中，代理类$Proxy0每个方法的实现，都会调用处理器中的invode方法。

 

3.2、分析Proxy.newProxyInstance中的源码

因为篇幅原因，如下所有代码都没把所有源代码都粘贴出来了，只把P其中的关键代码提取出来，去掉了里面很多不相关和验证代码。

第一步：首先看Proxy类的newProxyInstance：

public class Proxy{
    private static final Class<?>[] constructorParams = { InvocationHandler.class };
    /*
     * 第一个参数类加载器
     * 第二个参数类所继承的接口class（可以通过反射获得）
     * 第三个参数InvocationHandler处理器
     */
    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h){
    
        final Class<?>[] intfs = interfaces.clone();
        //1、生成了com.sun.proxy.$Proxy0的Class,这里还没初始化(会先去缓存中查找，没有再生成)
        Class<?> cl = getProxyClass0(loader, intfs);
        //2、获得构造器对象，参数是InvocationHandler.class
        final Constructor<?> cons = cl.getConstructor(constructorParams);
        //3、把InvocationHandler传入构造函数，实例化对象
        return cons.newInstance(new Object[]{h});
    }
}

如上可知，其实newProxyInstance里就干了3件事：

1、生成代理类的Class

2、通过class获得构造函数

3、通过构造函数实例化对象

关于2、3其实就是Java反射机制，这里就不去多讲了。

第二步：然后继续查看源码，分析如何自动生成的代理类的Class:

public class Proxy{
    private static final WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

    private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) {
        //相当于先从缓存中拿一下，有就返回缓存的副本，没有就从ProxyClassFactory里创建代理类
        //ProxyClassFactory的实例就在上面new WeakCache的时候创建
        return proxyClassCache.get(loader, interfaces);
    }
}

如上（依然只贴了关键代码），这还不是关键点，只是把类加载器和需要代理的接口数组传入get方法中。proxyClassCache就是WeakCache类。

第三步：继续查看WeakCache中get方法：

final class WeakCache<K, P, V> {
    public WeakCache(BiFunction<K, P, ?> subKeyFactory, BiFunction<K, P, V> valueFactory) {
        this.subKeyFactory = Objects.requireNonNull(subKeyFactory);
        this.valueFactory = Objects.requireNonNull(valueFactory);
    }
    /**
     * @param key 类加载器
     * @param parameter 接口数组，传入的Class<?>[] interfaces
     */
    public V get(K key, P parameter) {
        //缓存部分就不做详细讲解，就是尝试去缓存中获得以下供应商（supplier）,虽然说过程可能有点复杂
        Supplier<V> supplier = valuesMap.get(subKey);
        WeakCache.Factory factory = null;
        //死循环，循环第一次会去创建supplier和factory
        while (true) {
            if (supplier != null) {
                V value = supplier.get();//在此就进入到了内部类Factory的get方法中
                if (value != null) {//如果有数据就取出来返回
                    return value;
                }
            }
            //否则就说明缓存中没有供应商（supplier）或者供应商中没有数据 或者 工厂类没有成功加载
            //懒加载的方式把供应商创建出来，关键代码就如下两行
            //把类加载器和接口数组继续传入到Factory类中
            factory = new Factory(key, parameter, subKey, valuesMap);
            supplier = factory;
        }
    }
    //Factory是WeakCache内部类，实现了Supplier接口
    private final class Factory implements Supplier<V> {
        //把类加载器和接口数组通过构造方法传入
        Factory(K key, P parameter, Object subKey,
                ConcurrentMap<Object, Supplier<V>> valuesMap) {
            this.key = key;
            this.parameter = parameter;
            this.subKey = subKey;
            this.valuesMap = valuesMap;
        }

        @Override
        public synchronized V get() {
            V value = null;
            //valueFactory就是ProxyClassFactory的实例
            //valueFactory是在Proxy类中(第二步所示代码中)new WeakCache时通过构造方法传入
            value = Objects.requireNonNull(valueFactory.apply(key, parameter));
            return value;
        }
    }
}

如上，精简之后看起来好像还是很多，但其实核心就两行：

1、V value = supplier.get();

2、value = Objects.requireNonNull(valueFactory.apply(key, parameter));

先调用内部类Factory中的get方法，,然后内部类Factory的get方法继续调用ProxyClassFactory的apply方法对代理类Class进行创建。

也就是最终是在ProxyClassFactory中的apply方法中，传入类加载器和被代理类的接口数组，生成了代理类$Proxy0的Class。

ProxyClassFactory对象在哪生成的？WeakCache的构造函数中传入的，看第二步代码，Proxy类实例化proxyClassCache时。

第四步：看看ProxyClassFactory中的apply方法

ProxyClassFactory是Proxy的一个私有的静态内部类，apply方法里面一大串验证，验证接口，验证，就不贴出来了，

 private static final String proxyClassNamePrefix = "$Proxy";
    private static final AtomicLong nextUniqueNumber = new AtomicLong();
    @Override
    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
            // 如果没有非公共代理接口，则使用com.sun.proxy 包
            proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
        }
        /*
         * Choose a name for the proxy class to generate.
         * 为要生成的代理类选择一个名称,其实就是在类名$Proxy后面增加自增的数字
         */
        long num = nextUniqueNumber.getAndIncrement();
        String proxyName = proxyPkg + proxyClassNamePrefix + num;

        /*
         * Generate the specified proxy class. 
         * 干货来了，在这里生成代理类的class字节码
         */
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
        try {
            //这里调用的defineClass0是native方法，跟不了了，功能就是把字节数组加入类加载器。
            return defineClass0(loader, proxyName,
                    proxyClassFile, 0, proxyClassFile.length);
        } catch (ClassFormatError e) {
            throw new IllegalArgumentException(e.toString());
        }
    }

如上代码，其实就干了3件事：

1、创建名字

2、通过ProxyGenerator.generateProxyClass生成代理类的class字节码

3、把字节码加载到JVM中

 

在此基本完了也能回答最开始提的第三、第四个问题：

问题三：保存在本地的是$Proxy0.class（注意这个不是java文件，而是编译好的class文件），那么是怎么生成的这个文件？

      通过ProxyGenerator类对jdk动态代理进行生成，直接生成的class字节码，没有生成Java文件，然后直接加载到JVM中。

要在程序中加入System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");代码，就会生成上文反编译看到的class文件。

问题四：怎么把class文件加载到jvm中供程序调用。

     JDK动态代理是在ProxyClassFactory中的apply方法里调用了native方法defineClass0加载到JVM中。但其实ClassLoader其实也可以加载字节数组，在后续文章中写一个高仿JDK动态代理，再来用ClassLoader实现试试。

 

总结和后续

newProxyInstance里干的3件事：1、生成代理类的Class；2、通过class获得构造函数；3、通过构造函数实例化对象；

生成代理类的Class，看上面看起来复杂，其实如果把里面的缓存部分都去掉，其实就是调用ProxyClassFactory类中的apply方法，不过因为ProxyClassFactory是Proxy的一个私有的静态内部，所以只能在Proxy中调用它。

ProxyGenerator是jre的lib文件夹下的rt.jar包里的类，具体有什么用可以参考文章末尾的参考链接。

 

JDK动态代理是对接口进行代理实现，上文中的示例代码是用JDK的动态代理对实现类进行增强。其用处不仅于此，还可以用动态代理直接生成接口的实现类，达到对接口动态的实现。

 

后续：抽时间写一个高仿低配的JDK动态代理，会自定义代理类、处理器接口、通过自定义类加载器加载class的字节数组。

 

参考链接：

代理模式详解：https://www.cyxcoder.com/article/17

蚂蚁课堂： http://www.mayikt.com/front/couinfo/194/0

ProxyGenerator介绍：https://www.cnblogs.com/liuyun1995/p/8144706.html

怎样从OpenJDK下载源码：https://my.oschina.net/u/2518341/blog/1931088