Spring AOP之坑：徹底搞清楚advice的執行順序

AOP的核心概念

要徹底理解Spring AOP首先要理解AOP的核心概念和術語，這些術語並非Spring指定的，並且很不幸，這些術語並不能直觀理解，可是，若是Spring使用本身的術語，那將更加使人困惑。

• Aspect：切面，由一系列切點、加強和引入組成的模塊對象，可定義優先級，從而影響加強和引入的執行順序。事務管理（Transaction management）在java企業應用中就是一個很好的切面樣例。
• Join point：接入點，程序執行期的一個點，例如方法執行、類初始化、異常處理。 在Spring AOP中，接入點始終表示方法執行。
• Advice：加強，切面在特定接入點的執行動做，包括 "around," "before" and "after"等多種類型。包含Spring在內的許多AOP框架，一般會使用攔截器來實現加強，圍繞着接入點維護着一個攔截器鏈。
• Pointcut：切點，用來匹配特定接入點的謂詞（表達式），加強將會與切點表達式產生關聯，並運行在任何切點匹配到的接入點上。經過切點表達式匹配接入點是AOP的核心，Spring默認使用AspectJ的切點表達式。
• Introduction：引入，爲某個type聲明額外的方法和字段。Spring AOP容許你引入任何接口以及它的默認實現到被加強對象上。
• Target object：目標對象，被一個或多個切面加強的對象。也叫做被加強對象。既然Spring AOP使用運行時代理（runtime proxies），那麼目標對象就老是代理對象。
• AOP proxy：AOP代理，爲了實現切面功能一個對象會被AOP框架建立出來。在Spring框架中AOP代理的默認方式是：有接口，就使用基於接口的JDK動態代理，不然使用基於類的CGLIB動態代理。可是咱們能夠經過設置proxy-target-class="true"，徹底使用CGLIB動態代理。
• Weaving：織入，將一個或多個切面與類或對象連接在一塊兒建立一個被加強對象。織入能發生在編譯時 （compile time ）(使用AspectJ編譯器)，加載時（load time），或運行時（runtime） 。Spring AOP默認就是運行時織入，能夠經過枚舉AdviceMode來設置。

---

模擬aspect advice的執行過程

在這裏咱們再也不展現測試代碼，而是經過簡單的代碼來模擬aspect advice的執行過程。

儘管Spring AOP是經過動態代理來實現的，可是咱們能夠繞過代理，直接模擬出它的執行過程，示例代碼：

