Spring Aop

定义

AOP 中的通知是基于连接点的一种业务逻辑增强，Spring AOP 可以基于 XML 方式和注解方式定义， 提供了五种通知类型。

@Before (前置通知)

连接点前执行，不能终止后续流程，除非抛异常。

@Aspect
@Component
public class TestAspect {
	
	@Pointcut("execution(* *.*..*.*(..))")
    public void pointcut() {
    }

    @Before("point()")
    public void doBefore() {
        //切面逻辑
    }
}

@AfterReturning (后置通知)

方法正常返回，会执行后置通知，有异常不执行。

@Aspect
@Component
public class TestAspect {

    @Pointcut("execution(* *.*..*.*(..))")
    public void pointcut() {
    }
    
    @AfterReturning("pointcut()")
    public void doAfterReturning() {
        // 切面逻辑
    }
}

@AfterReturning 注解的 returning 属性可以绑定目标方法返回值，用于在通知中获取目标方法执行完成后的返回结果。

• 当注解使用了 returning 属性时，切入点会增加返回值类型的限制，如果目标方法返回值类型结果参数绑定类型不一致时，通知不会被执行。
• 例如, 切中的方法返回值是String类型，returning 属性对应的参数绑定是Boolean类型，则该通知不会被执行

@Aspect
@Component
public class TestAspect {

    @Pointcut("execution(* *.*..*.*(..))")
    public void pointcut() {
    }

    @AfterReturning(pointcut = "pointcut()", returning = "retType")
    public void doAfterReturning(Object retType) {
        // 切面逻辑（通过参数绑定切入点方法的返回值）
    }
}

@Around (环绕通知)

环绕通知可以在方法执行的任何节点添加逻辑，可以捕获异常。它也可以实现其它几种通知的功能。使用中，如果都能实现功能的情况下，优先使用其他通知方式。环绕方法定义时可以添加切入点 JoinPoint 和 ProceedingJoinPoint。

@Aspect
@Component
public class TestAspect {

    @Pointcut("execution(* *.*..*.*(..))")
    public void pointcut() {
    }
    
    @Around("pointcut()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        // 方法执行前逻辑
        Object retVal = joinPoint.proceed();
        // 方法执行后逻辑
        return retVal;
    }
}

@After(最终通知)

连接点退出时执行，无论是正常退出还是异常退出都会执行

@Aspect
@Component
public class TestAspect {

    @Pointcut("execution(* *.*..*.*(..))")
    public void pointcut() {
    }
    
    @After("pointcut()")
    public void doAfter(){
        //切面逻辑
    }
}

@AfterThrowing (异常通知)

方法抛出异常时执行。

@Aspect
@Component
public class TestAspect {

    @Pointcut("execution(* *.*..*.*(..))")
    public void pointcut() {
    }
    
    @AfterThrowing("pointcut()")
    public void doAfterThrowing(){
        //切面逻辑
    }
}

@AfterThrowing注解的 throwing 属性用来绑定目标方法抛出的异常，用于在通知中获取目标方法抛出的异常实例。

• 当注解使用了 throwing 属性时，切入点会增加异常类型的限制，如果目标方法抛出异常与结果参数绑定异常类型不一致时，通知不会被执行。
• 例如, 切中的方法抛出RuntimeException异常，throwing属性对应的参数绑定是NullPointerException异常，则该通知不会被执行

@Aspect
@Component
public class TestAspect {

    @Pointcut("execution(* *.*..*.*(..))")
    public void pointcut() {
    }
    
    @AfterThrowing(value = "pointcut()", throwing = "e")
    public void doAfterThrowing(NullPointerException e){
        //切面逻辑
    }
}

参数

在定义通知的方法签名上可以指定参数来绑定目标方法的一些信息。

切入点

在定义通知方法时，一般使用 JoinPoint 作为参数，环绕通知使用 ProceedingJoinPoint。

JoinPoint

public interface JoinPoint {

  // 获取代理对象
    Object getThis();

    // 获取目标对象
    Object getTarget();

    // 获取连接点方法的参数
    Object[] getArgs();

    // 获取连接点方法的签名
    Signature getSignature();

}

ProceedingJoinPoint

public interface ProceedingJoinPoint extends JoinPoint {

    // 执行下一个切面的通知或者目标方法
    public Object proceed() throws Throwable;

    // 执行下一个切面的通知或者目标方法（带参数）
    public Object proceed(Object[] args) throws Throwable;

}

切面表达式

要想精确切中目标方法，需要对切面表达式有一定认知。 要使切点的匹配性能达到最佳，编写表达式时，应尽可能缩小匹配范围。

切点表达式分为三大类：

• 类型表达式：匹配某个特定切入点，如 execution
• 作用域表达式：匹配某组切入点，如 within
• 上下文表达式：基于上下文匹配某些切入点，如 this、target 和 @annotation

一个好的切点表达式应该包含类型表达式和作用域表达式。作用域表达式匹配的性能非常高，单独使用类型表达式或上下文表达式比较消耗性能,所以表达式中尽可能使用作用域类型。

