Spring中的AOP

Spring中的AOP

一.Spring AOP的概念

1.AOP的概述

       AOP的全称是Aspect Oriented Programming，即面向切面编程。是通过预编译方式和运行期间动态代理，实现程序功能的统一维护的一种技术。AOP是OOP面向对象编程的一种延续。

       使用OOP编程时，虽然我们可以通过继承关系实现大量代码重用，但是一些不具有继承关系的对象，也可能具有一些公共行为，比如日志记录等等。

       面对这种没有继承关系而重复的代码，OOP的编程方式就不适合把它们重用和管理起来。

       而AOP的出现，就为处理这类问题提供了一套完整的理论和灵活多样的解决方案。AOP可以将这些重复的代码抽取出来单独维护，而在需要使用时再统一调用。

      OOP由于继承关系是纵向的，而AOP所关注的方向是横向的。AOP是对OOP一种很好的补充。

2.JoinPoint连接点

       AOP的功能模块都是需要横向织入到各个纵向继承体系的OOP的模块中。要进行这种织入操作，我们就需要知道要在OOP模块的哪些执行点上进行织入操作。

       这些将要在其之上进行织入操作的系统执行点就是JoinPoint连接点。这些连接点就是AOP的切入点。

       在Spring中只支持方法类型的连接点。

2.1类图:

3.Advice通知

       Advice通知是定义在JoinPoint连接点上的横切逻辑。在Spring AOP中，Advice是一个定义的接口。在这个接口的基础上，Spring提供了更具体的通知类型，如BeforeAdvice、AfterAdvice、ThrowsAdvice等。具体切面的增强，就是通过这些接口集成到AOP框架中去发挥作用的。

3.1 类图

3.2 BeforeAdvice

       BeforeAdvice所实现的横切逻辑将在相应的Joinpoint之前执行，在BeforeAdvice执行完成之后，程序执行流程将从Joinpoint处继续执行，所以BeforeAdvice通常不会打断程序的执行流程。但是如果必要，也可以通过抛出相应异常的形式中断程序流程。

在Spring中，我们通过实现MethodBeforeAdvice接口，来实现BeforeAdvice的功能。

public interface MethodBeforeAdvice extends BeforeAdvice {
   void before(Method method, Object[] args, @Nullable Object target) throws Throwable;
}

       MethodBeforeAdvice接口中，定义了一个before的回调函数。Before回调函数中需要三个参数。

• 目标方法反射的Method对象。
• 目标方法的输入Object[]对象参数数组。
• Object类型的目标对象

3.3 AfterAdvice

       顾名思义，AfterAdvice所实现的横切逻辑将在相应的Joinpoint方法之后执行，但是方法是在正常返回的情况下。

       在Spring中的定义了AfterReturningAdvice接口，接口中定义了afterReturning方法。通过该方法我们可以访问当前Joinpoint的方法返回值、方法、方法参数以及所在的目标对象。

public interface AfterReturningAdvice extends AfterAdvice {

   void afterReturning(@Nullable Object returnValue, Method method, Object[] args, @Nullable Object target) throws Throwable;

}

3.4 ThrowsAdvice

       ThrowsAdvice所实现的横切逻辑将在相应的Joinpoint方法抛出异常后执行。通过ThrowsAdvice我们可以对系统中异常情况进行监控,以统一的方式对所发生的异常进行处理。

       在Spring中的定义了ThrowsAdvice接口，该接口继承自AfterAdvice接口。ThrowsAdvice接口虽然没有定义任何方法，它在抛出异常时被回调，这个回调是AOP使用反射机制来完成的。

       我们在实现相应的ThrowsAdvice的时候，需要遵循如下规则（以CountingThrowsAdvice为例）

public static class CountingThrowsAdvice extends MethodCounter implements ThrowsAdvice {

   public void afterThrowing(IOException ex) throws Throwable {

      count(IOException.class.getName());

   }

   public void afterThrowing(UncheckedException ex) throws Throwable {

      count(UncheckedException.class.getName());

   }

}

