簡介： AOP（Aspect Orient Programming），也就是面向方面編程，作為面向?qū)ο缶幊痰囊环N補(bǔ)充，專門用于處理系統(tǒng)中分布于各個(gè)模塊（不同方法）中的交叉關(guān)注點(diǎn)的問題，在 Java EE 應(yīng)用中，常常通過 AOP 來處理一些具有橫切性質(zhì)的系統(tǒng)級(jí)服務(wù)，如事務(wù)管理、安全檢查、緩存、對(duì)象池管理等。AOP 實(shí)現(xiàn)的關(guān)鍵就在于 AOP 框架自動(dòng)創(chuàng)建的 AOP 代理，AOP 代理主要分為靜態(tài)代理和動(dòng)態(tài)代理兩大類，靜態(tài)代理以 AspectJ 為代表；而動(dòng)態(tài)代理則以 Spring AOP 為代表。本文會(huì)從 AspectJ 分析起，逐漸深入，并介紹 CGLIB 來介紹 Spring AOP 框架的實(shí)現(xiàn)原理。

AOP（Aspect Orient Programming），作為面向?qū)ο缶幊痰囊环N補(bǔ)充，廣泛應(yīng)用于處理一些具有橫切性質(zhì)的系統(tǒng)級(jí)服務(wù)，如事務(wù)管理、安全檢查、緩存、對(duì)象池管理等。 AOP 實(shí)現(xiàn)的關(guān)鍵就在于 AOP 框架自動(dòng)創(chuàng)建的 AOP 代理，AOP 代理則可分為靜態(tài)代理和動(dòng)態(tài)代理兩大類，其中靜態(tài)代理是指使用 AOP 框架提供的命令進(jìn)行編譯，從而在編譯階段就可生成 AOP 代理類，因此也稱為編譯時(shí)增強(qiáng)；而動(dòng)態(tài)代理則在運(yùn)行時(shí)借助于 JDK 動(dòng)態(tài)代理、CGLIB 等在內(nèi)存中“臨時(shí)”生成 AOP 動(dòng)態(tài)代理類，因此也被稱為運(yùn)行時(shí)增強(qiáng)。

AOP 的存在價(jià)值

在傳統(tǒng) OOP 編程里以對(duì)象為核心，整個(gè)軟件系統(tǒng)由系列相互依賴的對(duì)象所組成，而這些對(duì)象將被抽象成一個(gè)一個(gè)的類，并允許使用類繼承來管理類與類之間一般到特殊的關(guān)系。隨著軟件規(guī)模的增大，應(yīng)用的逐漸升級(jí)，慢慢出現(xiàn)了一些 OOP 很難解決的問題。

我們可以通過分析、抽象出一系列具有一定屬性與行為的對(duì)象，并通過這些對(duì)象之間的協(xié)作來形成一個(gè)完整的軟件功能。由于對(duì)象可以繼承，因此我們可以把具有相同功能或相同特性的屬性抽象到一個(gè)層次分明的類結(jié)構(gòu)體系中。隨著軟件規(guī)范的不斷擴(kuò)大，專業(yè)化分工越來越系列，以及 OOP 應(yīng)用實(shí)踐的不斷增多，隨之也暴露出了一些 OOP 無法很好解決的問題。

現(xiàn)在假設(shè)系統(tǒng)中有 3 段完全相似的代碼，這些代碼通常會(huì)采用“復(fù)制”、“粘貼”方式來完成，通過這種“復(fù)制”、“粘貼”方式開發(fā)出來的軟件如圖 1 所示。

圖 1.多個(gè)地方包含相同代碼的軟件

看到如圖 1 所示的示意圖，可能有的讀者已經(jīng)發(fā)現(xiàn)了這種做法的不足之處：如果有一天，圖 1 中的深色代碼段需要修改，那是不是要打開 3 個(gè)地方的代碼進(jìn)行修改？如果不是 3 個(gè)地方包含這段代碼，而是 100 個(gè)地方，甚至是 1000 個(gè)地方包含這段代碼段，那會(huì)是什么后果？

為了解決這個(gè)問題，我們通常會(huì)采用將如圖 1 所示的深色代碼部分定義成一個(gè)方法，然后在 3 個(gè)代碼段中分別調(diào)用該方法即可。在這種方式下，軟件系統(tǒng)的結(jié)構(gòu)如圖 2 所示。

圖 2 通過方法調(diào)用實(shí)現(xiàn)系統(tǒng)功能

對(duì)于如圖 2 所示的軟件系統(tǒng)，如果需要修改深色部分的代碼，只要修改一個(gè)地方即可，不管整個(gè)系統(tǒng)中有多少地方調(diào)用了該方法，程序無須修改這些地方，只需修改被調(diào)用的方法即可——通過這種方式，大大降低了軟件后期維護(hù)的復(fù)雜度。

對(duì)于如圖 2 所示的方法 1、方法 2、方法 3 依然需要顯式調(diào)用深色方法，這樣做能夠解決大部分應(yīng)用場景。但對(duì)于一些更特殊的情況：應(yīng)用需要方法 1、方法 2、方法 3 徹底與深色方法分離——方法 1、方法 2、方法 3 無須直接調(diào)用深色方法，那如何解決？

因?yàn)檐浖到y(tǒng)需求變更是很頻繁的事情，系統(tǒng)前期設(shè)計(jì)方法 1、方法 2、方法 3 時(shí)只實(shí)現(xiàn)了核心業(yè)務(wù)功能，過了一段時(shí)間，我們需要為方法 1、方法 2、方法 3 都增加事務(wù)控制；又過了一段時(shí)間，客戶提出方法 1、方法 2、方法 3 需要進(jìn)行用戶合法性驗(yàn)證，只有合法的用戶才能執(zhí)行這些方法；又過了一段時(shí)間，客戶又提出方法 1、方法 2、方法 3 應(yīng)該增加日志記錄；又過了一段時(shí)間，客戶又提出……面對(duì)這樣的情況，我們怎么辦？通常有兩種做法：

