獲取目標方法的資訊

    訪問目標方法最簡單的做法是定義增強處理方法時，將第一個引數定義為JoinPoint型別，當該增強處理方法被呼叫時，該JoinPoint引數就代表了織入增強處理的連線點。JoinPoint裡包含了如下幾個常用的方法：

• Object[] getArgs：返回目標方法的引數

• Signature getSignature：返回目標方法的簽名

• Object getTarget：返回被織入增強處理的目標物件

• Object getThis：返回AOP框架為目標物件生成的代理物件

    注意：當使用@Around處理時，我們需要將第一個引數定義為ProceedingJoinPoint型別，該類是JoinPoint的子類。

    下面的切面類（依然放在com.abc.advice包中）中定義了Before、Around、AfterReturning和After 4中增強處理，並分別在4種增強處理中訪問被織入增強處理的目標方法、目標方法的引數和被織入增強處理的目標物件等：

1. package com.abc.advice;  
2. import java.util.Arrays;  
3. import org.aspectj.lang.JoinPoint;  
4. import org.aspectj.lang.ProceedingJoinPoint;  
5. import org.aspectj.lang.annotation.After;  
6. import org.aspectj.lang.annotation.AfterReturning;  
7. import org.aspectj.lang.annotation.Around;  
8. import org.aspectj.lang.annotation.Aspect;  
9. import org.aspectj.lang.annotation.Before;  
10. @Aspect  
11. public class MyAspect {  
12.    //切入點
    @Pointcut("execution(* com.aaa.biz..*.*(..))")
    public void myCutPoint(){}
13.     @Around("myCutPoint()
    ")  
14.     public Object doAround(ProceedingJoinPoint point) throws Throwable {  
15.         System.out.println("@Around：執行目標方法之前...");  
16.         //訪問目標方法的引數：  
17.         Object[] args = point.getArgs();  
18.         if (args != null && args.length > 0 && args[0].getClass() == String.class) {  
19.             args[0] = "改變後的引數1";  
20.         }  
21.         //用改變後的引數執行目標方法  
22.         Object returnValue = point.proceed(args);  
23.         System.out.println("@Around：執行目標方法之後...");  
24.         System.out.println("@Around：被織入的目標物件為：" + point.getTarget());  
25.         return "原返回值：" + returnValue + "，這是返回結果的字尾";  
26.     }  
27.     @Before("myCutPoint()")  
28.     public void permissionCheck(JoinPoint point) {  
29.         System.out.println("@Before：模擬許可權檢查...");  
30.         System.out.println("@Before：目標方法為：" +   
31.                 point.getSignature().getDeclaringTypeName() +   
32.                 "." + point.getSignature().getName());  
33.         System.out.println("@Before：引數為：" + Arrays.toString(point.getArgs()));  
34.         System.out.println("@Before：被織入的目標物件為：" + point.getTarget());  
35.     }  
36.     @AfterReturning(pointcut="myCutPoint()",   
37.         returning="returnValue")  
38.     public void log(JoinPoint point, Object returnValue) {  
39.         System.out.println("@AfterReturning：模擬日誌記錄功能...");  
40.         System.out.println("@AfterReturning：目標方法為：" +   
41.                 point.getSignature().getDeclaringTypeName() +   
42.                 "." + point.getSignature().getName());  
43.         System.out.println("@AfterReturning：引數為：" +   
44.                 Arrays.toString(point.getArgs()));  
45.         System.out.println("@AfterReturning：返回值為：" + returnValue);  
46.         System.out.println("@AfterReturning：被織入的目標物件為：" + point.getTarget());  
47.     }  
48.     @After("myCutPoint()")  
49.     public void releaseResource(JoinPoint point) {  
50.         System.out.println("@After：模擬釋放資源...");  
51.         System.out.println("@After：目標方法為：" +   
52.                 point.getSignature().getDeclaringTypeName() +   
53.                 "." + point.getSignature().getName());  
54.         System.out.println("@After：引數為：" + Arrays.toString(point.getArgs()));  
55.         System.out.println("@After：被織入的目標物件為：" + point.getTarget());  
56.     }  
57. }  
58.     在AdviceManager類中增加以下內容：  
59. //將被AdviceTest的各種方法匹配  
60. public String manyAdvices(String param1, String param2) {  
61.     System.out.println("方法：manyAdvices");  
62.     return param1 + " 、" + param2;  
63. }  
64.     在com.abc.main.AOPTest中加入方法的呼叫，觸發切點：  
65. String result = manager.manyAdvices("aa", "bb");  
66. System.out.println("Test方法中呼叫切點方法的返回值：" + result);  
67.     下面是執行結果：  
68. @Around：執行目標方法之前...  
69. @Before：模擬許可權檢查...  
70. @Before：目標方法為：com.abc.service.AdviceManager.manyAdvices  
71. @Before：引數為：[改變後的引數1, bb]  
72. @Before：被織入的目標物件為：[email protected]  
73. 方法：manyAdvices  
74. @Around：執行目標方法之後...  
75. @Around：被織入的目標物件為：[email protected]  
76. @After：模擬釋放資源...  
77. @After：目標方法為：com.abc.service.AdviceManager.manyAdvices  
78. @After：引數為：[改變後的引數1, bb]  
79. @After：被織入的目標物件為：[email protected]  
80. @AfterReturning：模擬日誌記錄功能...  
81. @AfterReturning：目標方法為：com.abc.service.AdviceManager.manyAdvices  
82. @AfterReturning：引數為：[改變後的引數1, bb]  
83. @AfterReturning：返回值為：原返回值：改變後的引數1 、 bb，這是返回結果的字尾  
84. @AfterReturning：被織入的目標物件為：[email protected]  
85. Test方法中呼叫切點方法的返回值：原返回值：改變後的引數1 、bb，這是返回結果的字尾  

  從結果中可以看出：在任何一個織入的增強處理中，都可以獲取目標方法的資訊。另外，Spring AOP採用和AspectJ一樣的有限順序來織入增強處理：在“進入”連線點時，最高優先順序的增強處理將先被織入（所以給定的兩個Before增強處理中，優先順序高的那個會先執行）；在“退出”連線點時，最高優先順序的增強處理會最後被織入（所以給定的兩個After增強處理中，優先順序高的那個會後執行）。當不同的切面中的多個增強處理需要在同一個連線點被織入時，Spring AOP將以隨機的順序來織入這些增強處理。如果應用需要指定不同切面類裡的增強處理的優先順序，Spring提供瞭如下兩種解決方案：

• 讓切面類實現org.springframework.core.Ordered介面：實現該介面只需要實現一個int getOrder()方法，該方法返回值越小，優先順序越高

• 直接使用@Order註解來修飾一個切面類：使用這個註解時可以配置一個int型別的value屬性，該屬性值越小，優先順序越高

    優先順序高的切面類裡的增強處理的優先順序總是比優先順序低的切面類中的增強處理的優先順序高。例如：優先順序為1的切面類Bean1包含了@Before，優先順序為2的切面類Bean2包含了@Around，雖然@Around優先順序高於@Before，但由於Bean1的優先順序高於Bean2的優先順序，因此Bean1中的@Before先被織入。

    同一個切面類裡的兩個相同型別的增強處理在同一個連線點被織入時，Spring AOP將以隨機的順序來織入這兩個增強處理，沒有辦法指定它們的織入順序。如果確實需要保證它們以固有的順序被織入，則可以考慮將多個增強處理壓縮為一個增強處理；或者將不同增強處理重構到不同切面中，通過在切面級別上定義順序。

    如果只要訪問目標方法的引數，Spring還提供了一種更加簡潔的方法：我們可以在程式中使用args來繫結目標方法的引數。如果在一個args表示式中指定了一個或多個引數，該切入點將只匹配具有對應形參的方法，且目標方法的引數值將被傳入增強處理方法。下面輔以例子說明：

1. package com.abc.advice;  
2. import java.util.Date;  
3. import org.aspectj.lang.annotation.AfterReturning;  
4. import org.aspectj.lang.annotation.Aspect;  
5. @Aspect  
6. public class AccessArgAdviceTest {  
7.     @AfterReturning(  
8.             pointcut="myCutPoint() && args(time, name)",  
9.             returning="returnValue")  
10.     public void access(Date time, Object returnValue, String name) {  
11.         System.out.println("目標方法中的引數String = " + name);  
12.         System.out.println("目標方法中的引數Date = " + time);  
13.         System.out.println("目標方法的返回結果returnValue = " + returnValue);  
14.     }  
15. }  

    上面的程式中，定義pointcut時，表示式中增加了args(time, name)部分，意味著可以在增強處理方法（access方法）中定義time和name兩個屬性——這兩個形參的型別可以隨意指定，但一旦指定了這兩個引數的型別，則這兩個形參型別將用於限制該切入點只匹配第一個引數型別為Date，第二個引數型別為name的方法（方法引數個數和型別若有不同均不匹配）。

    注意，在定義returning的時候，這個值（即上面的returning="returnValue"中的returnValue）作為增強處理方法的形參時，位置可以隨意，即：如果上面access方法的簽名可以為

1. public void access(Date time, Object returnValue, String name)  

1. public void access(Object returnValue, Date time, String name)  

1. public void access(Date time, String name, Object returnValue)  

1.     只需要滿足另外的引數名的順序和pointcut中args(param1, param2)的順序相同即可。我們在AdviceManager中定義一個方法，該方法的第一個引數為Date型別，第二個引數為String型別，該方法的執行將觸發上面的access方法，如下：  
2. //將被AccessArgAdviceTest的access方法匹配  
3. public String accessAdvice(Date d, String n) {  
4.     System.out.println("方法：accessAdvice");  
5.     return "aa";  
6. }  
7.     在AOPTest中增加呼叫這個accessAdvice方法並執行，下面是輸出結果：  
8.     從執行結果可以看出，使用args表示式有如下兩個作用：  
9. 提供了一種簡單的方式來訪問目標方法的引數  
10. 可用於對切入點表示式作額外的限制 
11.  除此之外，使用args表示式時，還可以使用如下形式：args(param1, param2, ..)，注意args引數中後面的兩個點，它表示可以匹配更多引數。在例子args(param1, param2, ..)中，表示目標方法只需匹配前面param1和param2的型別即可。