Java的动态代理机制

0. 什么是代理

代理是基本的设计模式之一，它是你为了提供额外的或不同的操作，而插入的用来代替“实际”对象的对象。

这些操作通常涉及与“实际”对象的通信，因此代理通常充当着中间人的角色。

代理这种设计模式是通过不直接访问被代理对象的方式，而访问被代理对象的方法。

从Java面向对象编程的角度，代理模式通常也涉及三个角色：

• （1）目标类（TargetSubject），也就是具体实现业务功能的类；
• （2）代理类（ProxyObject），提供一些被代理类功能之外的额外功能的类；
• （3）请求类（RequestObject），即：业务调用类。

1.动态代理和静态代理的区别

• 静态代理中对每一个TargetObject都要生成一个对应的ProxyObject，这样会造成类膨胀，并且不利于统一处理。

  • 静态代理是在编译时就引入代理类，
  • 而动态代理则是在运行时才动态生成代理类。

• 简单来说就是通过动态代理我们不再需要手动的去写一个一个的代理类了，而是在运行时动态代理技术自动帮我们生成这个代理类。

从上图也可以看出：TargetSubject和ProxyObject对外提供了统一的功能，那么结合Java的语言特性，要达到这样的效果，有两种方法：

• 一个是通过接口，TargetSubject和ProxyObject都实现同样的接口；
• 一个是通过继承，ProxyObject必须继承TargetSubject。

这两种方法也衍生出了Java中实现动态代理的两种方案：

• JDK动态代理
• Cglib动态代理。

2. 使用代理的情况

• (1)设计模式中有一个设计原则是开闭原则，是说对修改关闭对扩展开放，我们在工作中有时会接手很多前人的代码，里面代码逻辑让人摸不着头脑(sometimes the code is really like shit)，这时就很难去下手修改代码，那么这时我们就可以通过代理对类进行增强。
• (2)我们在使用RPC框架的时候，框架本身并不能提前知道各个业务方要调用哪些接口的哪些方法。那么这个时候，就可用通过动态代理的方式来建立一个中间人给客户端使用，也方便框架进行搭建逻辑，某种程度上也是客户端代码和框架松耦合的一种表现。
• (3)Spring的AOP机制就是采用动态代理的机制来实现切面编程。

3. 动态代理的构成

• 接口类
• 实现接口类的目标类
• 实现了InvocationHandler接口的代理类

在Java的动态代理机制中，有两个重要的类或接口，这一个类和接口是实现我们动态代理所必须用到的。

• Interface InvocationHandler
• Class Proxy

4. JDK中的动态代理

JDK动态代理的实现是：

• 在运行时，根据一组接口定义，使用Proxy、InvocationHandler等工具类去生成一个代理类和代理类实例。

JDK动态代理的类关系模型和静态代理看起来差不多。也是需要一个或一组接口来定义行为规范，需要一个代理类来实现接口。

区别是：没有真实类，因为动态代理就是要解决在不知道真实类的情况下依然能够使用代理模式的问题。

通过上图我们可以很清楚地看到JDK的动态代理机制实现的时候引入了一个公共的接口：InvocationHandler，而该接口由我们具体实现，并且要在具体的实现类中持有TargetSubject的引用。

由此，我们可以猜想是由InvocationHandler的具体实现类，提供了具体的代理业务逻辑。

并且需要指出的是，ProxyObject这个代理对象是在运行时生成的而不需要我们手动编写。

5. 手写一个JDK动态规划的demo

下面动手写个JDK动态代理的代码样例：

第一步，定义一个接口。

这个接口里面定义一个方法helloWorld()

/**
 * @Description 代理测试接口
 */
public interface MyIntf {
	void helloWorld();
}

第二步，编写一个我们自己的调用处理类，这个类需要实现InvocationHandler接口
InvocationHandler接口只有一个待实现的invoke()方法。
这个方法有三个参数：

• proxy表示动态代理类实例
• method表示调用的方法
• args表示调用方法的参数

在实际应用中，invoke()方法就是我们实现业务逻辑的入口。
这里我们的实现逻辑就一行代码，打印当前调用的方法（在实际应用中这么做是没有意义的，不过这里我们只想解释JDK动态代理的原理，所以越简单越清晰

/**
 * @Description 目标类
 */
public class MyInvocationHandler implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
    	System.out.println(method);
    	return null;
     }
}

第三步，直接使用Proxy提供的方法创建一个动态代理类实例。
并调用代理类实例的helloWorld()方法，检测运行结果

