復習了一下Spring，發(fā)現(xiàn)忘了很多東西了。特別是AOP這一塊兒，于是認真看了看，寫篇文章總結(jié)總結(jié)。

概念

AOP（Aspect Oriented Programming），即面向切面編程（也叫面向方面編程，面向方法編程）。其主要作用是，在不修改源代碼的情況下給某個或者一組操作添加額外的功能。像日志記錄，事務處理，權(quán)限控制等功能，都可以用AOP來“優(yōu)雅”地實現(xiàn)，使這些額外功能和真正的業(yè)務邏輯分離開來，軟件的結(jié)構(gòu)將更加清晰。AOP是OOP的一個強有力的補充。

術(shù)語

AOP的術(shù)語不太直觀，Spring文檔中也沒有給一個確切的定義，所以重在理解。

• Join Point: Spring AOP中，join point就是一個方法。（通俗來講就是起作用的那個方法）。

• Pointcut: 用來指定join point（通俗來講就是描述的一組符合某個條件的join point）。通常使用pointcut表達式來限定joint point，Spring默認使用AspectJ pointcut expression language。

• Advice: 在join point上特定的時刻執(zhí)行的操作，Advice有幾種不同類型，下文將會討論（通俗地來講就是起作用的內(nèi)容和時間點）。

• Introduction：給對象增加方法或者屬性。

• Target object: Advice起作用的那個對象。

• AOP proxy: 為實現(xiàn)AOP所生成的代理。在Spring中有兩種方式生成代理:JDK代理和CGLIB代理。

• Aspect: 組合了Pointcut與Advice，在Spring中有時候也稱為Advisor。某些資料說Advisor是一種特殊的Aspect，其區(qū)別是Advisor只能包含一對pointcut和advice，但是aspect可以包含多對。AOP中的aspect可以類比于OOP中的class。

• Weaving：將Advice織入join point的這個過程。

Advice的類型

• Before advice:  執(zhí)行在join point之前的advice,但是它不能阻止joint point的執(zhí)行流程，除非拋出了一個異常（exception）。

• After returning advice: 執(zhí)行在join point這個方法返回之后的advice。

• After throwing advice: 執(zhí)行在join point拋出異常之后的advice。

• After(finally) advice: 執(zhí)行在join point返回之后或者拋出異常之后的advice，通常用來釋放所使用的資源。

• Around advice: 執(zhí)行在join point這個方法執(zhí)行之前與之后的advice。

兩種代理

Spring AOP是基于代理機制的。上文說到，Spring AOP通過JDK Proxy和CGLIB Proxy兩種方法實現(xiàn)代理。

如果target object沒有實現(xiàn)任何接口，那么Spring將使用CGLIB來實現(xiàn)代理。CGLIB是一個開源項目,它是一個強大的,高性能,高質(zhì)量的Code生成類庫,它可以在運行期擴展Java類與實現(xiàn)Java接口。

如果target object實現(xiàn)了一個以上的接口，那么Spring將使用JDK Proxy來實現(xiàn)代理，因為Spring默認使用的就是JDK Proxy，并且JDK Proxy是基于接口的。這也是Spring提倡的面向接口編程。當然，你也可以強制使用CGLIB來進行代理，但是這樣可能會造成性能上的下降。

Pointcut expression

Pointcut通過pointcut expression來描述，有若干種限定詞。由于Pointcut的定義在Spring文檔7.2.3 Declaring a pointcut中寫得比較詳細，所以在此不再贅述。

Spring AOP的使用

我們可以通過三種方式來使用Spring AOP，它們分別是：@Aspect-based（Annotation），Schema-based（XML），以及底層的Spring AOP API。

@Aspect-based (Annotation)

Annotaion是最常用的方式。

配置

首先，我們應該在配置文件中增加對Annotation的支持。

假設我們的配置文件是classpath下的applicationContext.xml，添加如下片段:

1

<aop:aspectj-autoproxy />

業(yè)務邏輯類

假設我們有一個UserManager類，這個類負責處理業(yè)務邏輯。類的定義如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public class UserManager {
  /*這個方法需要一個參數(shù)*/
  public void addUser(String user) {
      System.out.println("addUser(String str) method is executed!");
  }
  
  public void deleteUser() {
      System.out.println("deleteUser() method is executed!");
  }
  /*這個方法返回一個字符串*/
  public String getUser() {
      System.out.println("getUser() method is executed!");
      return "Hello";
  }
  /*這個方法拋出一個異常*/
  public void editUser() throws Exception {
      throw new Exception("something is wrong.");
  }    
}

