AOP随笔

AOP: Aspect-Oriented Programming 面向切面编程。

首先明确一个点：AOP是一个概念。那么对于一个概念，其实现方式多种多样，分为静态AOP、动态AOP，而对于动态AOP的实现又分为动态代理和动态字节码增强实现。

这里分享的AOP主要是基于Spring的AOP实现。

AOP的一些基础概念

• 连接点（Joinpoint）：程序执行的某个特定位置，比如方法调用前、方法调用后、方法抛出异常后等，这些点都可以是连接点。

• 切点（PointCut）：一个程序有若干个连接点，并不是所有的连接点都是需要关注的，需要我们关注的那部分连接点就是切点。

• 通知(增强)（Advice）：就是在切点处要插入的逻辑；分为前置、后置、异常、返回、环绕通知；

• 切面（Advice）：切点和通知组合在一起形成切面，对应的切面横切整个应用程序。切面实现了横切关注点的模块化。

• 目标对象（Target）：需要被增强的业务对象。

• 织入（Weaving）：将通知增强添加到目标对象的具体连接点的过程。具体来说，就是生成代理对象并将切面融入到业务流程的过程。

• 代理类（Proxy）：一个类在被织入器织入增强逻辑后产生的一个类就是代理类。

上面这些点在Spring中的体现就是一个一个的注解。

Spring AOP的使用方式

比如我们现在有一个除法计算类，这个方法计算可能会抛错，在抛错的时候我们需要记录一下日志，那么使用方式如下：

（说明：很多地方在介绍AOP的时候，都喜欢以日志来当做案例，但是日志记录并不是一个好的AOP使用场景，因为系统中各个日志记录点和记录格式不具有通用性。）

• 首先定义实现方法：

  public class MathCalculator {
  
      public int div(int i, int j) {
          return i / j;
      }
  }
  

• 然后定义切面：

  @Aspect
  public class LogAspects {
  
      @Pointcut("execution(public int MathCalculator.*(..))")
      public void poinCut() {
      }
  
      @Around("poinCut()")
      public Object logArround(ProceedingJoinPoint joinPoint) throws Throwable {
          System.out.println("环绕开始！");
          try {
              return joinPoint.proceed();
          } catch (Exception e) {
              System.out.println("环绕异常！");
              throw e;
          } finally {
              System.out.println("环绕结束！");
          }
      }
  }
  

我们在切面中定义了一个环绕通知，这样就对MathCalculator的div方法调用进行了环绕处理。

Spring AOP的实现方式

上面提到动态AOP有两种实现方式：动态代理和动态字节码增强。

在Spring中主要是通过动态代理实现的：基于JDK的动态代理和基于CGLIB的动态代理。

要了解Spring AOP的实现原理，只要把上面两个技术了解后就能明白相应的原理了。

JDK动态代理

• 1、JDK动态代理是基于接口的，所以我们首先来创建一个接口

  /**
   * 抽象主题接口
   **/
  public interface Subject {
  
      void doSomething();
  }
  

• 2、创建对应接口的实现类

  /**
   * 真实主题类
   **/
  public class RealSubject implements Subject {
      @Override
      public void doSomething() {
          System.out.println("doSomething....");
      }
  }
  

• 3、创建代理类，实现 java.lang.reflect.InvocationHandler 接口

  import java.lang.reflect.InvocationHandler;
  import java.lang.reflect.Method;
  import java.lang.reflect.Proxy;
  
  /**
   * jdkd动态代理类
   **/
  public class JDKDynamicProxy implements InvocationHandler {
  
      private Object target;
  
      public JDKDynamicProxy(Object target) {
          this.target = target;
      }
  
      /**
       * 获取被代理接口实例对象
       */
      public <T> T getProxy() {
          return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
      }
  
      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
          System.out.println("Do something before");
          Object result = method.invoke(target, args);
          System.out.println("Do something after");
          return result;
      }
  }
  

• 4、创建测试类

  import com.lnjecit.proxy.dynamic.jdk.JDKDynamicProxy;
  
  /**
   * 测试类
   **/
  public class Ceshi {
      public static void main(String[] args) {
          Subject subject = new JDKDynamicProxy(new RealSubject()).getProxy();
          subject.doSomething();
      }
  }
  