@SuppressWarnings("serial")
static class UncheckedException extends RuntimeException {

}

4.Pointcut切点

       Pointcut(切点)是决定Advice通知应该作用于哪些连接点(JoinPoint)。我们可以通过Pointcut来定义一些需要增强的方法的集合，这些集合的选取可以按照一定的规则来完成。

       这些规则可以是根据某个方法名进行匹配，或者由某个正则表达式进行标识等。

4.1类图

4.2 Pointcut常用类

• Pointcut接口

public interface Pointcut {
   /**

    * Return the ClassFilter for this pointcut.

    * @return the ClassFilter (never {@code null})

    */

   ClassFilter getClassFilter();

   /**

    * Return the MethodMatcher for this pointcut.

    * @return the MethodMatcher (never {@code null})

    */

   MethodMatcher getMethodMatcher();

   /**

    * Canonical Pointcut instance that always matches.

    */

   Pointcut TRUE = TruePointcut.INSTANCE;
}

       Pointcut接口中定义了两个方法getClassFilter(),getMethodMatcher(),分别返回ClassFilter和MethodMatcher类型的实例。

• ClassFilter 是用于类型级别匹配被执行织入操作。
• MethodMatcher是用于方法级别匹配被执行织入操作。

       Pointcut接口还提供了一个TruePointcut的实例，来匹配所有的Joinpoint实例。

• NameMatchMethodPointcut

       NameMatchMethodPointcut继承自StaticMethodMatcherPointcut类，可以根据自身指定的一组方法名称与Joinpoint处的方法的方法名称进行匹配。

• JdkRegexpMethodPointcut

       JdkRegexpMethodPointcut也是StaticMethodMatcherPointcut类的子类，通过正则表达式与Joinpoint处的方法的方法名称进行匹配。

• AnnotationMatchingPointcut

       AnnotationMatchingPointcut直接实现了Pointcut接口，通过注解与Joinpoint处的方法的方法名称进行匹配。

• ComposablePointcut

       ComposablePointcut是Spring AOP提供的可以进行Pointcut逻辑运算的Pointcut实现。它可以进行Pointcut之间的“并”以及“交”运算。

5.Advisor通知器

       完成对目标方法的切面增强设计（Advice)和切点的设计（Pointcut)以后，需要一个对象把它们结合起来，完成这个作用的就是Advisor(通知器)。Advisor是定义在哪个切点使用使用哪个通知，也就是说通过Advisor，把Advice和Pointcut结合起来，这个结合为使用IoC容器配置AOP应用，或者说即开即用地使用AOP基础设施，提供了便利。

5.1类图

二.Spring AOP的实现机制

       在Spring AOP的实现中，使用的核心技术是动态代理和字节码生成技术。动态代理机制和字节码生成技术都是在运行期间为目标对象生成一个代理对象，再将横切逻辑织入到这个代理对象中，系统最终使用的是织入了横切逻辑的代理对象。

1.代理模式

1.1概念

       代理模式给一个对象提供一个替身或占位符，来控制对原对象的访问。代理模式是一种对象结构型模式。

1.2类图

       Subject（抽象主题类）：抽象主题类是真实主题类和代理类的共同接口。通过实现同一接口，代理类可以在真实主题类出现任何地方取代它。

       RealSubject（真实主题类）：真实主题类是真正做事的对象，它实现了具体的业务逻辑操作。它是一个被代理类控制和访问的对象。

       Proxy（代理类）：代理类包含了对真实主题类的引用。由于它和真实主题类实现了相同的接口，所以在任何用到真实主题类的地方，都可以被代理类取代。代理类可以控制真实主题类的访问。客户端可以通过访问代理类，来间接调用真实主题类的操作。

1.3代码示例

public interface ISubject {
   public void request();
}

public class RealSubject implements ISubject{
   @Override
   public void request() {
       System.out.println("do some request.");
   }
}

public class SubjectProxy implements ISubject{
   private ISubject iSubject;
   