這是一個很普通的Java對象，看不出任何Spring AOP的痕跡，這也是Spring低侵入式設計的體現(xiàn)。

切面（Aspect）類

為了給業(yè)務邏輯增加額外功能，我們需要定義一個切面類，切面類里包含了pointcut和advice。假設我們的切面類是ExampleAspect，代碼如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

@Aspect
public class ExampleAspect {
  
  @Pointcut("execution(* com.psjay.example.spring.aop.*.*(..))")
  public void aPointcut() {
  }
  
  @Before("aPointcut()")
  public void beforeAdvice() {
      System.out.println("before advice is executed!");
  }
  
  @AfterReturning(pointcut = "aPointcut()", returning="r")
  public void afterReturningAdvice(String r) {
      if (r != null)
          System.out.println("after returning advice is executed! returning String is : " + r);
  }
  
  @After("aPointcut()")
  public void AfterAdvice() {
      System.out.println("after advice is executed!");
  }
  
  @After("aPointcut() && args(str)")
  public void AfterAdviceWithArg(String str) {
      System.out.println("after advice with arg is executed!arg is : " + str);
  }
  
  @AfterThrowing(pointcut="aPointcut()",throwing="e")
  public void afterThrowingAdvice(Exception e) {
      System.out.println("after throwing advice is executed!exception msg is : " + e.getMessage());
  }
  
}

在基于annotation的Spring AOP中，@Aspect用來標注切面類。@Pointcut標注一個空的方法，用來代表一個pointcut，這個方法必須是public的。@Pointcut注解括號內(nèi)是pointcut expression，例子中的表達式表示com.psjay.example.spring.aop的所有方法都是join point。而@Before,@After等注解對應著幾種不同類型的Advice。被標注的方法就是一個Advice。@Advice注解括號內(nèi)是一個pointcut。例子中的@afterReturningAdvice()，AfterAdviceWithArg()和afterThrowingAdvice()分別演示了Advice得到join point的返回值，Advice使用join point的參數(shù)，Advice使用join point拋出的異常對象幾種操作。

不要忘了在Spring配置文件中配置以上兩個類的“Bean”，這里就不貼出具體代碼了。

測試類

測試類相對簡單，就是從Spring中拿出bean演示AOP的結(jié)果。測試類代碼如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class Test {

  public static void main(String[] args) {
      ApplicationContext ctx  = new ClassPathXmlApplicationContext("applicationContext.xml");
      UserManager um =  ctx.getBean("userManager",UserManager.class);
      System.out.println("------ Case 1 --------");
      um.addUser("hey");
      System.out.println("------ Case 2 --------");
      try {
          um.editUser();
      } catch (Exception e) {
          
      }
      System.out.println("------ Case 3 --------");
      um.getUser();
      
  }
}

測試結(jié)果：

------ Case 1 --------
before advice is executed!
addUser(String str) method is executed!
after advice is executed!
after advice with arg is executed!arg is : hey
------ Case 2 --------
before advice is executed!
after advice is executed!
after throwing advice is executed!exception msg is : something is wrong.
------ Case 3 --------
before advice is executed!
getUser() method is executed!
after returning advice is executed! returning String is : Hello
after advice is executed!

可以看到，Advice已經(jīng)在對應的join point上起作用了。

Schema-based（XML）

除了使用Annotation，我們還可以使用XML來實現(xiàn)Spring AOP。使用XML來實現(xiàn)AOP只是將AOP的配置信息移到XML配置文件里，其他地方與annotation實現(xiàn)AOP并無太大區(qū)別。所以這里就不貼出相關(guān)代碼了。具體配置方法，見Spring文檔7.3. Schema-based AOP support。

Spring AOP API

在Spring1.2中使用底層的Spring AOP API來實現(xiàn)AOP。當然，Spring3也是完全與其兼容的。我們可以借其窺探一下底層實現(xiàn)。由于比較復雜，我將單獨寫一篇文章來描述這種實現(xiàn)方式。

總結(jié)

Spring AOP是基于代理的，是運行時綁定的。合理的運用AOP，將使軟件的開發(fā)更加便捷，清晰。