根據(jù)需求說明書，直接拒絕客戶要求；擁抱需求，滿足客戶的需求。

***種做法顯然不好，客戶是上帝，我們應(yīng)該盡量滿足客戶的需求。通常會(huì)采用第二種做法，那如何解決呢？是不是每次先定義一個(gè)新方法，然后修改方法 1、方法 2、方法 3，增加調(diào)用新方法？這樣做的工作量也不小??！我們希望有一種特殊的方法：我們只要定義該方法，無須在方法 1、方法 2、方法 3 中顯式調(diào)用它，系統(tǒng)會(huì)“自動(dòng)”執(zhí)行該特殊方法。

上面想法聽起來很神奇，甚至有一些不切實(shí)際，但其實(shí)是完全可以實(shí)現(xiàn)的，實(shí)現(xiàn)這個(gè)需求的技術(shù)就是 AOP。AOP 專門用于處理系統(tǒng)中分布于各個(gè)模塊（不同方法）中的交叉關(guān)注點(diǎn)的問題，在 Java EE 應(yīng)用中，常常通過 AOP 來處理一些具有橫切性質(zhì)的系統(tǒng)級(jí)服務(wù)，如事務(wù)管理、安全檢查、緩存、對(duì)象池管理等，AOP 已經(jīng)成為一種非常常用的解決方案。

使用 AspectJ 的編譯時(shí)增強(qiáng)進(jìn)行 AOP

AspectJ 是一個(gè)基于 Java 語言的 AOP 框架，提供了強(qiáng)大的 AOP 功能，其他很多 AOP 框架都借鑒或采納其中的一些思想。

AspectJ 是 Java 語言的一個(gè) AOP 實(shí)現(xiàn)，其主要包括兩個(gè)部分：***個(gè)部分定義了如何表達(dá)、定義 AOP 編程中的語法規(guī)范，通過這套語言規(guī)范，我們可以方便地用 AOP 來解決 Java 語言中存在的交叉關(guān)注點(diǎn)問題；另一個(gè)部分是工具部分，包括編譯器、調(diào)試工具等。

AspectJ 是最早、功能比較強(qiáng)大的 AOP 實(shí)現(xiàn)之一，對(duì)整套 AOP 機(jī)制都有較好的實(shí)現(xiàn)，很多其他語言的 AOP 實(shí)現(xiàn)，也借鑒或采納了 AspectJ 中很多設(shè)計(jì)。在 Java 領(lǐng)域，AspectJ 中的很多語法結(jié)構(gòu)基本上已成為 AOP 領(lǐng)域的標(biāo)準(zhǔn)。

下載、安裝 AspectJ 比較簡單，讀者登錄 AspectJ 官網(wǎng)（http://www.eclipse.org/aspectj），即可下載到一個(gè)可執(zhí)行的 JAR 包，使用 java -jar aspectj-1.x.x.jar 命令、多次單擊“Next”按鈕即可成功安裝 AspectJ。

成功安裝了 AspectJ 之后，將會(huì)在 E:\Java\AOP\aspectj1.6 路徑下（AspectJ 的安裝路徑）看到如下文件結(jié)構(gòu)：

bin：該路徑下存放了 aj、aj5、ajc、ajdoc、ajbrowser 等命令，其中 ajc 命令最常用，它的作用類似于 javac，用于對(duì)普通 Java 類進(jìn)行編譯時(shí)增強(qiáng)。

docs：該路徑下存放了 AspectJ 的使用說明、參考手冊、API 文檔等文檔。

lib：該路徑下的 4 個(gè) JAR 文件是 AspectJ 的核心類庫。

相關(guān)授權(quán)文件。

一些文檔、AspectJ 入門書籍，一談到使用 AspectJ，就認(rèn)為必須使用 Eclipse 工具，似乎離開了該工具就無法使用 AspectJ 了。

雖然 AspectJ 是 Eclipse 基金組織的開源項(xiàng)目，而且提供了 Eclipse 的 AJDT 插件（AspectJ Development Tools）來開發(fā) AspectJ 應(yīng)用，但 AspectJ 絕對(duì)無須依賴于 Eclipse 工具。

實(shí)際上，AspectJ 的用法非常簡單，就像我們使用 JDK 編譯、運(yùn)行 Java 程序一樣。下面通過一個(gè)簡單的程序來示范 AspectJ 的用法，并分析 AspectJ 如何在編譯時(shí)進(jìn)行增強(qiáng)。

首先編寫一個(gè)簡單的 Java 類，這個(gè) Java 類用于模擬一個(gè)業(yè)務(wù)組件。

清單 1.Hello.java

public class Hello   
 {   
 // 定義一個(gè)簡單方法，模擬應(yīng)用中的業(yè)務(wù)邏輯方法  
 public void sayHello()  
   {  
   System.out.println("Hello AspectJ!");  
   }  
 // 主方法，程序的入口  
 public static void main(String[] args)   
 {   
 Hello h = new Hello();   
 h.sayHello();   
 }   
 } 

上面 Hello 類模擬了一個(gè)業(yè)務(wù)邏輯組件，編譯、運(yùn)行該 Java 程序，這個(gè)結(jié)果是沒有任何懸念的，程序?qū)⒃诳刂婆_(tái)打印“Hello AspectJ”字符串。

假設(shè)現(xiàn)在客戶需要在執(zhí)行 sayHello() 方法之前啟動(dòng)事務(wù)，當(dāng)該方法執(zhí)行結(jié)束時(shí)關(guān)閉事務(wù)，在傳統(tǒng)編程模式下，我們必須手動(dòng)修改 sayHello() 方法——如果改為使用 AspectJ，則可以無須修改上面的 sayHello() 方法。

