如何实现一个简易版的 Spring - 如何实现 AOP（中）

前言

在上篇 如何实现 AOP（上） 介绍了 AOP 技术出现的缘由和一些重要的概念，在咱们本身实现以前有必要先了解一下 AOP 底层究竟是如何运做的，因此这篇再来看看 AOP 实现所依赖的一些核心基础技术。AOP 是使用动态代理和字节码生成技术来实现的，在运行期（注意：不是编译期！）为目标对象生成代理对象，而后将横切逻辑织入到生成的代理对象中，最后系统使用的是带有横切逻辑的代理对象，而不是被代理对象，由代理对象转发到被代理对象。html

代理模式

动态代理的根源是设计模式中的代理模式，代理模式在 GoF 中的描述以下：java

Provide a surrogate or placeholder for another object to control access to it.

从其定义能够看出，代理模式主要是为了控制对象的访问，一般也会拥有被代理者的全部功能。经过代理模式咱们能够在不改变被代理类的状况下，经过引入代理类来给被代理类添加一些功能，此时脑海里飘过计算机科学界中一句著名的话(P.S. 基础知识很重要啊，能够参见 这篇)：git

计算机科学的任何一个问题，均可以经过增长一个中间层来解决。

代理模式其实在现实生活中也常常会接触到，好比在一线城市租房时大部分都是找的租房中介去看的房子、谈价格以及签合同，是由于房子的房东已经把房子全权托管给了中介处理了，这里的租房中介其实就是充当了代理模式中的代理对象的解决，而真正的被代理对象(目标对象)实际上是房子的房东，而和咱们打交道都是租房中介(代理对象)。代理模式类图结构以下图所示：github

图中各个部分的含义以下：编程

• ISubject 是被代理对象所能提供能力的抽象。
• SubjectImpl 是被代理的具体实现类。
• SubjectProxy 是代理的实现类，一般该类持有 ISubject 接口的实例。
• Client 是访问者的抽象角色，要访问 ISubject 类型的资源。

能够看到 SubjectImpl 和 SubjectProxy 都实现了相同的接口 ISubject，在代理对象 SubjectProxy 内持有 ISubject 的引用，当 Client 访问 doOperation() 时，代理对象将请求转发给被代理对象，单单从这个过程来看，代理对象若是只是为了转发请求，是否是有点画蛇添足了？再结合代理模式的定义思考一下，在转发以前（后者以后）不就能够添加一些访问控制了吗。设计模式

在代理对象(SubjectProxy)将请求转发给被代理对象(SubejctImpl)以前或者以后都是根据须要添加一些处理逻辑，而不须要修改被代理对象的具体实现逻辑，假设 SubjectImpl 是咱们系统中 Joinpoint 所在的对象，此时 SubjectImpl 就是咱们的目标对象了，只须要为这个目标对象建立一个代理对象，而后将横切逻辑添加到代理对象中，对外暴露出建立出来的代理对象就能够将将横切逻辑和原来的逻辑融合在一块儿了。ide

动态代理

到目前为止，一切都是那么美好，当只为同一个目标对象类型添加横切逻辑时，只须要建立一个代理对象便可，可是在 Joinpoint 相同而目标对象类型不一样时，须要为每一个不一样的目标对象类型都单首创建一个代理对象，而这些代理对象的横切逻辑其实都是同样的，根据 DRY原则，须要寻找另外一种技术来解决这个问题。
在 JDK 1.3 引入的 动态代理机制 能够为指定的接口在运行期动态的去生成代理对象，使用这个动态代理机制能够解决上述问题，这样咱们就能够不事先为每一个原始类建立代理类，而是在运行时动态生成代理类。在 Java 中，使用动态代理是比较简单的，它自己就已经使用反射实现了动态代理的语法，主要是由一个类 Proxy 和一个接口 InvocationHandler 组成，使用动态代理机制实现前文示例以下：工具

/**
 * @author mghio
 * @since 2021-05-29
 */
public interface Subject {
  void doOperation();
}

public class SubjectImpl implements Subject {
  @Override
  public void doOperation() {
    System.out.println("SubjectImpl doOperation...");
  }
}

public class JDKInvocationHandler implements InvocationHandler {
  private final Subject target;
  public JDKInvocationHandler(Subject target) {
    this.target = target;
  }
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    // add pre process logic if necessary
    
    System.out.println("Proxy before JDKInvocationHandler doOperation...");
    Object result = method.invoke(target, args);
    System.out.println("Proxy after JDKInvocationHandler doOperation...");

    // add post process logic if necessary
    return result;
  }
}

public class Client {
  public static void main(String[] args) {
    // 将生成的代理类保存在根目录下（com/sun/proxy/XXX.class）
    System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
    Subject target = new SubjectImpl();
    Subject proxy = (Subject) Proxy.newProxyInstance(SubjectImpl.class.getClassLoader(),
        new Class[]{Subject.class}, new JDKInvocationHandler(target));
    proxy.doOperation();
  }
}

由以上代码可知，使用 JDK 的动态代理只要 3 步：post

1. 定义公共接口 Subject，建立被代理对象 SubjectImpl
2. 建立被代理对象的处理对象 JDKInvocationHandler，持有目标对象 Subject 的引用
3. 使用 JDK 的 Proxy 类的静态方法 newProxyInstance 建立代理对象

