动态代理种类及原理，你知道多少？

前言

提到动态代理，很多人都会对 JDK 动态代理、CGLib，或者 Proxy 、InvocationHandler 等类感到熟悉，甚至有些人会直接提到 Spring AOP。的确动态代理的实现有时会给我们带来意想不到的优势，比如常见的业务解耦、无侵入式的代码扩展等。这篇文章就主要来探讨如下几种实现动态代理的常见方式及其原理：

• JDK 动态代理
• CGLib 动态代理
• javassist 动态代理
  -javassist 字节码
• ASM 字节码
• 静态代理

为了下文叙述的方便，先来回顾一下静态代理。

静态代理

生活中身边不乏做微商的朋友，其实就是我们常说的微商代理，目的就是在朋友圈之类的为厂家宣传产品，厂家委托微商为其引流或者销售商品。将这个场景进行抽象，我们可以把微商代理看成“代理类”，厂家看成“委托类”或者“被代理类”等。

什么是静态代理？

若代理类在程序运行前就已经存在，那么这种代理方式就是静态代理。因此在程序运行前，我们都会在程序中定义好代理类。同时，静态代理中的代理类和委托类都会实现同一接口或者派生自相同的父类。接下来，我们将会用一段代码进行演示，Factory 代表厂家，即委托类，BusinessAgent 代表微商，即代理类。

代理类和委托类都实现Operator 接口：

public interface Operator {
    // 宣传，商品销售
    void sale();
    // 引流，业务扩张
    void expand();
}

Factory 类定义如下：

public class Factory implements Operator {

    @Override
    public void sale() {
        System.out.println("sale .... ");
    }

    @Override
    public void expand() {
        System.out.println("expand .... ");
    }
}

BusinessAgent 类定义如下：

public class BusinessAgent implements Operator {

    private Factory factory;

    public BusinessAgent(Factory factory){
        this.factory = factory;
    }

    @Override
    public void sale() {
        factory.sale();
    }

    @Override
    public void expand() {
        factory.expand();
    }
}

从BusinessAgent 类的类结构定义可以看得出来，静态代理主要是通过聚合的方式，来让代理类持有一个委托类的引用，同时我们可以想象，如果我们需要为委托类中的方法做统一处理，比如记录运行时间，那么我们是不是得在代理类中每个方法都单独去处理一遍？

动态代理

在前文，我们对什么是代理，什么是静态代理有了简单回顾。而动态代理跟静态代理的区别在于，代理类是在程序运行时创建，而动态代理的优势在于可以很方便的对代理类的方法进行统一处理。比如记录委托类中每个方法的运行时间。接下来，我们将逐个讲解动态代理的实现方式及其原理。

JDK 动态原理

实例演示

JDK 动态代理的实现主要是借助 InvocationHandler 接口、Proxy 类实现的。在使用时，我们得定义一个位于代理类与委托类之间的中介类，就像传统的微商代理，其实并不是直接跟厂家接触，他们之间可能还会存在一层中介。而这个中介类，需要实现 InvocationHandler 接口：

public interface InvocationHandler { 
  Object invoke(Object proxy, Method method, Object[] args);
}

• proxy：表示程序运行期间生成的代理类对象，后面可以看见使用 Proxy.newProxyInstance()生成
• method：表示代理对象被调用的方法
• args：表示代理对象被调用的方法的参数

调用代理对象的每个方法实际最终都是调用 InvocationHandler 的 invoke 方法。后面我们将论证这个结论。

这里我们使用 AgencyHandler 表示中介类，中介类定义为：

public class AgencyHandler implements InvocationHandler {

    // 委托类对象
    private Object target;

    public AgencyHandler(){}

    public AgencyHandler(Object target){
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
        long startTime = System.currentTimeMillis();
        // 使用反射执行委托类对象具体方法
        Object result = method.invoke(target, args);
        System.out.println(method.getName() + " cost time is:" + (System.currentTimeMillis() - startTime));
        return result;
    }
}

通过 Proxy 的静态方法 newProxyInstance 生成代理对象：

public class Main {

    public static void main(String[] args) {
        AgencyHandler agencyHandler = new AgencyHandler(new Factory());
        // 创建代理对象
        Operator operator = (Operator) Proxy.newProxyInstance(Operator.class.getClassLoader(), 
                            new Class[]{Operator.class}, 
                            agencyHandler);
        operator.sale();
        operator.expand();
    }
}

public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)

• loader：表示类加载器，将运行期动态生成的代理类加载到内存
• interfaces：表示委托类的接口，生成代理类需要实现的接口
• h：InvocationHandler 实现类对象，负责连接代理类和委托类的中介类

正如预期运行结果为：

sale .... 
sale cost time is:1s
expand .... 
expand cost time is:0s