   public SubjectProxy(ISubject iSubject){
      this.iSubject = iSubject;
   }

   @Override
   public void request() {
      //在调用真实主题类方法前，加入前置逻辑，对原方法进行增强。
      preProcess();
      this.iSubject.request();
      //在调用真实主题类方法后，加入后置逻辑，对原方法进行增强。
      postProcess();
   }

   private void preProcess() {
      System.out.println("do some pre-process business logic.");
   }   

   private void postProcess() {
      System.out.println("do some post-process business logic.");
   }   

   public ISubject getiSubject() {
      return iSubject;
   }

   public void setiSubject(ISubject iSubject) {
      this.iSubject = iSubject;
   }

}

public class App {
  public static void main(String[] args) {
     ISubject iSubject = new RealSubject();
     SubjectProxy subjectProxy = new SubjectProxy(iSubject);
     subjectProxy.request();
  }
}

       在代码示例中，我们定义了一个抽象主题接口ISubject，接口中就定义了一个request()方法。真实主题类RealSubject和代理主题类SubjectProxy都实现了ISubject接口，RealSubject和SubjectProxy都对ISubject接口中定义的request()给出了实现。

       代理主题类SubjectProxy定义了一个对ISubject类型实例的引用，这个引用ISubject类型实例一般都是真实主题类RealSubject的实例。

       当我们调用代理主题类SubjectProxy的request()方法时，其实真正调用的是所引用的真实主题类RealSubject的request()方法。不过在调用RealSubject的request()方法前后，我们可以分别添加前置和后置的处理逻辑，这样就达到了对原方法增强的目的。

       RealSubject是系统中的Joinpoint所在的目标对象，那么我们就可以为这个目标对象创建一个代理对象SubjectProxy，然后将横切逻辑（preProcess()和postProcess方法）添加到这个代理对象中。当系统使用这个代理对象运行的时候，那么原有逻辑的实现和横切逻辑就完全融合到这个代理对象中。

       Spring AOP本质上就是采用这种代理机制的原理实现的。只不过这种静态代理的模式，对于相同的横切逻辑，需要为每一个不同的目标对象，都创建一个代理对象。

       如果系统中存在成百上千的符合Pointcut匹配条件的目标对象时，那我们为这成百上千的目标对象创建成百上千的代理对象，明显不合实际情况。但是动态代理就可以很好解决这个问题。

2.动态代理

2.1概念

       Java标准库中提供了一种动态代理（Dynamic Proxy）的机制。使用该机制，我们可以为指定的接口，在系统运行期间动态的生成代理对象。代理对象将请求转发给了实际的目标对象，并在转发过程中可以增加额外的操作。这样我们就可以在不修改源代码的情况下，对原有的类功能进行了增强。所以动态代理比静态代理更加灵活和易于扩展。

2.2动态代理的实现

       在Java中动态代理主要通过Proxy类和InvocationHandler接口来实现的。

• java.lang.reflect.Proxy类：Proxy类中定义了newProxyInstance()方法，专门用于创建代理对象。newProxyInstance()方法需要三个参数。
  1. ClassLoader：类加载器。
  2. Class[]： 需要实现的接口数组，至少需要传入一个接口进去。
  3. InvocationHandler：InvocationHandler接口的实例。
• InvocationHandler接口：InvocationHandler接口定义了一个invoke方法。代理对象在执行方法时都会调用invoke方法。invoke方法就是我们实现横切逻辑的地方，相当于AOP中的Advice通知。

       InvocationHandler接口的实例，是作为参数传给了Proxy类的newProxyInstance()方法。

2.3代码示例

public interface ISubject {
   public void request();
}

public class RealSubject implements ISubject{

   @Override
   public void request() {
      System.out.println("this is do request");
   }
}

public class RequestHandler implements InvocationHandler {

   private ISubject target;

   public RequestHandler(ISubject target) {
      this.target = target;
   }  
   
   @Override
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      if(method.getName().equals("request")) {
         System.out.println("dynamic proxy do some thing");
      }
      return method.invoke(target, args);
   }
}