经过设置 sun.misc.ProxyGenerator.saveGeneratedFiles 属性，能够将动态生成的代理类保存在项目根目录下，运行上面的示例代码生成的代理类以下：this

public final class $Proxy0 extends Proxy implements Subject {
  private static Method m1;
  private static Method m2;
  private static Method m3;
  private static Method m0;

  static {
    try {
      m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
      m2 = Class.forName("java.lang.Object").getMethod("toString");
      m3 = Class.forName("cn.mghio.designpattern.proxy.dynamicproxy.Subject").getMethod("doOperation");
      m0 = Class.forName("java.lang.Object").getMethod("hashCode");
    } catch (NoSuchMethodException var2) {
      throw new NoSuchMethodError(var2.getMessage());
    } catch (ClassNotFoundException var3) {
      throw new NoClassDefFoundError(var3.getMessage());
    }
  }

  public $Proxy0(InvocationHandler var1) throws  {
    super(var1);
  }

  public final void doOperation() throws  {
    try {
      super.h.invoke(this, m3, (Object[])null);
    } catch (RuntimeException | Error var2) {
      throw var2;
    } catch (Throwable var3) {
      throw new UndeclaredThrowableException(var3);
    }
  }

  // omit toString、equals、hashCode method...

}

从动态生成的代理类的代码能够看出，JDK 动态代理生成的代理类是继承 JDK 中提供的 Proxy 和实现被代理类所实现的接口。进一步能够从这个实现方式得出两点：1. 使用 JDK 动态代理时为何只能使用接口引用指向代理，而不能使用被代理的具体类引用指向代理；2. 被代理类必须实现接口，由于 JDK 动态代理生成的代理类必须继承自 Proxy，而 Java 不支持多重继承，因此只能经过实现接口的方式。

在默认状况下，Spring AOP 发现了目标对象实现了接口，会使用 JDK 动态代理机制为其动态生成代理对象，虽然提倡面向接口编程，可是也有目标对象没有实现接口的场景，当被代理的目标对象没有实现接口时就没法使用 JDK 动态代理了，那么这种状况下就须要使用第三方工具来帮忙了。

字节码生成技术

当目标对象没有实现接口时，能够经过动态字节码生成来继承目标对象来动态生成相应的子类，在生成的子类中重写父类目标对象的行为，而后将横切逻辑放在子类，在系统中使用目标对象的子类，最终的效果是代理模式是同样的，CGLIB 动态字节码生成类库（它自己其实也是一个抽象层，更底层是 ASM）能够动态生成和修改一个类的字节码。当以上示例代码目标对象未实现接口是修改成 CGLIB 动态生成字节码方式实现以下：

/**
 * @author mghio
 * @since 2021-05-29
 */
public class RealSubject {
  public void doOperation() {
    System.out.println("RealSubject doOperation...");
  }
}

public class CglibMethodInterceptor implements MethodInterceptor {
  @Override
  public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy)
      throws Throwable {
    // add pre process logic if necessary

    System.out.println("Cglib before RealSubject doOperation...");
    Object result = methodProxy.invokeSuper(o, args);
    System.out.println("Cglib after RealSubject doOperation...");

    // add post process logic if necessary
    return result;
  }
}

public class Client {
  public static void main(String[] args) {
    // 将生成的动态代理类保存到文件中
    System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,
        "/Users/mghio/IdeaProjects/designpattern/cglib/proxy/");
    // 1. 建立 Enhancer 对象
    Enhancer enhancer = new Enhancer();
    // 2. 设置被代理类
    enhancer.setSuperclass(RealSubject.class);
    // 3. 设置回调对象(实现 MethodInterceptor 接口)
    enhancer.setCallback(new CglibMethodInterceptor());
    // 4. 建立代理对象
    RealSubject proxy = (RealSubject) enhancer.create();
    proxy.doOperation();
  }
}

使用 CGLIB 生成代理对象须要 4 步：

1. 建立 Enhancer 对象，动态生成字节码的绝大部分逻辑都是在这个类中完成的。
2. 设置被代理类(目标对象)，生成的代理类会继承自这个接口，也就意味着这个类不能是 final 类型的。
3. 设置回调对象(实现 MethodInterceptor 接口)，在这里根据须要添加横切逻辑。
4. 调用 Enhaner 的 create() 方法建立代理对象。

在设置 DebuggingClassWriter.DEBUG_LOCATION_PROPERTY 属性后，反编译已保存的动态生成代理类以下：

从反编译后的代码能够看出 CGLIB 生成的代理类是经过继承被代理类 RealSubject 实现 Factory 接口实现的，要能被继承也就要求被代理类不能是 final 类型的。看到这里你可能会问：既然 JDK 动态代理要求被代理类实现接口，而 CGLIB 动态字节码生成要求不能是 final 类，那对于那些没有实现接口同时仍是 final 类，要怎么动态代理呢？好问题，这个就留给你本身去思考了。

总结

本文简要介绍了 Spring AOP 实现所依赖的核心基础技术，从动态代理的根源代理模式到动态代理和动态字节码生成技术，为下篇动手实现简易版的 AOP 打下基础，在了解了所依赖的基础技术后，在具体实现时就会更加丝滑，动态代理和动态字节码生成对好比下：