下面我們定義一個(gè)特殊的 Java 類。

清單 2.TxAspect.java

public aspect TxAspect   
 {   
 // 指定執(zhí)行 Hello.sayHello() 方法時(shí)執(zhí)行下面代碼塊  
 void around():call(void Hello.sayHello())  
 {  
 System.out.println("開始事務(wù) ...");  
 proceed();  
 System.out.println("事務(wù)結(jié)束 ...");  
 }  
 } 

可能讀者已經(jīng)發(fā)現(xiàn)了，上面類文件中不是使用 class、interface、enum 在定義 Java 類，而是使用了 aspect ——難道 Java 語言又新增了關(guān)鍵字？沒有！上面的 TxAspect 根本不是一個(gè) Java 類，所以 aspect 也不是 Java 支持的關(guān)鍵字，它只是 AspectJ 才能識(shí)別的關(guān)鍵字。

上面粗體字代碼也不是方法，它只是指定當(dāng)程序執(zhí)行 Hello 對(duì)象的 sayHello() 方法時(shí)，系統(tǒng)將改為執(zhí)行粗體字代碼的花括號(hào)代碼塊，其中 proceed() 代表回調(diào)原來的 sayHello() 方法。

正如前面提到的，Java 無法識(shí)別 TxAspect.java 文件的內(nèi)容，所以我們要使用 ajc.exe 命令來編譯上面的 Java 程序。為了能在命令行使用 ajc.exe 命令，需要把 AspectJ 安裝目錄下的 bin 路徑（比如 E:\Java\AOP\aspectj1.6\bin 目錄）添加到系統(tǒng)的 PATH 環(huán)境變量中。接下來執(zhí)行如下命令進(jìn)行編譯：

ajc -d . Hello.java TxAspect.java

我們可以把 ajc.exe 理解成 javac.exe 命令，都用于編譯 Java 程序，區(qū)別是 ajc.exe 命令可識(shí)別 AspectJ 的語法；從這個(gè)意義上看，我們可以將 ajc.exe 當(dāng)成一個(gè)增強(qiáng)版的 javac.exe 命令。

運(yùn)行該 Hello 類依然無須任何改變，因?yàn)?Hello 類位于 lee 包下。程序使用如下命令運(yùn)行 Hello 類：java lee.Hello

運(yùn)行該程序，將看到一個(gè)令人驚喜的結(jié)果：

開始事務(wù) … Hello AspectJ! 事務(wù)結(jié)束 …

從上面運(yùn)行結(jié)果來看，我們完全可以不對(duì) Hello.java 類進(jìn)行任何修改，同時(shí)又可以滿足客戶的需求：上面程序只是在控制臺(tái)打印“開始事務(wù) …”、“結(jié)束事務(wù) …”來模擬了事務(wù)操作，實(shí)際上我們可用實(shí)際的事務(wù)操作代碼來代替這兩行簡單的語句，這就可以滿足客戶需求了。

如果客戶再次提出新需求，需要在 sayHello() 方法后增加記錄日志的功能，那也很簡單，我們再定義一個(gè) LogAspect，程序如下：

清單 3.LogAspect.java

public aspect LogAspect  
 {  
 // 定義一個(gè) PointCut，其名為 logPointcut  
 // 該 PointCut 對(duì)應(yīng)于指定 Hello 對(duì)象的 sayHello 方法  
     pointcut logPointcut() :execution(void Hello.sayHello());  
 // 在 logPointcut 之后執(zhí)行下面代碼塊  
     after():logPointcut()  
     {  
 System.out.println("記錄日志 ...");  
     }  
 } 

上面程序的粗體字代碼定義了一個(gè) Pointcut：logPointcut – 等同于執(zhí)行 Hello 對(duì)象的 sayHello() 方法，并指定在 logPointcut 之后執(zhí)行簡單的代碼塊，也就是說，在 sayHello() 方法之后執(zhí)行指定代碼塊。使用如下命令來編譯上面的 Java 程序：ajc -d . *.java

再次運(yùn)行 Hello 類，將看到如下運(yùn)行結(jié)果：

開始事務(wù) … Hello AspectJ! 記錄日志 … 事務(wù)結(jié)束 …

從上面運(yùn)行結(jié)果來看，通過使用 AspectJ 提供的 AOP 支持，我們可以為 sayHello() 方法不斷增加新功能。

為什么在對(duì) Hello 類沒有任何修改的前提下，而 Hello 類能不斷地、動(dòng)態(tài)增加新功能呢？這看上去并不符合 Java 基本語法規(guī)則啊。實(shí)際上我們可以使用 Java 的反編譯工具來反編譯前面程序生成的 Hello.class 文件，發(fā)現(xiàn) Hello.class 文件的代碼如下：

清單 4.Hello.class

package lee;   
 import java.io.PrintStream;   
 import org.aspectj.runtime.internal.AroundClosure;   
   
 public class Hello   
 {   
  public void sayHello()   
  {   
    try 
    {   
      System.out.println("Hello AspectJ!"); } catch (Throwable localThrowable) {   
      LogAspect.aspectOf().ajc$after$lee_LogAspect$1$9fd5dd97(); throw localThrowable; }   
      LogAspect.aspectOf().ajc$after$lee_LogAspect$1$9fd5dd97();   
  }   
  ...   
  private static final void sayHello_aroundBody1$advice(Hello target,   
             TxAspect ajc$aspectInstance, AroundClosure ajc$aroundClosure)   
  {   
    System.out.println("開始事務(wù) ...");   
    AroundClosure localAroundClosure = ajc$aroundClosure; sayHello_aroundBody0(target);   
    System.out.println("事務(wù)結(jié)束 ...");   
  }   
 } 

