spring aop通知(advice)分成五類：
前置通知[Before advice]：在連接點前面執行，前置通知不會影響連接點的執行，除非此處拋出異常。
正常返回通知[After returning advice]：在連接點正常執行完成后執行，如果連接點拋出異常，則不會執行。
異常返回通知[After throwing advice]：在連接點拋出異常后執行。
返回通知[After (finally) advice]：在連接點執行完成后執行，不管是正常執行完成，還是拋出異常，都會執行返回通知中的內容。
環繞通知[Around advice]：環繞通知圍繞在連接點前后，比如一個方法調用的前后。這是最強大的通知類型，能在方法調用前后自定義一些操作。
環繞通知還需要負責決定是繼續處理join point(調用ProceedingJoinPoint的proceed方法)還是中斷執行。
接下來通過編寫示例程序來測試一下五種通知類型：
定義接口
package com.chenqa.springaop.example.service;
public interface BankService {
/**
* 模擬的銀行轉賬
* @param from 出賬人
* @param to 入賬人
* @param account 轉賬金額
* @return
*/
public boolean transfer(String form, String to, double account);
}
編寫實現類
package com.chenqa.springaop.example.service.impl;
import com.chenqa.springaop.example.service.BankService;
public class BCMBankServiceImpl implements BankService {
public boolean transfer(String form, String to, double account) {
if(account<100) {
throw new IllegalArgumentException("最低轉賬金額不能低于100元");
}
System.out.println(form+"向"+to+"交行賬戶轉賬"+account+"元");
return false;
}
}
修改spring配置文件，添加以下內容：
<!-- bankService bean -->
<bean id="bankService" class="com.chenqa.springaop.example.service.impl.BCMBankServiceImpl"/>
<!-- 切面 -->
<bean id="myAspect" class="com.chenqa.springaop.example.aspect.MyAspect"/>
<!-- aop配置 -->
<aop:config>
<aop:aspect ref="myAspect">
<aop:pointcut expression="execution(* com.chenqa.springaop.example.service.impl.*.*(..))" id="pointcut"/>
<aop:before method="before" pointcut-ref="pointcut"/>
<aop:after method="after" pointcut-ref="pointcut"/>
<aop:after-returning method="afterReturning" pointcut-ref="pointcut"/>
<aop:after-throwing method="afterThrowing" pointcut-ref="pointcut"/>
<aop:around method="around" pointcut-ref="pointcut"/>
</aop:aspect>
</aop:config>
編寫測試程序
ApplicationContext context = new ClassPathXmlApplicationContext("spring-aop.xml");
BankService bankService = context.getBean("bankService", BankService.class);
bankService.transfer("張三", "李四", 200);
執行后輸出:
將測試程序中的200改成50，再執行后輸出:
通過測試結果可以看出，五種通知的執行順序為：
前置通知→環繞通知→正常返回通知/異常返回通知→返回通知，可以多次執行來查看。
情況一: 一個方法只被一個Aspect類攔截
當一個方法只被一個Aspect攔截時，這個Aspect中的不同advice是按照怎樣的順序進行執行的呢？請看:
添加 PointCut類
該pointcut用來攔截test包下的所有類中的所有方法。
package test;
import org.aspectj.lang.annotation.Pointcut;
public class PointCuts {
@Pointcut(value = "within(test.*)")
public void aopDemo() {
}
}
添加Aspect類
該類中的advice將會用到上面的pointcut，使用方法請看各個advice的value屬性。
package test;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
@Component
@Aspect
public class Aspect1 {
@Before(value = "test.PointCuts.aopDemo()")
public void before(JoinPoint joinPoint) {
System.out.println("[Aspect1] before advise");
}
@Around(value = "test.PointCuts.aopDemo()")
public void around(ProceedingJoinPoint pjp) throws Throwable{
System.out.println("[Aspect1] around advise 1");
pjp.proceed();
System.out.println("[Aspect1] around advise2");
}
@AfterReturning(value = "test.PointCuts.aopDemo()")
public void afterReturning(JoinPoint joinPoint) {
System.out.println("[Aspect1] afterReturning advise");
}
@AfterThrowing(value = "test.PointCuts.aopDemo()")
public void afterThrowing(JoinPoint joinPoint) {
System.out.println("[Aspect1] afterThrowing advise");
}
@After(value = "test.PointCuts.aopDemo()")
public void after(JoinPoint joinPoint) {
System.out.println("[Aspect1] after advise");
}
}
添加測試用Controller
添加一個用于測試的controller，這個controller中只有一個方法，但是它會根據參數值的不同，會作出不同的處理：一種是正常返回一個對象，一種是拋出異常(因為我們要測試@AfterThrowing這個advice)
package test;
import test.exception.TestException;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping(value = "/aop")
public class AopTestController {
@ResponseStatus(HttpStatus.OK)
@RequestMapping(value = "/test", method = RequestMethod.GET)
public Result test(@RequestParam boolean throwException) {
// case 1
if (throwException) {
System.out.println("throw an exception");
throw new TestException("mock a server exception");
}
// case 2
System.out.println("test OK");
return new Result() {{
this.setId(111);
this.setName("mock a Result");
}};
}
public static class Result {
private int id;
private String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
}
測試 正常情況
在瀏覽器直接輸入以下的URL，回車：http://192.168.142.8:7070/aoptest/v1/aop/test?throwException=false1
我們會看到輸出的結果是：
[Aspect1] around advise 1 [Aspect1] before advise test OK [Aspect1] around advise2 [Aspect1] after advise [Aspect1] afterReturning advise
測試 異常情況
在瀏覽器中直接輸入以下的URL，回車：http://192.168.142.8:7070/aoptest/v1/aop/test?throwException=true1
我們會看到輸出的結果是：
[Aspect1] around advise 1 [Aspect1] before advise throw an exception [Aspect1] after advise [Aspect1] afterThrowing advise
結論
在一個方法只被一個aspect類攔截時，aspect類內部的 advice 將按照以下的順序進行執行：
正常情況：
異常情況：
情況二: 同一個方法被多個Aspect類攔截
此處舉例為被兩個aspect類攔截。
有些情況下，對于兩個不同的aspect類，不管它們的advice使用的是同一個pointcut，還是不同的pointcut，都有可能導致同一個方法被多個aspect類攔截。那么，在這種情況下，這多個Aspect類中的advice又是按照怎樣的順序進行執行的呢？請看:
pointcut類保持不變
添加一個新的aspect類
package test;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
@Component
@Aspect
public class Aspect2 {
@Before(value = "test.PointCuts.aopDemo()")
public void before(JoinPoint joinPoint) {
System.out.println("[Aspect2] before advise");
}
@Around(value = "test.PointCuts.aopDemo()")
public void around(ProceedingJoinPoint pjp) throws Throwable{
System.out.println("[Aspect2] around advise 1");
pjp.proceed();
System.out.println("[Aspect2] around advise2");
}
@AfterReturning(value = "test.PointCuts.aopDemo()")
public void afterReturning(JoinPoint joinPoint) {
System.out.println("[Aspect2] afterReturning advise");
}
@AfterThrowing(value = "test.PointCuts.aopDemo()")
public void afterThrowing(JoinPoint joinPoint) {
System.out.println("[Aspect2] afterThrowing advise");
}
@After(value = "test.PointCuts.aopDemo()")
public void after(JoinPoint joinPoint) {
System.out.println("[Aspect2] after advise");
}
}
測試用Controller也不變
還是使用上面的那個Controller。但是現在 aspect1 和 aspect2 都會攔截該controller中的方法。
下面繼續進行測試！
測試 正常情況
在瀏覽器直接輸入以下的URL，回車：http://192.168.142.8:7070/aoptest/v1/aop/test?throwException=false1
我們會看到輸出的結果是：
[Aspect2] around advise 1 [Aspect2] before advise [Aspect1] around advise 1 [Aspect1] before advise test OK [Aspect1] around advise2 [Aspect1] after advise [Aspect1] afterReturning advise [Aspect2] around advise2 [Aspect2] after advise [Aspect2] afterReturning advise
但是這個時候，我不能下定論說 aspect2 肯定就比 aspect1 先執行。
不信？你把服務務器重新啟動一下，再試試，說不定你就會看到如下的執行結果：
[Aspect1] around advise 1 [Aspect1] before advise [Aspect2] around advise 1 [Aspect2] before advise test OK [Aspect2] around advise2 [Aspect2] after advise [Aspect2] afterReturning advise [Aspect1] around advise2 [Aspect1] after advise [Aspect1] afterReturning advise
也就是說，這種情況下， aspect1 和 aspect2 的執行順序是未知的。那怎么解決呢？不急，下面會給出解決方案。
測試 異常情況
在瀏覽器中直接輸入以下的URL，回車：http://192.168.142.8:7070/aoptest/v1/aop/test?throwException=true1
我們會看到輸出的結果是：
[Aspect2] around advise 1 [Aspect2] before advise [Aspect1] around advise 1 [Aspect1] before advise throw an exception [Aspect1] after advise [Aspect1] afterThrowing advise [Aspect2] after advise [Aspect2] afterThrowing advise
同樣地，如果把服務器重啟，然后再測試的話，就可能會看到如下的結果：
[Aspect1] around advise 1 [Aspect1] before advise [Aspect2] around advise 1 [Aspect2] before advise throw an exception [Aspect2] after advise [Aspect2] afterThrowing advise [Aspect1] after advise [Aspect1] afterThrowing advise
也就是說，同樣地，異常情況下， aspect1 和 aspect2 的執行順序也是未定的。
那么在 情況二 下，如何指定每個 aspect 的執行順序呢？
方法有兩種：
不管采用上面的哪種方法，都是值越小的 aspect 越先執行。
比如，我們為 apsect1 和 aspect2 分別添加 @Order 注解，如下：
@Order(5)
@Component
@Aspect
public class Aspect1 {
// ...
}
@Order(6)
@Component
@Aspect
public class Aspect2 {
// ...
}
這樣修改之后，可保證不管在任何情況下， aspect1 中的 advice 總是比 aspect2 中的 advice 先執行。如下圖所示：
注意點
如果在同一個 aspect 類中，針對同一個 pointcut，定義了兩個相同的 advice(比如，定義了兩個 @Before)，那么這兩個 advice 的執行順序是無法確定的，哪怕你給這兩個 advice 添加了 @Order 這個注解，也不行。這點切記。
對于@Around這個advice，不管它有沒有返回值，但是必須要方法內部，調用一下 pjp.proceed();否則，Controller 中的接口將沒有機會被執行，從而也導致了 @Before這個advice不會被觸發。比如，我們假設正常情況下，執行順序為”aspect2 -> apsect1 -> controller”，如果，我們把 aspect1中的@Around中的 pjp.proceed();給刪掉，那么，我們看到的輸出結果將是：
[Aspect2] around advise 1 [Aspect2] before advise [Aspect1] around advise 1 [Aspect1] around advise2 [Aspect1] after advise [Aspect1] afterReturning advise [Aspect2] around advise2 [Aspect2] after advise [Aspect2] afterReturning advise
從結果可以發現， Controller 中的 接口 未被執行，aspect1 中的 @Before advice 也未被執行。
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持億速云。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