这里我们将委托类对象 new Factory() 作为 AgencyHandler 构造方法入参创建了agencyHandler 对象，然后通过 Proxy.newProxyInstance(…) 方法创建了一个代理对象，实际代理类就是这个时候动态生成的。我们调用该代理对象的方法就会调用到 agencyHandler 的 invoke 方法（类似于静态代理），而 invoke 方法实现中调用委托类对象 new Factory() 相应的 method（类似于静态代理）。因此，动态代理内部可以看成是由两组静态代理构成。

代理类源码分析

其实上面一段话已经对动态代理的原理讲得很清楚了，下面我们从源码的角度来梳理一下。既然 JDK 动态代理的代理对象是运行期生成的，那么它在运行期也会对应一段字节码，可以使用 ProxyGenerator.generateProxyClass 方法进行获取。

为了让大家一步到位，这里贴一下这个工具类：

public class ProxyUtils {
    public static boolean saveProxyClass(String path, String proxyClassName, Class[] interfaces) {
        if (proxyClassName == null || path == null) {
            return false;
        }
        byte[] classFile = ProxyGenerator.generateProxyClass(proxyClassName, interfaces);
        FileOutputStream out = null;
        try {
            out = new FileOutputStream(path);
            out.write(classFile);
            out.flush();
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return false;
    }
}

将得到的字节码文件进行反编译就能看到其中的源代码了：

import com.limynl.proxy.Operator;
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 Operator {
  // 这 5 个方法分别是 equals、expand、toString、sale、hashCode
  private static Method m1;
  private static Method m3;
  private static Method m2;
  private static Method m4;
  private static Method m0;

  static {
    try {
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m3 = Class.forName("com.limynl.proxy.Operator").getMethod("expand", new Class[0]);
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      m4 = Class.forName("com.limynl.proxy.Operator").getMethod("sale", new Class[0]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      return;
    } catch (NoSuchMethodException noSuchMethodException) {
      throw new NoSuchMethodError(noSuchMethodException.getMessage());
    } catch (ClassNotFoundException classNotFoundException) {
      throw new NoClassDefFoundError(classNotFoundException.getMessage());
    } 
  }
  // 构造方法接收一个 InvocationHandler 对象为参数
  public $Proxy0(InvocationHandler paramInvocationHandler) {
    // 传至父类中的 InvocationHandler 类型变量 h
    super(paramInvocationHandler);
  }

  public final boolean equals(Object paramObject) {
    try {
      // this.h.invoke 将会调用实现了 InvocationHandler 接口的类，上面我们传入的是 agencyHandler 对象，
      // 因此会调用 AgencyHandler 的 invoke 方法
      // 同时这里也印证了，invoke 的方法的第一个参数就是代理对象本身。下面其余方法类似
      return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
    } catch (Error|RuntimeException error) {
      throw null;
    } catch (Throwable throwable) {
      throw new UndeclaredThrowableException(throwable);
    } 
  }

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

  public final String toString() {
    try {
      return (String)this.h.invoke(this, m2, null);
    } catch (Error|RuntimeException error) {
      throw null;
    } catch (Throwable throwable) {
      throw new UndeclaredThrowableException(throwable);
    } 
  }

  public final void sale() {
    try {
      this.h.invoke(this, m4, null);
      return;
    } catch (Error|RuntimeException error) {
      throw null;
    } catch (Throwable throwable) {
      throw new UndeclaredThrowableException(throwable);
    } 
  }

  public final int hashCode() {
    try {
      return ((Integer)this.h.invoke(this, m0, null)).intValue();
    } catch (Error|RuntimeException error) {
      throw null;
    } catch (Throwable throwable) {
      throw new UndeclaredThrowableException(throwable);
    } 
  }
}

从中我们可以看出动态生成的代理类是以 $Proxy 为类名前缀，继承自 Proxy，并且实现了 Proxy.newProxyInstance(…) 第二个参数传入的所有接口。

代理类的构造方法传入的是 InvocationHandler 对象，即Proxy.newProxyInstance(…) 第三个参数，同时 sale()、expand() 都交给 h 去处理，最终会传递到 agencyHandler 对象的 invoke 方法里面，该方法里面继续使用反射的方式找到最终需要调用的委托类的方法。从而也论证了开头说的：调用代理对象的每个方法实际最终都是调用 InvocationHandler 的 invoke 方法。

所以 InvocationHandler 的子类 AgencyHandler 连接代理类和委托类的中介类。

到这里我们已经把 JDK 动态代理的原理讲完了，所以大家可以在脑海中回忆一下：JDK 动态代理内部可以看成是由两组静态代理构成，是不是这个意思？

通过这个代理类也将明白：

• 为什么在 Proxy.newProxyInstance 过程需要接口：因为生成的代理类需要实现这个接口
• 为什么 JDK 动态代理只能代理接口：因为 java 是单继承，代理类已经继承了 Proxy，因此没办法在继承另外一个类.

JDK 动态代理中除使用了反射外，也操作了字节码.