SpringAOP：对于同一个切入点，不同切面不同通知的执行顺序

1. 问题描述
2. 结论
- 结论1："对于同一个切入点，同一个切面不同类型的通知的执行顺序"
- 结论2："对于同一个切入点，不同切面不同类型通知的执行顺序"
3. 测试
- 环境：SpringBoot 2.3.4.RELEASE
- 测试集合1：针对结论1，单个切面类的情况。
- - 测试1：切入点正常执行完，无异常。
  - 测试2：切入点抛出异常
  - 测试3：@AfterReturning执行了注解属性returning，表示需要返回值
- 测试集合2：针对结论2，多个切面类的情况
4. 参考
5. 结语：如果对大家有帮助，请点赞支持。如果有问题随时在评论中指出，感谢。

1. 问题描述

在Spring AOP中，对于同一个切入点，可能会有多个切面多种不同类型的通知共同作用于它，那么这些来自不同切面的不同类型通知，它们的执行顺序是怎样的？本文将答案分成2部分讲述。

对于同一个切入点，同一个切面不同类型的通知的执行顺序。
对于同一个切入点，不同切面不同类型通知的执行顺序。

文章后续安排：section 2直接给出结论，图文结合，更好理解。section 3讲述测试过程。section 4讲述参考来源。大家可以根据自己需要查看相应部分，想看结论可以直接看section2。

2. 结论

结论1：“对于同一个切入点，同一个切面不同类型的通知的执行顺序”

图片描述
文字描述

@Around(before)
@Before
#切入点方法#
@AfterReturing/@AfterThrowing
(1. 假如有异常，执行@AfterThrowing。2. 假如没异常，
2.1 假如@AfterReturning中没有设置returning属性，@AfterReturning修饰的方法会被执行。
2.2 假如@AfterReturning中设置了returning属性，当切入点方法拥有返回值时，@AfterReturning修饰的方法会被执行，否则不执行)
@After (不管有没有异常，都执行)
@Around(after)
(1. 切入点方法抛出异常而且没有捕获，不执行。2. 切入点方法没有异常，或者异常被捕获，执行。)

结论2：“对于同一个切入点，不同切面不同类型通知的执行顺序”

图片描述
文字描述

切入点方法之前，优先级越高的切面的通知，越先被执行。
切入点方法之后，优先级越高的切面的通知，越后被执行。
切面优先级可以通过在切面类上的"定义注解@Order"或者”实现Ordered接口中的getOrder()决定”，值越小，优先级越高。

3. 测试

环境：SpringBoot 2.3.4.RELEASE

测试集合1：针对结论1，单个切面类的情况。

测试1：切入点正常执行完，无异常。

切面类：各种通知都有

@Component
@Aspect
public class CommonAspect1 {
    @Pointcut("execution(* cn.edu.szu.flow.control.service.UserService.*(..))")
    private void pointCut() {}

    @Around("pointCut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("Around(before)");
        Object val = joinPoint.proceed();
        System.out.println("Around(after)");
        return val;
    }

    @Before("pointCut()")
    public void before() {
        System.out.println("Before");
    }

    @AfterReturning(value = "pointCut()")
    public void afterReturning() {
        System.out.println("AfterReturning");
    }

    @AfterThrowing("pointCut()")
    public void afterThrowing() {
        System.out.println("AfterThrowing");
    }

    @After("pointCut()")
    public void after() {
        System.out.println("After");
    }
}

切入点方法