/**
 * @Description JDK动态代理测试类
 */
public class ProxyTest{
    public static void main(String[] args){
    	System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
    	MyIntf proxyObj = (MyIntf)Proxy
            .newProxyInstance(MyIntf.class.getClassLoader(),
                              new Class[]{MyIntf.class},
                              new MyInvocationHandler());
     	proxyObj.helloWorld();
     }
}

System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true")是设置系统属性，把生成的代理类写入到文件。这里再强调一下，JDK动态代理技术是在运行时直接生成类的字节码，并载入到虚拟机执行的。这里不存在class文件的，所以我们通过设置系统属性，把生成的字节码保存到文件，用于后面进一步分析。

.newProxyInstance就是调用Proxy.newProxyInstance方法创建一个动态代理类实例，这个方法需要传入三个参数：

• 第一个参数是类加载器，用于加载这个代理类
• 第二个参数是Class数组，里面存放的是待实现的接口信息
• 第三个参数是InvocationHandler实例

proxyObj.helloWorld();调用代理类的helloWorld()方法，运行结果：

public abstract void com.tuniu.distribute.openapi.common.annotation.MyIntf.helloWorld()

分析运行结果，就可以发现，方法的最终调用是分派到了MyInvocationHandler.invoke方法，打印出了调用的方法信息。

到这里，对于JDK动态代理的基本使用就算讲完了。

我们做的事情很少，只是编写了接口MyIntf和调用处理类MyInvocationHandler。

其他大部分的工作都是Proxy工具类帮我们完成的。

Proxy帮我们创建了动态代理类和代理类实例。

上面的代码我们设置了系统属性，把生成的字节码保存到class文件。

下面我们通过反编译软件（如jd-gui），看下Proxy类为我们生成的代理类是什么样子的。

package com.sun.proxy;

import com.tuniu.distribute.openapi.common.annotation.MyIntf;

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 MyIntf {
    private static Method m0;
    private static Method m1;
    private static Method m2;
    private static Method m3;

    static {
        try {
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m3 = Class.forName("com.tuniu.distribute.openapi.common.annotation.MyIntf").getMethod("helloWorld", new Class[0]);
            return;
        } catch (NoSuchMethodException localNoSuchMethodException) {
            throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
        } catch (ClassNotFoundException localClassNotFoundException) {
            throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
        }
    }

    public $Proxy0(InvocationHandler paramInvocationHandler) {
        super(paramInvocationHandler);
    }

    public final void helloWorld() {
        try {
            this.h.invoke(this, m3, null);
            return;
        } catch (Error | RuntimeException localError) {
            throw localError;
        } catch (Throwable localThrowable) {
            throw new UndeclaredThrowableException(localThrowable);
        }
    }

	//后面省略equals(),hashCode(),toString()三个方法的代码，因为这三个方法和helloWorld()方法非常相似
}

这里Proxy为我们生成的代理类叫$Proxy0，继承了Proxy，实现了我们定义的接口MyIntf。每一个JDK动态代理技术生成的代理类的名称都是由$Proxy前缀加上一个序列数0,1,2,...，并且都需要继承Proxy类。

$Proxy0类中11-14行代码定义了4个Method字段m0、m1、m2、m3。

我们先来看下m3，它描述了我们定义的接口MyIntf中的方法helloWorld()。

紧接着下面的34-43行代码就是对helloWorld()方法的实现，它的实现非常简单就一句话this.h.invoke(this, m3, null);这行代码就是调用当前对象的h实例的invoke()方法，也就是把方法的实现逻辑分派给了h.invoke()。

这里的h是继承父类Proxy中的InvocationHandler字段（读者可以结合上面的动态代理类图模型或者Proxy源码进一步理解）。

同时，代码30-32行$Proxy0提供了一个构造函数，调用父类的构造函数来注入这个InvocationHandler实例。

$Proxy0中的另外3个Method对象m0、m1、m2分别代表了Object类的hashCode()、equals()、toString()方法，Java中的所有类都是Object的子类（Object类本身除外），这里​$Proxy0重写了Object中的这三个方法。这三个方法的实现和helloWorld方法很类似，所以在这里就把这段代码省略了，用一行注释（45行代码）解释了下。

6. 总结

至此，我们认识了运行时生成的代理类结构。

其实JDK动态代理，简单的来说就是，JDK动态代理技术可以为一组接口生成代理类，这个代理类也就是一层壳，简单的实现了接口中定义的方法，通过提供一个构造函数传入InvocationHandler实例，然后将方法的具体实现交给它。