不難發(fā)現(xiàn)這個(gè) Hello.class 文件不是由原來的 Hello.java 文件編譯得到的，該 Hello.class 里新增了很多內(nèi)容——這表明 AspectJ 在編譯時(shí)“自動(dòng)”編譯得到了一個(gè)新類，這個(gè)新類增強(qiáng)了原有的 Hello.java 類的功能，因此 AspectJ 通常被稱為編譯時(shí)增強(qiáng)的 AOP 框架。

提示：與 AspectJ 相對(duì)的還有另外一種 AOP 框架，它們不需要在編譯時(shí)對(duì)目標(biāo)類進(jìn)行增強(qiáng)，而是運(yùn)行時(shí)生成目標(biāo)類的代理類，該代理類要么與目標(biāo)類實(shí)現(xiàn)相同的接口，要么是目標(biāo)類的子類——總之，代理類的實(shí)例可作為目標(biāo)類的實(shí)例來使用。一般來說，編譯時(shí)增強(qiáng)的 AOP 框架在性能上更有優(yōu)勢——因?yàn)檫\(yùn)行時(shí)動(dòng)態(tài)增強(qiáng)的 AOP 框架需要每次運(yùn)行時(shí)都進(jìn)行動(dòng)態(tài)增強(qiáng)。

實(shí)際上，AspectJ 允許同時(shí)為多個(gè)方法添加新功能，只要我們定義 Pointcut 時(shí)指定匹配更多的方法即可。如下片段：

pointcut xxxPointcut()   
     :execution(void H*.say*()); 

上面程序中的 xxxPointcut 將可以匹配所有以 H 開頭的類中、所有以 say 開頭的方法，但該方法返回的必須是 void；如果不想匹配任意的返回值類型，則可將代碼改為如下形式：

pointcut xxxPointcut()  
:execution(* H*.say*());xxxPointcut() 

關(guān)于如何定義 AspectJ 中的 Aspect、Pointcut 等，讀者可以參考 AspectJ 安裝路徑下的 doc 目錄里的 quick5.pdf 文件。

使用 Spring AOP

與 AspectJ 相同的是，Spring AOP 同樣需要對(duì)目標(biāo)類進(jìn)行增強(qiáng)，也就是生成新的 AOP 代理類；與 AspectJ 不同的是，Spring AOP 無需使用任何特殊命令對(duì) Java 源代碼進(jìn)行編譯，它采用運(yùn)行時(shí)動(dòng)態(tài)地、在內(nèi)存中臨時(shí)生成“代理類”的方式來生成 AOP 代理。

Spring 允許使用 AspectJ Annotation 用于定義方面（Aspect）、切入點(diǎn)（Pointcut）和增強(qiáng)處理（Advice），Spring 框架則可識(shí)別并根據(jù)這些 Annotation 來生成 AOP 代理。Spring 只是使用了和 AspectJ 5 一樣的注解，但并沒有使用 AspectJ 的編譯器或者織入器（Weaver），底層依然使用的是 Spring AOP，依然是在運(yùn)行時(shí)動(dòng)態(tài)生成 AOP 代理，并不依賴于 AspectJ 的編譯器或者織入器。

簡單地說，Spring 依然采用運(yùn)行時(shí)生成動(dòng)態(tài)代理的方式來增強(qiáng)目標(biāo)對(duì)象，所以它不需要增加額外的編譯，也不需要 AspectJ 的織入器支持；而 AspectJ 在采用編譯時(shí)增強(qiáng)，所以 AspectJ 需要使用自己的編譯器來編譯 Java 文件，還需要織入器。

為了啟用 Spring 對(duì) @AspectJ 方面配置的支持，并保證 Spring 容器中的目標(biāo) Bean 被一個(gè)或多個(gè)方面自動(dòng)增強(qiáng)，必須在 Spring 配置文件中配置如下片段：

<?xml version="1.0" encoding="GBK"?>   
 <beans   xmlns="http://www.springframework.org/schema/beans" 
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 xmlns:aop="http://www.springframework.org/schema/aop" 
xsi:schemaLocation="http://www.springframework.org/schema/beans   
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
http://www.springframework.org/schema/aop  
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">  
 <!-- 啟動(dòng) @AspectJ 支持 -->  
 <aop:aspectj-autoproxy/>   
 </beans> 

當(dāng)然，如果我們希望完全啟動(dòng) Spring 的“零配置”功能，則還需要啟用 Spring 的“零配置”支持，讓 Spring 自動(dòng)搜索指定路徑下 Bean 類。

所謂自動(dòng)增強(qiáng)，指的是 Spring 會(huì)判斷一個(gè)或多個(gè)方面是否需要對(duì)指定 Bean 進(jìn)行增強(qiáng)，并據(jù)此自動(dòng)生成相應(yīng)的代理，從而使得增強(qiáng)處理在合適的時(shí)候被調(diào)用。

如果不打算使用 Spring 的 XML Schema 配置方式，則應(yīng)該在 Spring 配置文件中增加如下片段來啟用 @AspectJ 支持。

<!-- 啟動(dòng) @AspectJ 支持 -->  
<bean/> 

上面配置文件中的 AnnotationAwareAspectJAutoProxyCreator 是一個(gè) Bean 后處理器（BeanPostProcessor），該 Bean 后處理器將會(huì)為容器中 Bean 生成 AOP 代理，

當(dāng)啟動(dòng)了 @AspectJ 支持后，只要我們在 Spring 容器中配置一個(gè)帶 @Aspect 注釋的 Bean，Spring 將會(huì)自動(dòng)識(shí)別該 Bean，并將該 Bean 作為方面 Bean 處理。