public class Demo {
   
  public static void main(String[] args) {
      ISubject target = new RealSubject();     
      ISubject subject = (ISubject)Proxy.newProxyInstance(target.getClass().getClassLoader(), 
            new Class[] {ISubject.class},
            new RequestHandler(target));
    
      subject.request();
   }
}

       在以上动态代理代码示例中，我们同静态代理一样定义了一个抽象主题接口ISubject和其实现类SubjectProxy。

       和静态代理所不同的是，我们定义了一个RequestHandler类实现了InvocationHandler接口。在RequestHandler类中，我们现实了invoke()方法。在invoke()方法方法中，我们可以加入横切逻辑。
       最后再使用Proxy类来动态生成代理对象。当程序调用代理对象的方法时，对应的InvocationHandler实例就会在invoke()方法中拦截相应的方法调用。在invoke()方法中并进行横切处理。

       如果还有其它目标对象和SubjectProxy类织入的横切逻辑是相同的,那我们使用Proxy类和同一个RequestHandler类为它生成相应的动态代理实例即可。不需要像静态代理那样，需要为每一个不同的目标类都都定义一个不同的代理类。

       动态代理为我们减少了很多重复的代码，但是动态代理机制只能对实现了相应接口的类来使用。

       如果一个类没有实现任何接口，我们就需要使用动态字节码技术，来为目标对象生成动态的代理对象实例。

3.动态字节码技术

3.1概述

      Spring AOP中使用的动态字节码生成技术是CGLIB。CGLIB的全称是：Code Generation Library。CGLIB是一个强大的、高性能、高质量的代码生成类库，它可以为没有实现接口的类提供代理，是JDK动态代理技术的一种良好补充。

      CGLIB的原理是对目标类进行继承扩展，为其动态的生成相应的代理子类。在子类中通过覆写父类的方法来扩展父类的行为(父类的final方法除外)，子类会采用方法拦截的技术拦截父类方法的调用，在拦截父类方法的过程中，可以顺势织入增强的横切逻辑。

3.2代码示例

      我们定义一个目标类SubjectImpl，在这个类中声明了一个request方法，这个方法非常简单，就是打印出” this is do request”这段内容。

public class SubjectImpl {

   public void request() {
      System.out.println("this is do request");
   }

}

      我们再定义一个RequestHandler类，该类实现了MethodInterceptor接口。RequestHandler类覆写了MethodInterceptor接口的intercept方法。

      这个intercept方法其实是CGLIB的回调函数。目标对象的任何方法执行时，都会被拦截，代码会被执行到intercept方法中。在intercept方法中，我们可以增加自定义的横切逻辑。

      在本例的intercept方法中，会判断果目标对象执行的方法名是否是request时，如果是，就会增加一些自定义逻辑。intercept方法最后是再执行目标对象的方法。

public class RequestHandler implements MethodInterceptor{

   @Override
   public Object intercept(Object object, Method method, Object[] args, MethodProxy proxy) throws Throwable {
      if(method.getName().equals("request")) {
         System.out.println("cglib do some thing");
      }
      return proxy.invokeSuper(object, args);
   }
}

示例Demo：

public class Demo {

   public static void main(String[] args) {
      //创建Enhancer对象
      Enhancer enhancer = new Enhancer();
      //Enhancer对象设置目标类的类型
      enhancer.setSuperclass(SubjectImpl.class);
      //Enhancer对象设置回调函数的类
      enhancer.setCallback(new RequestHandler());
      //创建代理对象
      SubjectImpl proxy = (SubjectImpl)enhancer.create();
      //代理对象执行目标对象的方法
      proxy.request();
   }
}

运行结果：

三.Spring AOP的设计与实现