@Service
public class UserService {
    public void addUser() {
        System.out.println("切入点方法执行......");
    }

调用切入点方法

@SpringBootApplication
public class FlowControlApplication {
    public static void main(String[] args) {
        SpringApplication.run(FlowControlApplication.class, args);
    }
    @Autowired
    private UserService userService;
    @PostConstruct
    public void postConstruct() {
        // --------------调用切入点方法--------------
        userService.addUser();
    }
}

结果：符合结论1

测试2：切入点抛出异常

切面类：和测试1相同
切入点方法：在测试1基础上修改，让它抛出异常。

@Service
public class UserService {
    public void addUser() {
        System.out.println("切入点方法执行......");
        System.out.println("切入点方法抛出异常......");
        int i = 1/0;
    }

调用切入点方法：和测试1相同
结果：符合结论1。AfterThrowing执行，AfterReturning不执行，Around没有捕获异常，因此后面的不执行。

测试3：@AfterReturning执行了注解属性returning，表示需要返回值

切面类：在测试1基础上，只修改@AfterReturning

@AfterReturning(value = "pointCut()", returning = "result")
public void afterReturning(String result) {
    System.out.println("AfterReturning");
}

切入点方法：不抛出异常

@Service
public class UserService {
    public void addUser() {
        System.out.println("切入点方法执行......");
    }

调用切入点方法：和测试1相同
结果：符合结论1。@AfterReturning不执行，因为切入点方法是void，而@AfterReturning指明了需要返回值。

测试集合2：针对结论2，多个切面类的情况

切面1：包含不同类型的通知，并使用@Order指明优先级。值越小，优先级越高。

@Order(0)
@Component
@Aspect
public class CommonAspect1 {
    @Pointcut("execution(* cn.edu.szu.flow.control.service.UserService.*(..))")
    private void pointCut() {}
    @Around("pointCut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("Around(before).One");
        Object val = joinPoint.proceed();
        System.out.println("Around(after).One");
        return val;
    }
    @Before("pointCut()")
    public void before() {
        System.out.println("Before.One");
    }
    @AfterReturning(value = "pointCut()")
    public void afterReturning() {
        System.out.println("AfterReturning.One");
    }
    @AfterThrowing("pointCut()")
    public void afterThrowing() {
        System.out.println("AfterThrowing.One");
    }
    @After("pointCut()")
    public void after() {
        System.out.println("After.One");
    }
}

切面2：和切面1类似，包含不同类型的通知，并使用@Order指明优先级。值越小，优先级越高。

@Order(1)
@Component
@Aspect
public class CommonAspect2 {
    @Pointcut("execution(* cn.edu.szu.flow.control.service.UserService.*(..))")
    private void pointCut() {}
    @Around("pointCut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("Around(before).Two");
        Object val = joinPoint.proceed();
        System.out.println("Around(after).Two");
        return val;
    }
    @Before("pointCut()")
    public void before() {
        System.out.println("Before.Two");
    }
    @AfterReturning(value = "pointCut()")
    public void afterReturning() {
        System.out.println("AfterReturning.Two");
    }
    @AfterThrowing("pointCut()")
    public void afterThrowing() {
        System.out.println("AfterThrowing.Two");
    }
    @After("pointCut()")
    public void after() {
        System.out.println("After.Two");
    }
}

切入点方法

@Service
public class UserService {
    public void addUser() {
        System.out.println("切入点方法执行......");
    }

执行切入点方法

@SpringBootApplication
public class FlowControlApplication {
    public static void main(String[] args) {
        SpringApplication.run(FlowControlApplication.class, args);
    }
    @Autowired
    private UserService userService;
    @PostConstruct
    public void postConstruct() {
        // --------------调用切入点方法--------------
        userService.addUser();
    }
}

符合结论2：在切入点方法之前，优先级高的先执行。在切入点方法之后，优先级高的后执行。
调换2个切面的优先级：让切面2的优先级更高
结果：符合结论2。在切入点方法之前，优先级高的先执行。在切入点方法之后，优先级高的后执行。

4. 参考

Spring 5.3.39 docs
本文测试使用SpringBoot2.3.4.RELEASE，内部使用的是Spring5.x，所以这里看的也是5.x的文档(Spring6.x文档关于这部分的内容和Spring5.x是一样的)。

参考1说：在切入点方法之前，优先级越高的通知越先执行。在切入点访问之后，优先级越高的通知越后执行。
参考2说：在不同的切面中，可以通过给切面类”添加@Order”或者”实现Ordered接口”来指定切面的优先级，从而决定不同切面中通知的优先级。如果不指定，则执行顺序不可知。
参考3说：在同一个切面中，不同类型的通知优先级由高到低分别是@Around, @Before, @After, @AfterReturning, @AfterThrowing。注意，结合参考1，@After和@AfterReturning, @AfterThrowing都是在切入点之后执行的，优先级越高的通知越后执行，因此执行顺序是@AfterThrowing，@AfterReturning，@After。
结合参考1+参考3+上述测试得出结论1。
结合参考1+参考2+上述测试得出结论2。