在 Spring 容器中配置方面 Bean（即帶 @Aspect 注釋的 Bean），與配置普通 Bean 沒有任何區(qū)別，一樣使用 <bean…/> 元素進(jìn)行配置，一樣支持使用依賴注入來配置屬性值；如果我們啟動(dòng)了 Spring 的“零配置”特性，一樣可以讓 Spring 自動(dòng)搜索，并裝載指定路徑下的方面 Bean。

使用 @Aspect 標(biāo)注一個(gè) Java 類，該 Java 類將會(huì)作為方面 Bean，如下面代碼片段所示：

// 使用 @Aspect 定義一個(gè)方面類  
 @Aspect 
 public class LogAspect   
 {   
 // 定義該類的其他內(nèi)容  
 ...   
 } 

方面類（用 @Aspect 修飾的類）和其他類一樣可以有方法、屬性定義，還可能包括切入點(diǎn)、增強(qiáng)處理定義。

當(dāng)我們使用 @Aspect 來修飾一個(gè) Java 類之后，Spring 將不會(huì)把該 Bean 當(dāng)成組件 Bean 處理，因此負(fù)責(zé)自動(dòng)增強(qiáng)的后處理 Bean 將會(huì)略過該 Bean，不會(huì)對(duì)該 Bean 進(jìn)行任何增強(qiáng)處理。

開發(fā)時(shí)無須擔(dān)心使用 @Aspect 定義的方面類被增強(qiáng)處理，當(dāng) Spring 容器檢測到某個(gè) Bean 類使用了 @Aspect 標(biāo)注之后，Spring 容器不會(huì)對(duì)該 Bean 類進(jìn)行增強(qiáng)。

下面將會(huì)考慮采用 Spring AOP 來改寫前面介紹的例子：

下面例子使用一個(gè)簡單的 Chinese 類來模擬業(yè)務(wù)邏輯組件：

清單 5.Chinese.java

@Component 
 public class Chinese  
 {  
 // 實(shí)現(xiàn) Person 接口的 sayHello() 方法  
     public String sayHello(String name)  
     {  
    System.out.println("-- 正在執(zhí)行 sayHello 方法 --");  
 // 返回簡單的字符串  
         return name + " Hello , Spring AOP";  
     }  
 // 定義一個(gè) eat() 方法  
     public void eat(String food)  
     {  
    System.out.println("我正在吃 :"+ food);  
     }  
 } 

提供了上面 Chinese 類之后，接下來假設(shè)同樣需要為上面 Chinese 類的每個(gè)方法增加事務(wù)控制、日志記錄，此時(shí)可以考慮使用 Around、AfterReturning 兩種增強(qiáng)處理。

先看 AfterReturning 增強(qiáng)處理代碼。

清單 6.AfterReturningAdviceTest.java

// 定義一個(gè)方面  
 @Aspect 
 public class AfterReturningAdviceTest   
 {   
 // 匹配 org.crazyit.app.service.impl 包下所有類的、  
 // 所有方法的執(zhí)行作為切入點(diǎn)  
 @AfterReturning(returning="rvt", pointcut="execution(* org.crazyit.app.service.impl.*.*(..))")  
 public void log(Object rvt)   
 {   
 System.out.println("獲取目標(biāo)方法返回值 :" + rvt);   
 System.out.println("模擬記錄日志功能 ...");   
 }   
 } 

上面 Aspect 類使用了 @Aspect 修飾，這樣 Spring 會(huì)將它當(dāng)成一個(gè)方面 Bean 進(jìn)行處理。其中程序中粗體字代碼指定將會(huì)在調(diào)用 org.crazyit.app.service.impl 包下的所有類的所有方法之后織入 log(Object rvt) 方法。

再看 Around 增強(qiáng)處理代碼：

清單 7.AfterReturningAdviceTest.java

// 定義一個(gè)方面  
 @Aspect 
 public class AroundAdviceTest  
 {  
 // 匹配 org.crazyit.app.service.impl 包下所有類的、  
 // 所有方法的執(zhí)行作為切入點(diǎn)  
 @Around("execution(* org.crazyit.app.service.impl.*.*(..))")  
 public Object processTx(ProceedingJoinPoint jp)  
 throws java.lang.Throwable  
 {  
 System.out.println("執(zhí)行目標(biāo)方法之前，模擬開始事務(wù) ...");  
 // 執(zhí)行目標(biāo)方法，并保存目標(biāo)方法執(zhí)行后的返回值  
 Object rvt = jp.proceed(new String[]{"被改變的參數(shù)"});  
 System.out.println("執(zhí)行目標(biāo)方法之后，模擬結(jié)束事務(wù) ...");  
 return rvt + " 新增的內(nèi)容";  
 }  
 } 

與前面的 AfterReturning 增強(qiáng)處理類似的，此處同樣使用了 @Aspect 來修飾前面 Bean，其中粗體字代碼指定在調(diào)用 org.crazyit.app.service.impl 包下的所有類的所有方法的“前后（Around）” 織入 processTx(ProceedingJoinPoint jp) 方法

需要指出的是，雖然此處只介紹了 Spring AOP 的 AfterReturning、Around 兩種增強(qiáng)處理，但實(shí)際上 Spring 還支持 Before、After、AfterThrowing 等增強(qiáng)處理，關(guān)于 Spring AOP 編程更多、更細(xì)致的編程細(xì)節(jié)，可以參考《輕量級(jí) Java EE 企業(yè)應(yīng)用實(shí)戰(zhàn)》一書。

本示例采用了 Spring 的零配置來開啟 Spring AOP，因此上面 Chinese 類使用了 @Component 修飾，而方面 Bean 則使用了 @Aspect 修飾，方面 Bean 中的 Advice 則分別使用了 @AfterReturning、@Around 修飾。接下來只要為 Spring 提供如下配置文件即可：