1.概述

      在Spring AOP中，使用的核心技术是动态代理。动态代理会在系统运行期间为目标对象动态的生成代理对象。这个代理对象的建立可以通过JDK的Proxy类来完成，也可以通过CGLIB来完成。

      Spring AOP会在代理对象的拦截器中，织入各种横切逻辑。Spring AOP给出了一系列Advice横切实现，比如BeforeAdvice（前置通知）、AfterAdvice（后置通知）、ThrowsAdvice（异常通知等）异常通知等。Spring AOP还提供了一系列的Pointcut来匹配切入点。Spring AOP中还设计了一系列Adapter，各个Adapter会匹配Advice和其特定的拦截器，实现各种Advice织入。

2.AopProxy代理对象的创建

      Spring中分别使用了JDK动态代理和CGLIB两种技术来生成代理对象。对于这两种代理对象生成的模式，Spring中使用了工厂模式。

      类图：

• AopProxy接口：AopProxy接口中定义两个获取代理对象的方法。AopProxy接口相当于工厂模式中的抽象产品类。

public interface AopProxy {
   Object getProxy();
   Object getProxy(@Nullable ClassLoader classLoader);
}

• JdkDynamicAopProxy类：JdkDynamicAopProxy类实现了AopProxy接口。JdkDynamicAopProxy类在覆写父类中的getProxy方法时，使用JDK动态代理的方式来生成一个代理对象。

@Override
public Object getProxy(@Nullable ClassLoader classLoader) {

   if (logger.isTraceEnabled()) {
      logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
   }

   Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
   findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
   return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}

      JdkDynamicAopProxy类还实现了InvocationHandler接口，覆写了该接口的invoke方法。代理对象在执行方法时都会调用InvocationHandler实例的invoke方法。在这个invoke方法中可以对目标对象的方法进行拦截，在拦截中我们可以织入横切逻辑。

      在这个工厂模式中，JdkDynamicAopProxy相当于Jdk动态代理类型的一个具体的产品类。

• CglibAopProxy类：CglibAopProxy类也实现了AopProxy接口。在CglibAopProxy类中的getProxy方法中，则使用了动态字节码生成技术CGLIB，来生产一个代理对象。

@Override
public Object getProxy(@Nullable ClassLoader classLoader) {
   if (logger.isTraceEnabled()) {
      logger.trace("Creating CGLIB proxy: " + this.advised.getTargetSource());
   }

   try {
      Class rootClass = this.advised.getTargetClass();
      Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");
      Class proxySuperClass = rootClass;
      if (rootClass.getName().contains(ClassUtils.CGLIB_CLASS_SEPARATOR)) {
         proxySuperClass = rootClass.getSuperclass();
         Class[] additionalInterfaces = rootClass.getInterfaces();
         for (Class additionalInterface : additionalInterfaces) {
            this.advised.addInterface(additionalInterface);
         }
      }

      // Validate the class, writing log messages as necessary.
      validateClassIfNecessary(proxySuperClass, classLoader);
      // Configure CGLIB Enhancer...
      Enhancer enhancer = createEnhancer();
      if (classLoader != null) {
         enhancer.setClassLoader(classLoader);
         if (classLoader instanceof SmartClassLoader &&
               ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
            enhancer.setUseCache(false);
         }
      }

      enhancer.setSuperclass(proxySuperClass);
      enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
      enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
      enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(classLoader));

      Callback[] callbacks = getCallbacks(rootClass);
      Class[] types = new Class[callbacks.length];
      for (int x = 0; x < types.length; x++) {
         types[x] = callbacks[x].getClass();
      }

      // fixedInterceptorMap only populated at this point, after getCallbacks call above
      enhancer.setCallbackFilter(new ProxyCallbackFilter(
            this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
      enhancer.setCallbackTypes(types);

      // Generate the proxy class and create a proxy instance.
      return createProxyClassAndInstance(enhancer, callbacks);
   }
   catch (CodeGenerationException | IllegalArgumentException ex) {
      throw new AopConfigException("Could not generate CGLIB subclass of " + this.advised.getTargetClass() +
            ": Common causes of this problem include using a final class or a non-visible class",
            ex);
   }
   catch (Throwable ex) {
      // TargetSource.getTarget() failed
      throw new AopConfigException("Unexpected AOP exception", ex);
   }
}

      由此可见，CglibAopProxy类也是AopProxy抽象产品类的另一种形式的具体产品类。                     

• AopProxyFactory接口：光有定义了产品定义还是不行的，我们还得有工厂来对定义的产品进行生产。

      Spring中定义了AopProxyFactory接口，来规范AopProxy类型的实例的创建。AopProxyFactory接口就是一个抽象的工厂类。

public interface AopProxyFactory {
   AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException;
}

• DefaultAopProxyFactory类：DefaultAopProxyFactory类是对AopProxyFactory接口的一个默认实现。DefaultAopProxyFactory是一个具体工厂类。

      在DefaultAopProxyFactory类的createAopProxy方法中，会进行一些逻辑判断，来决定是实例化一个JdkDynamicAopProxy对象，还是实例化一个CglibAopProxy对象。

      Spring是使用JDK动态代理还是CGLIB来创建代理对象，受下面的一些条件是影响：

• optimize：是否使用激进的优化策略, 来控制通过CGLIB创建代理对象。
• proxyTargetClass：这个属性值为true时，表示目标类本身被代理而不是目标类的接口。
• hasNoUserSuppliedProxyInterfaces：是否存在代理接口。

@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
   if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
      Class targetClass = config.getTargetClass();
      if (targetClass == null) {
         throw new AopConfigException("TargetSource cannot determine target class: " +
               "Either an interface or a target is required for proxy creation.");
      }

      if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
         return new JdkDynamicAopProxy(config);
      }
      return new ObjenesisCglibAopProxy(config);
   }
   else {
      return new JdkDynamicAopProxy(config);
   }
}

