Spring AOP中增強Advice的執行順序

• Spring AOP中Advice分類
• 同一Apsect中不同類型Advice執行順序
  • 配置基礎環境
  • 實驗結果
  • 結論
• 不同Aspect中Advice執行順序
  • 實驗一: Aspect1為高優先順序，Aspect2為低優先順序
    • 實驗結果
  • 實驗二: Aspect1為低優先順序，Aspect2為高優先順序
    • 實驗結果
  • 結論
• 參考資料:

本文主要驗證Spring AOP中Advice的執行順序問題。(Spring版本: 5.3.23)

Spring AOP中Advice分類

Spring AOP中Advice可分為如下五類:

1. @Around
2. @Before
3. @AfterReturning
4. @AfterThrowing
5. @After

Advice相關概念參考

同一Apsect中不同類型Advice執行順序

配置基礎環境

1. 依賴版本

• Spring 版本為: 5.3.23
• Spring Boot 版本為: 2.6.12
• aspectjweaver 版本: 1.9.9.1

2. 定義Spring Boot啟動類

package sakura.springinaction;

@SpringBootApplication
@EnableAspectJAutoProxy
public class MySpringApplication {
	public static void main(String[] args) {
		SpringApplication.run(MySpringApplication.class, args);
	}
}

3. 定義一個用於測試的Controller類

package sakura.springinaction.controller;

@Controller
@Slf4j
public class IndexController {
	@GetMapping("/time")
	@ResponseBody
	public String time() {
		LocalDateTime now = LocalDateTime.now();
		String nowTime = now.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME);
		log.info("Current time: " + nowTime);
		return nowTime;
	}
}

4. 定義一個聲明式切麵 Apsect1

@Slf4j
@Component
@Aspect
public class Aspect1 {

   // 定義 Point Cut 切麵
   @Pointcut("execution(public * sakura.springinaction.controller.*.*(..))")
   public void controllerLayer() {
   }

   // 定義Advice

   @Before("controllerLayer()")
   private void beforeAdvice2() {
   	log.info("Aspect_1 # @Before");
   }

   @After("controllerLayer() && @annotation(getMapping)")
   private void afterAdvice1(GetMapping getMapping) {
   	log.info("Aspect_1 # @afterAdvice" + " path: " + Arrays.toString(getMapping.value()));
   }

   @AfterReturning(pointcut = "controllerLayer()", returning = "val")
   private void afterReturningAdvice(Object val) {
   	log.info("Aspect_1 # @AfterReturning" + " returnValue: " + val);
   }

   @AfterThrowing(pointcut = "controllerLayer()", throwing = "thrower")
   private void afterThrowingAdvice(Throwable thrower) {
   	log.info("Aspect_1 # @AfterThrowing" + " thrower: " + thrower.getClass().getName());
   }

   @Around("controllerLayer() && @annotation(getMapping)")
   private Object aroundAdvice(ProceedingJoinPoint pjp, GetMapping getMapping) throws Throwable {
   	// Around 前置處理
   	Stopwatch stopwatch = Stopwatch.createStarted();
   	log.info("Aspect_1 # @Around-Before" + " methodName: " + pjp.getSignature().getName() + ", path: " + Arrays.toString(getMapping.value()));
   	Object result = pjp.proceed();
   	// Around 後置處理
   	log.info("Aspect_1 # @Around-After" + " methodName: " + pjp.getSignature().getName() + ", runTime: " + stopwatch.elapsed(TimeUnit.NANOSECONDS));
   	return result;
   }

}

實驗結果