清單 8.bean.xml

<?xml version="1.0" encoding="GBK"?>  
 <beans xmlns="http://www.springframework.org/schema/beans" 
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:context="http://www.springframework.org/schema/context" 
xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/beans  
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
http://www.springframework.org/schema/context  
http://www.springframework.org/schema/context/spring-context-3.0.xsd  
http://www.springframework.org/schema/aop  
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">  
   
 <!-- 指定自動(dòng)搜索 Bean 組件、自動(dòng)搜索方面類 -->  
 <context:component-scan base-package="org.crazyit.app.service  
 ,org.crazyit.app.advice">  
 <context:include-filter type="annotation" 
 expression="org.aspectj.lang.annotation.Aspect"/>  
 </context:component-scan>  
 <!-- 啟動(dòng) @AspectJ 支持 -->  
 <aop:aspectj-autoproxy/>  
 </beans> 

接下來按傳統(tǒng)方式來獲取 Spring 容器中 chinese Bean、并調(diào)用該 Bean 的兩個(gè)方法，程序代碼如下：

清單 9.BeanTest.java

public class BeanTest   
 {   
 public static void main(String[] args)   
 {   
 // 創(chuàng)建 Spring 容器  
 ApplicationContext ctx = new 
 ClassPathXmlApplicationContext("bean.xml");   
 Chinese p = ctx.getBean("chinese" ,Chinese.class);   
 System.out.println(p.sayHello("張三"));   
 p.eat("西瓜");   
 }   
 } 

從上面開發(fā)過程可以看出，對(duì)于 Spring AOP 而言，開發(fā)者提供的業(yè)務(wù)組件、方面 Bean 并沒有任何特別的地方。只是方面 Bean 需要使用 @Aspect 修飾即可。程序不需要使用特別的編譯器、織入器進(jìn)行處理。

運(yùn)行上面程序，將可以看到如下執(zhí)行結(jié)果：

執(zhí)行目標(biāo)方法之前，模擬開始事務(wù) … – 正在執(zhí)行 sayHello 方法 – 執(zhí)行目標(biāo)方法之后，模擬結(jié)束事務(wù) … 獲取目標(biāo)方法返回值 : 被改變的參數(shù) Hello , Spring AOP 新增的內(nèi)容 模擬記錄日志功能 … 被改變的參數(shù) Hello , Spring AOP 新增的內(nèi)容 執(zhí)行目標(biāo)方法之前，模擬開始事務(wù) … 我正在吃 : 被改變的參數(shù) 執(zhí)行目標(biāo)方法之后，模擬結(jié)束事務(wù) … 獲取目標(biāo)方法返回值 :null 新增的內(nèi)容 模擬記錄日志功能 …

雖然程序是在調(diào)用 Chinese 對(duì)象的 sayHello、eat 兩個(gè)方法，但從上面運(yùn)行結(jié)果不難看出：實(shí)際執(zhí)行的絕對(duì)不是 Chinese 對(duì)象的方法，而是 AOP 代理的方法。也就是說，Spring AOP 同樣為 Chinese 類生成了 AOP 代理類。這一點(diǎn)可通過在程序中增加如下代碼看出：System.out.println(p.getClass());

上面代碼可以輸出 p 變量所引用對(duì)象的實(shí)現(xiàn)類，再次執(zhí)行程序?qū)⒖梢钥吹缴厦娲a產(chǎn)生 class org.crazyit.app.service.impl.Chinese$$EnhancerByCGLIB$$290441d2 的輸出，這才是 p 變量所引用的對(duì)象的實(shí)現(xiàn)類，這個(gè)類也就是 Spring AOP 動(dòng)態(tài)生成的 AOP 代理類。從 AOP 代理類的類名可以看出，AOP 代理類是由 CGLIB 來生成的。

如果將上面程序程序稍作修改：只要讓上面業(yè)務(wù)邏輯類 Chinese 類實(shí)現(xiàn)一個(gè)任意接口——這種做法更符合 Spring 所倡導(dǎo)的“面向接口編程”的原則。假設(shè)程序?yàn)?Chinese 類提供如下 Person 接口，并讓 Chinese 類實(shí)現(xiàn)該接口：

清單 10.Person.java

public interface Person  
 {  
 String sayHello(String name);  
 void eat(String food);  
 } 

接下來讓 BeanTest 類面向 Person 接口、而不是 Chinese 類編程。即將 BeanTest 類改為如下形式：

清單 11.BeanTest.java

public class BeanTest   
 {   
 public static void main(String[] args)   
 {   
 // 創(chuàng)建 Spring 容器  
 ApplicationContext ctx = new 
 ClassPathXmlApplicationContext("bean.xml");   
 Person p = ctx.getBean("chinese" ,Person.class);  
 System.out.println(p.sayHello("張三"));   
 p.eat("西瓜");   
 System.out.println(p.getClass());   
 }   
 } 

原來的程序是將面向 Chinese 類編程，現(xiàn)在將該程序改為面向 Person 接口編程，再次運(yùn)行該程序，程序運(yùn)行結(jié)果沒有發(fā)生改變。只是 System.out.println(p.getClass()); 將會(huì)輸出 class $Proxy7，這說明此時(shí)的 AOP 代理并不是由 CGLIB 生成的，而是由 JDK 動(dòng)態(tài)代理生成的。

Spring AOP 框架對(duì) AOP 代理類的處理原則是：如果目標(biāo)對(duì)象的實(shí)現(xiàn)類實(shí)現(xiàn)了接口，Spring AOP 將會(huì)采用 JDK 動(dòng)態(tài)代理來生成 AOP 代理類；如果目標(biāo)對(duì)象的實(shí)現(xiàn)類沒有實(shí)現(xiàn)接口，Spring AOP 將會(huì)采用 CGLIB 來生成 AOP 代理類——不過這個(gè)選擇過程對(duì)開發(fā)者完全透明、開發(fā)者也無需關(guān)心。