像这样运行Ceshi类的main方法就能发现对应的doSomething()方法被我们的逻辑进行了拦截。

• 5、动态代理原理

  我们打开生成的代理类，可以看到内容如下：

  import com.lnjecit.proxy.Subject;
  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 Subject {
      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 void doSomething() throws  {
          try {
              super.h.invoke(this, m3, (Object[])null);
          } catch (RuntimeException | Error var2) {
              throw var2;
          } catch (Throwable var3) {
              throw new UndeclaredThrowableException(var3);
          }
      }
      
      // 为了精简代码，下面省略了重写的 equals、hashCode、toString、toString 方法
  
      static {
          try {
              m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
              m3 = Class.forName("com.lnjecit.proxy.Subject").getMethod("doSomething");
              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、继承了Proxy类，实现了代理的接口，由于java不能多继承，这里已经继承了Proxy类了，不能再继承其他的类，所以JDK的动态代理不支持对实现类的代理，只支持接口的代理。

  2、提供了一个使用InvocationHandler作为参数的构造方法。

  3、生成静态代码块来初始化接口中方法的Method对象，以及Object类的equals、hashCode、toString方法。

  4、重写了Object类的equals、hashCode、toString，它们都只是简单的调用了InvocationHandler的invoke方法，即可以对其进行特殊的操作，也就是说JDK的动态代理还可以代理上述三个方法。

  5、代理类实现代理接口的sayHello方法中，只是简单的调用了InvocationHandler的invoke方法，我们可以在invoke方法中进行一些特殊操作，甚至不调用实现的方法，直接返回。

  上面的InvocationHandler就是我们实现横切逻辑的地方，它是横切逻辑的载体。

CGLIB动态代理

CGLIB使用如下：

• 1、定义代理目标类

  public class UserService {
      public String getUserName(Long userId) {
          System.out.println("获取用户名..");
          return "user" + userId;
      }
  }
  

• 2、实现MethodInterceptor，定义事务拦截器

  public class TransactionInterceptor implements MethodInterceptor {
      Object target;
  
      public TransactionInterceptor(Object target) {
          this.target = target;
      }
  
      /**
       * proxy：代理对象，CGLib动态生成的代理类实例
       * method：目标对象的方法，上文中实体类所调用的被代理的方法引用
       * args：目标对象方法的参数列表，参数值列表
       * methodProxy：代理对象的方法，生成的代理类对方法的代理引用
       */
      @Override
      public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
          System.out.println("开启事务..." + proxy.getClass().getSimpleName());
          Object objValue = null;
          try {
              // 反射调用目标类方法
              objValue = method.invoke(target, args);
              System.out.println("返回值为：" + objValue);
          } catch (Exception e) {
              System.out.println("调用异常!" + e.getMessage());
          } finally {
              System.out.println("调用结束，关闭事务...");
          }
          return objValue;
      }
  
      /**
       * 获取代理实例
       */
      public Object getTargetProxy() {
          // Enhancer类是cglib中的一个字节码增强器，它可以方便的为你所要处理的类进行扩展
          Enhancer eh = new Enhancer();
          // 1.将目标对象所在的类作为Enhancer类的父类
          eh.setSuperclass(target.getClass());
          // 2.通过实现MethodInterceptor实现方法回调
          eh.setCallback(this);
          // 3. 创建代理实例
          return eh.create();
      }
  }
  

• 3、使用

  public static void main(String[] args) {
      // 1. 创建目标实例
      UserService userService = new UserService();
      // 2. 创建事务拦截器
      TransactionInterceptor transactionInterceptor = new TransactionInterceptor(userService);
      // 3. 创建代理实例
      UserService userServiceProxy = (UserService) transactionInterceptor.getTargetProxy();
      // 4. 使用代理实例调用目标方法
      userServiceProxy.getUserName(6L);
  }
  

说明：CGLIB是基于继承来实现的。它首先创建一个类，继承代理目标类，然后重写其中的方法，然后在重写的方法中将调用委托给目标对象，然后在委托调用前后实现横切逻辑。

通过上面两个例子可以看出，JDK的动态代理不是通过继承实现的，那么就是通过实现接口实现的。而CGLIB则是通过动态生成代理类的子类来实现的。