Jdk动态代理原理解析

---

• title: Jdk动态代理原理解析
• tags:代理
• categories:笔记
• date: 2017-06-14 9:48:05

---

动态代理这个知识点,也是我们开发过程中非常容易遇到。特别的是在一些框架中，为了满足软件开发的开闭原则，以及增强框架自身的灵活拓展功能。在底层就会为那些特定的目标类或者接口实现类进行渲染与自定义功能操作。就如spring框架中的aop，底层也是通过动态代理来实现的，所以，就像看看jdk自身的动态代理是如
何实现的，整个过程是如何流动的。

image

什么是动态代理，有什么优势？

动态，指的是代理类实在程序运行时创建的，而不是在程序运行前手动编码来定义代理类的。这些动态代理类是在运行时候根据我们在JAVA代码中
的“指示”动态生成的。相比于静态代理，动态代理的优势在于可以很方便的对代理类的函数进行统一处理，而不用修改每个代理类的函数。
有点类似于AOP的动态切面编程，为程序以供一些基础公用的实现，而不用分别针对每个实际类的方法进行前后环绕处理。有很多框架都是基于反射和动态代理基础上进行框架能力扩展，并实现JAVASE平台上基础接口或者继承类进而实现与JAVASE平台的耦合。

动态代理使用场景，有哪些类别？

动态代理的使用方式呢，主要就是分为两种：一种是基于接口的代理；另一种则是基于类的代理。基于接口的代理，就是jdk自带的动态代理规则的实现方式，后者则是基于一些字节类增强的类代理，如cglib,javassist等。

但是，动态代理实际的操作对象，都是在目标类的基础上，生成一个具有代理目的，增强功能的新的代理proxy字节码类。都是在复合class字节码的规范下，对class字节文件内的内容进行操作，最后将生成的字节类对应的代理类，通过类加载器加载到JVM中，进行使用。

● JDK自带的基于接口Interface的代理
● 三方CGLIB,JAVASSIST等字节码处理的类库，是基于Class类来实现代理

动态代理原理分析

说完了，动态代理的概念和大致的种类划分，现在就基于jdk自己的基于接口的动态代理来进行分析，通过实际的代码样例，逐步分析每个过程，到最后目标类的扩展完成。

动态代理使用

【1】jdk代理代码样例：
结合最上面的，代理结构图，可以知道。jdk代理最主要的就是三个类：目标接口，目标类(实现了目标接口),扩展处理器InvocationHandler类。

//目标接口，对应ITraget
public interface Subject {
    void hello(String str);
}

//目标类，对应Target
public class RealSubject implements Subject{
    public void hello(String str) {
        System.out.println("hello" + str);
    }
}

//InvocationHandler增强处理器接口实现类
//方法调用句柄invoke方法内部就是代理类的扩展点
public class DynamicProxy implements InvocationHandler{

    private Object target;//反射代理目标类(被代理，解耦的目标类)
    
    //可以通过构造器动态设置被代理目标类，以便于调用指定方法
    public DynamicProxy(Object subject){
        this.target = subject;
    }
    
    //代理过程中的扩展点
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("brfore call specific method >>" + method.getName());
        Object result = method.invoke(target, args);//MethodAccessor.invoke()
        System.out.println("after call specific method>>" + method.getName());
        return result;
    }
}

【2】客户端调用：
在定义完动态代理几种基本类型之后，就可以在客户端中进行代理实现。为了更清楚说明这个动态代理的过程，可以分为以下两种情形来进行使用分析：
（1）冗余型：过程清新，代码冗余

    @Test
    public void t() throws Exception{
        Subject realSubject = new RealSubject();
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true"); 
        //1.0 获取代理类的类对象，主要设置相同的ClassLoader去加载目标类实现的接口Subject类
        Class proxyClass = Proxy.getProxyClass(Client.class.getClassLoader(), new Class[]{Subject.class});
        //2.0 得到代理类后，就可以通过代理类的处理器句柄来得到构造器
        final Constructor con = proxyClass.getConstructor(InvocationHandler.class);
        //3.0 获取具体执行方法的句柄处理器，目的通过构造器传入被代理目标类对象，注入到代理类处理器句柄中进行代理调用
        final InvocationHandler handler = new DynamicProxy(realSubject);
        //4.0 通过构造器创建代理类对象
        Subject subject = (Subject)con.newInstance(handler);
        
        //5.0 最后调用方法
        subject.hello("proxy");

（2）简洁型：过程不是很清新，但是代码简洁
这种使用方式，也是我们经常看到的。

    //设置生成代理类文件到本地
    System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true"); 
    Subject subject2 = (Subject)Proxy.newProxyInstance(Client.class.getClassLoader(),
                         new Class[]{Subject.class}, new DynamicProxy(new RealSubject()));
    //调用代理类方法
    subject2.hello("proxy");

【3】使用分析：
通过上述代码可以知道，jdk中的接口代理有几个重要的点：

1. 最后方法的调用一定是声明在接口的方法。只是具体动态方法调用的时候，执行的是接口实现子类中方法。
2. 方法的调用点一定是在InvocationHandler接口或者其子类的invoke方法中，并且该接口中存在目标类的对象（依赖），这里也是代理类的拓展点。
3. 方法调用的对象，一定是通过构造器形式来创建出来的。

在按照规定，正确使用了proxy动态代理之后，会思考：为什么jdk的代理一定是基于接口实现的呢？
这里，可以先说说分析后的想法：

因为在动态代理过程中，会生成对应的代理类形如$Proxy0,$Proxy1....这样的匿名类，这些类都是继承java.lang.reflect.Proxy类和实现了我们传入
的接口，形如:public final class $Proxy0 extends Proxy implements Subject .所以，通过Proxy.newProxyInstance方法返回的就是这个匿名类的实例。通常就通过强制转换成指定接口，最后就可以调用方法了。【java中不能多重继承，当代理匿名类实现了jdk中的Proxy.class类的时候，就只能通过实现目标接口的方式来实现拓展】

(Subject)Proxy.newProxyInstance(Client.class.getClassLoader(), new Class[]{Subject.class}, new DynamicProxy(new RealSubject()))

若是强制转换成接口实现子类，形如：

(RealSubject)Proxy.newProxyInstance(Client.class.getClassLoader(), 
new Class[]{Subject.class}, new DynamicProxy(new RealSubject()))

就会报如下错误：
java.lang.ClassCastException: com.sun.proxy.$Proxy0 cannot be cast to proxy.RealSubject。

代理流程分析

就基于上述使用的样例中的动态代理的代码，对每个步骤的过程进行分析。看看，每个步骤内部是如何运行的。
因为，整个jdk动态代理过程都与java.lang.reflect.Proxy类有关，就先看看该类中一些重要分属性字段：

image

生成代理类

然后，整体看看创建代理对象newProxyInstance方法源代码:

    public static Object newProxyInstance(ClassLoader loader,
                                          Class[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        if (h == null) {
            throw new NullPointerException();
        }

        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, interfaces);
        }

        /*
         * Look up or generate the designated proxy class.
         */
        Class cl = getProxyClass0(loader, interfaces);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            final Constructor cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
                // create proxy instance with doPrivilege as the proxy class may
                // implement non-public interfaces that requires a special permission
                return AccessController.doPrivileged(new PrivilegedAction