3.Spring AOP拦截器的实现

      在Spring AOP中可以通过JDK的Proxy方式或者CGLIB方式来生成代理对象。在代理对象生成时，我们可以通过bean配置文件或者手动写代码来为生成的代理对象增加一系列的拦截器。当我们调用目标对象的方法时，都会触发代理对象的回调方法，在回调方法中就会执行一系列的拦截器的方法。通过这些拦截器，我们就可以把一些逻辑横向织入到代码，已达到实现AOP的目的。

• JDK的动态代理

      JDK的动态代理中，InvocationHandler接口定义了invoke方法，这个invoke方法是作为JDK Proxy动态代理对象进行拦截的回调入口。

      在Spring AOP的JDK动态代理实现方式中，是JdkDynamicAopProxy类中实现了InvocationHandler接口。也就是说当Proxy对象的代理方法被调用时，JdkDynamicAopProxy类中的invoke方法作为回调函数被触发，从而通过invoke的具体实现，来完成对目标对象方法调用的拦截或者说是功能增强的工作

      JdkDynamicAopProxy类中的invoke方法源码

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

   Object oldProxy = null;
   boolean setProxyContext = false;
   TargetSource targetSource = this.advised.targetSource;
   Object target = null;

   try {
      if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
         // The target does not implement the equals(Object) method itself.
         return equals(args[0]);
      }
      else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
         // The target does not implement the hashCode() method itself.
         return hashCode();
      }
      else if (method.getDeclaringClass() == DecoratingProxy.class) {
         // There is only getDecoratedClass() declared -> dispatch to proxy config.
         return AopProxyUtils.ultimateTargetClass(this.advised);
      }
      else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
            method.getDeclaringClass().isAssignableFrom(Advised.class)) {
         // Service invocations on ProxyConfig with the proxy config...
         return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
      }

      Object retVal;
      if (this.advised.exposeProxy) {
         // Make invocation available if necessary.
         oldProxy = AopContext.setCurrentProxy(proxy);
         setProxyContext = true;
      }

      // Get as late as possible to minimize the time we "own" the target,
      // in case it comes from a pool.
      //获得目标对象
      target = targetSource.getTarget();
      Class targetClass = (target != null ? target.getClass() : null);
      // Get the interception chain for this method.
      //获得定义好的拦截器链
      List