Spring AOP 支持以下几种切点表达式类型。

• execution
  最通用的表达式类型， 匹配方法切入点。根据表达式描述匹配方法，可以匹配方法、类、包。

   表达式模式：
   execution(modifier? ret-type declaring-type?name-pattern(param-pattern) throws-pattern?)

   表达式解释：
   modifier：匹配修饰符，public, private 等，省略时匹配任意修饰符。
   ret-type：匹配返回类型，使用 * 匹配任意类型。
   declaring-type：匹配目标类，省略时匹配任意类型。
      .. 匹配包及其子包的所有类。
   name-pattern：匹配方法名称，使用 * 表示通配符。
      * 匹配任意方法。
      set* 匹配名称以 set 开头的方法。
   param-pattern：匹配参数类型和数量。
      () 匹配没有参数的方法。
      (..) 匹配有任意数量参数的方法。
     (*) 匹配有一个任意类型参数的方法。
      (*,String) 匹配有两个参数的方法，并且第一个为任意类型，第二个为 String 类型。
   throws-pattern：匹配抛出异常类型，省略时匹配任意类型。

例如：
 execution(public * *(..))      任意的公共方法
 execution(* set*(..))          以set开头的所有的方法
 execution(* com.test.*(..))    com.test这个类里的所有的方法
 execution(* com.test.*.*(..))     com.test包下的所有的类的所有的方法
 execution(* com.test..*.*(..))    com.test包及子包下所有的类的所有的方法
 execution(* com.test..*.*(String,?,Long))     com.test包及子包下所有的类的有三个参数，第一个参数为String类型，第二个参数为任意类型，第三个参数为Long类型的方法
 execution(@annotation(com.test.AopTest))      带有@AopTest注解的方法

• within
  匹配指定类型。匹配指定类的任意方法，不能匹配接口。

   表达式模式：
   within(declaring-type)

   表达式解释：
   declaring-type：匹配目标类
     within(com.test.service.*) 匹配service包的类。
     within(com.test.service..*) 匹配service包及其子包的类。
     within(com.test.service.TestServiceImpl) 匹配TestServiceImpl类。

• this
  匹配代理对象实例的类型，匹配在运行时对象的类型。

  基于 JDK 动态代理实现的 AOP，代理类和实现类并不是同一种类型, this 不能匹配接口的实现类。
  

   表达式模式：
   this(declaring-type)

   示例：
  this(com.test.service.*) 匹配代理对象类型为service包下的类。
  this(com.test.service..*) 匹配代理对象类型为service包及其子包下的类。
  this(com.test.service.TestServiceImpl) 匹配代理对象类型为TestServiceImpl的类。

• target
  匹配目标对象实例的类型，匹配 AOP 被代理对象的类型。

  表达式模式：
  target(declaring-type)

  示例：
  target(com.test.service.*) 匹配目标对象类型为service包下的类。
  target(com.test.service..*) 匹配目标对象类型为service包及其子包下的类。
  target(com.test.service.TestServiceImpl 匹配目标对象类型为TestServiceImpl的类。

• args
  匹配方法参数类型和数量，参数类型可以为指定类型及其子类。
  使用 execution 表达式匹配参数时，不能匹配参数类型为子类的方法。

  表达式模式：
  args(param-pattern)

  示例：
  args(java.io.Serializable) 匹配参数只有一个且为Serializable类型或实现Serializable接口的类。
  args(cn.Test, ..) 匹配参数个数至少有一个且第一个为Test类型或实现Test接口的类。

• bean
  通过 bean 的 id 或名称匹配，支持 * 通配符。

  表达式模式：
  bean(bean-name)

  示例：
  bean(*Service)匹配名称以Service结尾的bean
  bean(testServiceImpl) 匹配名称为testServiceImpl的bean, 例如 @Component("testServiceImpl")

• @within
  匹配指定类型是否含有注解。当定义类时使用了注解，该类的方法会被匹配，但在接口上使用注解不匹配。

  示例：
  @within(com.Test) 匹配使用了Test注解的类。

• @args
  匹配方法参数类型是否含有注解。当方法的参数类型上使用了注解，该方法会被匹配。

  示例：
  @args(com.Test) 匹配参数只有一个且参数类使用了Test注解。
  @args(com.Test,..) 匹配参数个数至少有一个且第一个参数类使用了Test注解。

切点表达式组合

可以使用 &&、|| 或 ! 来组合多个切点表达式，表示多个表达式“与”、“或”和“非”的逻辑关系。

// 匹配point()切点表达式并且参数第一个为Test类型的方法
@Before("point() && args(test,..)")
public void before(Test test) {

}

切面顺序

Spring AOP 中一个目标类可以被多个切面切入，多个切面也可以切入一个目标类。使用 @Order 注解来指定切面的优先级，控制切面的执行顺序。

• Order 值越小，优先级越高。
• 优先级高的切面，前置通知先执行
• 优先级低的切面，后置通知先执行

@Order(1)
@Aspect
@Component
public class TestAspect {
	
}