Spring AOP 會(huì)動(dòng)態(tài)選擇使用 JDK 動(dòng)態(tài)代理、CGLIB 來生成 AOP 代理，如果目標(biāo)類實(shí)現(xiàn)了接口，Spring AOP 則無需 CGLIB 的支持，直接使用 JDK 提供的 Proxy 和 InvocationHandler 來生成 AOP 代理即可。關(guān)于如何 Proxy 和 InvocationHandler 來生成動(dòng)態(tài)代理不在本文介紹范圍之內(nèi)，如果讀者對(duì) Proxy 和 InvocationHandler 的用法感興趣則可自行參考 Java API 文檔或《瘋狂 Java 講義》。

Spring AOP 原理剖析

通過前面介紹可以知道：AOP 代理其實(shí)是由 AOP 框架動(dòng)態(tài)生成的一個(gè)對(duì)象，該對(duì)象可作為目標(biāo)對(duì)象使用。AOP 代理包含了目標(biāo)對(duì)象的全部方法，但 AOP 代理中的方法與目標(biāo)對(duì)象的方法存在差異：AOP 方法在特定切入點(diǎn)添加了增強(qiáng)處理，并回調(diào)了目標(biāo)對(duì)象的方法.

AOP 代理所包含的方法與目標(biāo)對(duì)象的方法示意圖如圖 3 所示。

圖 3.AOP 代理的方法與目標(biāo)對(duì)象的方法

Spring AOP 實(shí)現(xiàn)原理與 CGLIB 應(yīng)用

Spring 的 AOP 代理由 Spring 的 IoC 容器負(fù)責(zé)生成、管理，其依賴關(guān)系也由 IoC 容器負(fù)責(zé)管理。因此，AOP 代理可以直接使用容器中的其他 Bean 實(shí)例作為目標(biāo)，這種關(guān)系可由 IoC 容器的依賴注入提供。

縱觀 AOP 編程，其中需要程序員參與的只有 3 個(gè)部分：

● 定義普通業(yè)務(wù)組件。

● 定義切入點(diǎn)，一個(gè)切入點(diǎn)可能橫切多個(gè)業(yè)務(wù)組件。

● 定義增強(qiáng)處理，增強(qiáng)處理就是在 AOP 框架為普通業(yè)務(wù)組件織入的處理動(dòng)作。

上面 3 個(gè)部分的***個(gè)部分是最平常不過的事情，無須額外說明。那么進(jìn)行 AOP 編程的關(guān)鍵就是定義切入點(diǎn)和定義增強(qiáng)處理。一旦定義了合適的切入點(diǎn)和增強(qiáng)處理，AOP 框架將會(huì)自動(dòng)生成 AOP 代理，而 AOP 代理的方法大致有如下公式：

代理對(duì)象的方法 = 增強(qiáng)處理 + 被代理對(duì)象的方法

在上面這個(gè)業(yè)務(wù)定義中，不難發(fā)現(xiàn) Spring AOP 的實(shí)現(xiàn)原理其實(shí)很簡單：AOP 框架負(fù)責(zé)動(dòng)態(tài)地生成 AOP 代理類，這個(gè)代理類的方法則由 Advice 和回調(diào)目標(biāo)對(duì)象的方法所組成。

對(duì)于前面提到的圖 2 所示的軟件調(diào)用結(jié)構(gòu)：當(dāng)方法 1、方法 2、方法 3 ……都需要去調(diào)用某個(gè)具有“橫切”性質(zhì)的方法時(shí)，傳統(tǒng)的做法是程序員去手動(dòng)修改方法 1、方法 2、方法 3 ……、通過代碼來調(diào)用這個(gè)具有“橫切”性質(zhì)的方法，但這種做法的可擴(kuò)展性不好，因?yàn)槊看味家拇a。

于是 AOP 框架出現(xiàn)了，AOP 框架則可以“動(dòng)態(tài)的”生成一個(gè)新的代理類，而這個(gè)代理類所包含的方法 1、方法 2、方法 3 ……也增加了調(diào)用這個(gè)具有“橫切”性質(zhì)的方法——但這種調(diào)用由 AOP 框架自動(dòng)生成的代理類來負(fù)責(zé)，因此具有了極好的擴(kuò)展性。程序員無需手動(dòng)修改方法 1、方法 2、方法 3 的代碼，程序員只要定義切入點(diǎn)即可—— AOP 框架所生成的 AOP 代理類中包含了新的方法 1、訪法 2、方法 3，而 AOP 框架會(huì)根據(jù)切入點(diǎn)來決定是否要在方法 1、方法 2、方法 3 中回調(diào)具有“橫切”性質(zhì)的方法。

簡而言之：AOP 原理的奧妙就在于動(dòng)態(tài)地生成了代理類，這個(gè)代理類實(shí)現(xiàn)了圖 2 的調(diào)用——這種調(diào)用無需程序員修改代碼。接下來介紹的 CGLIB 就是一個(gè)代理生成庫，下面介紹如何使用 CGLIB 來生成代理類。

使用 CGLIB 生成代理類

CGLIB（Code Generation Library），簡單來說，就是一個(gè)代碼生成類庫。它可以在運(yùn)行時(shí)候動(dòng)態(tài)是生成某個(gè)類的子類。

此處使用前面定義的 Chinese 類，現(xiàn)在改為直接使用 CGLIB 來生成代理，這個(gè)代理類同樣可以實(shí)現(xiàn) Spring AOP 代理所達(dá)到的效果。

下面先為 CGLIB 提供一個(gè)攔截器實(shí)現(xiàn)類：

清單 12.AroundAdvice.java