在 發起請求(http://localhost:8080/time) 後，日誌輸出如圖:

結論

在同一個切麵(Apsect)定義中對於同一個Join Point而言，不同類型的Advice執行先後順序依次是:

1. @Around 前置處理
2. @Before
3. @AfterReturning/@AfterThrowing
4. @After
5. @Around 後置置處理

優先順序說明：

• 對於進入Join Point的Advice而言(比如: @Around 前置處理,@Before)，優先順序越高，越先執行；
• 對於從Join Point出來的Advice而言(比如: @Around 後置處理,@After)，優先順序越高，越後執行；
• 優先順序從高到低依次為: @Around, @Before,@After,@AfterReturning,@AfterThrowing；

PS:

如果在同一個切麵(Apsect)中定義了兩個同類型的Advice(比如定義兩個@Before), 對於某個Join Point而言這兩個Advice都匹配，那麼這兩個Advice執行的先後順序是無法確定的。

不同Aspect中Advice執行順序

問： 當不同的Aspect中的Advice 都匹配到了同一個Join Point，那麼那個Aspect中的Advice 先執行，那個後執行呢？

答： 不確定 ,但是可以通過在class上添加註解@Order指定優先順序確定執行順序(參考文檔)

實驗一: Aspect1為高優先順序，Aspect2為低優先順序

1. 與Aspect1 類似，再定義一個切麵類Aspect2,如下

package sakura.springinaction.advice;
import org.springframework.core.annotation.Order;

@Slf4j
@Component
@Aspect
@Order(2)
public class Aspect2 {
  // 定義Advice
  @Before("sakura.springinaction.advice.Aspect1.controllerLayer()")
  private void beforeAdvice2() {
    log.info("Aspect_2 # @Before");
  }

  @After("sakura.springinaction.advice.Aspect1.controllerLayer() && @annotation(getMapping)")
  private void afterAdvice1(GetMapping getMapping) {
    log.info("Aspect_2 # @afterAdvice" + " path: " + Arrays.toString(getMapping.value()));
  }

  @AfterReturning(pointcut = "sakura.springinaction.advice.Aspect1.controllerLayer()", returning = "val")
  private void afterReturningAdvice(Object val) {
    log.info("Aspect_2 # @AfterReturning" + " returnValue: " + val);
  }

  @AfterThrowing(pointcut = "sakura.springinaction.advice.Aspect1.controllerLayer()", throwing = "thrower")
  private void afterThrowingAdvice(Throwable thrower) {
    log.info("Aspect_2 # @AfterThrowing" + " thrower: " + thrower.getClass().getName());
  }

  @Around("sakura.springinaction.advice.Aspect1.controllerLayer() && @annotation(getMapping)")
  private Object aroundAdvice(ProceedingJoinPoint pjp, GetMapping getMapping) throws Throwable {
    Stopwatch stopwatch = Stopwatch.createStarted();
    log.info("Aspect_2 # @Around-Before" + " methodName: " + pjp.getSignature().getName() + ", path: " + Arrays.toString(getMapping.value()));
    Object result = pjp.proceed();
    log.info("Aspect_2 # @Around-After" + " methodName: " + pjp.getSignature().getName() + ", runTime: " + stopwatch.elapsed(TimeUnit.NANOSECONDS));
    return result;
  }

}

2. Aspect1 添加@Order註解指定優先順序，如下

@Slf4j
@Component
@Aspect
@Order(1)
public class Aspect1 {
  //...
}

此時，Aspect1的優先順序比Aspect2的優先順序高。

實驗結果

實驗結果如下:

說明：

高優先順序的Aspect1中的@Around前置處理和@Before先於低優先順序的Aspect2執行，而@AfterReturning,@After和@Around後置處理，則低優先順序的Aspect2先執行。

實驗二: Aspect1為低優先順序，Aspect2為高優先順序

1. 更改兩個Aspect中@Order註解優先順序,如下:

@Slf4j
@Component
@Aspect
@Order(2)
public class Aspect1 {
  //...
}

@Slf4j
@Component
@Aspect
@Order(1)
public class Aspect2 {
	//...
}

實驗結果

實驗結果如下:

結論

1. 當不同的Aspect中的Advice 都匹配到了同一個Join Point，不同Aspect中的Advice 執行順序不確定。
2. 通過在Aspect類上添加註解@Order指定優先順序，確定執行順序，執行順序滿足如下規律
   1. 對於@Around前置處理 和@Before兩種Advice而言，所在的Aspect優先順序越高，越先執行
   2. 對於@AfterReturning，@AfterThrowing,@After和@Around後置處理 類型的Advice而言，所在的Aspect優先順序越高，越後執行

參考資料:

1. Aspect Oriented Programming with Spring
2. AspectJ Programming Guide

本文主要目的是記錄學習過程,加深對知識點理解; 如有行文有誤,望指正。