package doubt;
public class AspectAdviceInvokeProcess {
	public static void main(String[] args){
		try {
		    //正常執行
			AspectInvokeProcess(false);
			System.out.println("=====分割線=====");
			//異常執行
			AspectInvokeProcess(true);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/** * 切面執行過程 * @param isException * @throws Exception */
	public static void AspectInvokeProcess(boolean isException) throws Exception{
		try {
			try {
				aroundAdvice(isException);
			} finally {
				afterAdvice();
			}
		    afterReturningAdvice();
		    return;
		} catch (Exception e) {
			afterThrowingAdvice(e);
			throw e;
			return;
		}	
	}
	
	/** * 環繞加強 * @param isException * @throws Exception */
	private static void aroundAdvice(boolean isException) throws Exception {
		System.out.println("around before advice");
		try {
			JoinPoint_Proceed(isException);
		} finally {
			System.out.println("around after advice");
		}
	}
	
	/** * 編織後的接入點執行過程 * @param isException */
	public static void JoinPoint_Proceed(boolean isException){
		beforeAdvice();
		targetMethod(isException);
	}
	
	/** * 前置加強 */
	private static void beforeAdvice() {
		System.out.println("before advice");
	}

	/** * 目標方法 * @param isException */
	private static void targetMethod(boolean isException) {
		System.out.println("target method 執行");
		if(isException)
			throw new RuntimeException("異常發生");
	}
	
	/** * 後置加強 */
	private static void afterAdvice() {
		System.out.println("after advice");
	}

	/** * 正常返回加強 */
	private static void afterReturningAdvice() {
		System.out.println("afterReturning");
	}

	/** * 異常返回加強 * @param e * @throws Exception */
	private static void afterThrowingAdvice(Exception e) throws Exception {
		System.out.println("afterThrowing:"+e.getMessage());
	}
}
複製代碼

---

同一aspect，不一樣advice的執行順序

上述代碼的執行結果，直接體現了同一apsect中不一樣advice的執行順序，結果以下：

around before advice
before advice
target method 執行
around after advice
after advice
afterReturning
===============分割線==============
around before advice
before advice
target method 執行
around after advice
after advice
afterThrowing:異常發生
java.lang.RuntimeException: 異常發生
複製代碼

得出結論：

---

不一樣aspect，advice的執行順序

詳情可見，《Spring官方文檔》 docs.spring.io/spring/docs…

Spring AOP經過指定aspect的優先級，來控制不一樣aspect，advice的執行順序，有兩種方式：

• Aspect 類添加註解：org.springframework.core.annotation.Order，使用註解value屬性指定優先級。

• Aspect 類實現接口：org.springframework.core.Ordered，實現 Ordered 接口的 getOrder() 方法。

其中，數值越低，代表優先級越高，@Order 默認爲最低優先級，即最大數值：

/** * Useful constant for the lowest precedence value. * @see java.lang.Integer#MAX_VALUE */
	int LOWEST_PRECEDENCE = Integer.MAX_VALUE;
複製代碼

最終，不一樣aspect，advice的執行順序：

• 入操做（Around（接入點執行前）、Before），優先級越高，越先執行；
• 一個切面的入操做執行完，才輪到下一切面，全部切面入操做執行完，纔開始執行接入點；
• 出操做（Around（接入點執行後）、After、AfterReturning、AfterThrowing），優先級越低，越先執行。
• 一個切面的出操做執行完，才輪到下一切面，直到返回到調用點；

以下圖所示：

先入後出，後入先出

---

同一aspect，相同advice的執行順序

同一aspect，相同advice的執行順序並不能直接肯定，並且 @Order 在advice方法上也無效，可是有以下兩種變通方式：

• 將兩個 advice 合併爲一個 advice，那麼執行順序就能夠經過代碼控制了
• 將兩個 advice 分別抽離到各自的 aspect 內，而後爲 aspect 指定執行順序

---

Transactional Aspect的優先級

Spring事務管理（Transaction Management），也是基於Spring AOP。

在Spring AOP的使用中，有時咱們必須明確自定義aspect的優先級低於或高於事務切面（Transaction Aspect），因此咱們須要知道：

• 事務切面優先級：默認爲最低優先級

LOWEST_PRECEDENCE = Integer.MAX_VALUE
複製代碼

• 事務的加強類型：Around advice，其實不難理解，進入方法開啓事務，退出方法提交或回滾，因此須要環繞加強。

public abstract aspect AbstractTransactionAspect extends TransactionAspectSupport implements DisposableBean {

   protected AbstractTransactionAspect(TransactionAttributeSource tas) {
   	setTransactionAttributeSource(tas);
   }

   @SuppressAjWarnings("adviceDidNotMatch")
   Object around(final Object txObject): transactionalMethodExecution(txObject) {
   	MethodSignature methodSignature = (MethodSignature) thisJoinPoint.getSignature();
   	// Adapt to TransactionAspectSupport's invokeWithinTransaction...
   	try {
   		return invokeWithinTransaction(methodSignature.getMethod(), txObject.getClass(), new InvocationCallback() {
   			public Object proceedWithInvocation() throws Throwable {
   				return proceed(txObject);
   			}
   		});
   	}
   	catch (RuntimeException ex) {
   		throw ex;
   	}
   	catch (Error err) {
   		throw err;
   	}
   	catch (Throwable thr) {
   		Rethrower.rethrow(thr);
   		throw new IllegalStateException("Should never get here", thr);
   	}
   }
}
複製代碼

• 如何修改事務切面的優先級： 在開啓事務時，經過設置 @EnableTransactionManagement 和 <tx:annotation-driven/> 中的， order 屬性來修改事務切面的優先級。 詳情可見，《Spring官方文檔》docs.spring.io/spring/docs…