public class AroundAdvice implements MethodInterceptor   
 {   
 public Object intercept(Object target, Method method   
 , Object[] args, MethodProxy proxy)   
 throws java.lang.Throwable   
 {   
 System.out.println("執(zhí)行目標(biāo)方法之前，模擬開始事務(wù) ...");   
 // 執(zhí)行目標(biāo)方法，并保存目標(biāo)方法執(zhí)行后的返回值  
 Object rvt = proxy.invokeSuper(target, new String[]{"被改變的參數(shù)"});   
 System.out.println("執(zhí)行目標(biāo)方法之后，模擬結(jié)束事務(wù) ...");   
 return rvt + " 新增的內(nèi)容";   
 }   
 } 

上面這個(gè) AroundAdvice.java 的作用就像前面介紹的 Around Advice，它可以在調(diào)用目標(biāo)方法之前、調(diào)用目標(biāo)方法之后織入增強(qiáng)處理。

接下來程序提供一個(gè) ChineseProxyFactory 類，這個(gè) ChineseProxyFactory 類會(huì)通過 CGLIB 來為 Chinese 生成代理類：

清單 13.ChineseProxyFactory.java

public class ChineseProxyFactory   
{   
public static Chinese getAuthInstance()   
{   
Enhancer en = new Enhancer();   
// 設(shè)置要代理的目標(biāo)類  
en.setSuperclass(Chinese.class);  
// 設(shè)置要代理的攔截器  
en.setCallback(new AroundAdvice());  
// 生成代理類的實(shí)例   
return (Chinese)en.create();  
}   
} 

上面粗體字代碼就是使用 CGLIB 的 Enhancer 生成代理對(duì)象的關(guān)鍵代碼，此時(shí)的 Enhancer 將以 Chinese 類作為目標(biāo)類，以 AroundAdvice 對(duì)象作為“Advice”，程序?qū)?huì)生成一個(gè) Chinese 的子類，這個(gè)子類就是 CGLIB 生成代理類，它可作為 Chinese 對(duì)象使用，但它增強(qiáng)了 Chinese 類的方法。

測試 Chinese 代理類的主程序如下：

清單 14.Main.java

public class Main   
 {   
 public static void main(String[] args)   
 {   
 Chinese chin = ChineseProxyFactory.getAuthInstance();   
 System.out.println(chin.sayHello("孫悟空"));   
 chin.eat("西瓜");   
 System.out.println(chin.getClass());   
 }   
 } 

運(yùn)行上面主程序，看到如下輸出結(jié)果：

執(zhí)行目標(biāo)方法之前，模擬開始事務(wù) … – 正在執(zhí)行 sayHello 方法 – 執(zhí)行目標(biāo)方法之后，模擬結(jié)束事務(wù) … 被改變的參數(shù) Hello , CGLIB 新增的內(nèi)容 執(zhí)行目標(biāo)方法之前，模擬開始事務(wù) … 我正在吃 : 被改變的參數(shù) 執(zhí)行目標(biāo)方法之后，模擬結(jié)束事務(wù) … class lee.Chinese$$EnhancerByCGLIB$$4bd097d9

從上面輸出結(jié)果來看，CGLIB 生成的代理完全可以作為 Chinese 對(duì)象來使用，而且 CGLIB 代理對(duì)象的 sayHello()、eat() 兩個(gè)方法已經(jīng)增加了事務(wù)控制（只是模擬），這個(gè) CGLIB 代理其實(shí)就是 Spring AOP 所生成的 AOP 代理。

通過程序***的輸出，不難發(fā)現(xiàn)這個(gè)代理對(duì)象的實(shí)現(xiàn)類是 lee.Chinese$$EnhancerByCGLIB$$4bd097d9，這就是 CGLIB 所生成的代理類，這個(gè)代理類的格式與前面 Spring AOP 所生成的代理類的格式完全相同。

這就是 Spring AOP 的根本所在：Spring AOP 就是通過 CGLIB 來動(dòng)態(tài)地生成代理對(duì)象，這個(gè)代理對(duì)象就是所謂的 AOP 代理，而 AOP 代理的方法則通過在目標(biāo)對(duì)象的切入點(diǎn)動(dòng)態(tài)地織入增強(qiáng)處理，從而完成了對(duì)目標(biāo)方法的增強(qiáng)。

小結(jié)

AOP 廣泛應(yīng)用于處理一些具有橫切性質(zhì)的系統(tǒng)級(jí)服務(wù)，AOP 的出現(xiàn)是對(duì) OOP 的良好補(bǔ)充，它使得開發(fā)者能用更優(yōu)雅的方式處理具有橫切性質(zhì)的服務(wù)。不管是那種 AOP 實(shí)現(xiàn)，不論是 AspectJ、還是 Spring AOP，它們都需要?jiǎng)討B(tài)地生成一個(gè) AOP 代理類，區(qū)別只是生成 AOP 代理類的時(shí)機(jī)不同：AspectJ 采用編譯時(shí)生成 AOP 代理類，因此具有更好的性能，但需要使用特定的編譯器進(jìn)行處理；而 Spring AOP 則采用運(yùn)行時(shí)生成 AOP 代理類，因此無需使用特定編譯器進(jìn)行處理。由于 Spring AOP 需要在每次運(yùn)行時(shí)生成 AOP 代理，因此性能略差一些。

原文鏈接：http://www.ibm.com/developerworks/cn/java/j-lo-springaopcglib/index.html?ca=drs-

【編輯推薦】

1. Java環(huán)境變量Classpath
2. 8種常見的Java不規(guī)范代碼
3. Java多線程發(fā)展簡史
4. Java 動(dòng)態(tài)代理（Proxy）
5. 東方程序員怎么看西方程序員_開發(fā)技術(shù)周刊第069期