一、閑談AOP

大家都知道OOP，即ObjectOriented Programming，面向對象編程。而本文要介紹的是AOP。AOP是Aspect Oriented Programming的縮寫，中譯文為面向切向編程。OOP和AOP是什么關系呢？

首先：

• l OOP和AOP都是方法論。我記得在剛學習C++的時候，最難學的并不是C++的語法，而是C++所代表的那種看問題的方法，即OOP。同樣，今天在AOP中，我發(fā)現(xiàn)其難度并不在利用AOP干活，而是從AOP的角度來看待問題，設計解決方法。這就是為什么我特意強調AOP是一種方法論的原因！
• l 在OOP的世界中，問題或者功能都被劃分到一個一個的模塊里邊。每個模塊專心干自己的事情，模塊之間通過設計好的接口交互。從圖示來看，OOP世界中，最常見的表示比如：

圖1  Android Framework中的模塊

圖1中所示為AndroidFramework中的模塊。OOP世界中，大家畫的模塊圖基本上是這樣的，每個功能都放在一個模塊里。非常好理解，而且確實簡化了我們所處理問題的難度。

OOP的精髓是把功能或問題模塊化，每個模塊處理自己的家務事。但在現(xiàn)實世界中，并不是所有問題都能完美得劃分到模塊中。舉個最簡單而又常見的例子：現(xiàn)在想為每個模塊加上日志功能，要求模塊運行時候能輸出日志。在不知道AOP的情況下，一般的處理都是：先設計一個日志輸出模塊，這個模塊提供日志輸出API，比如Android中的Log類。然后，其他模塊需要輸出日志的時候調用Log類的幾個函數(shù)，比如e(TAG,...)，w(TAG,...)，d(TAG,...)，i(TAG,...)等。

在沒有接觸AOP之前，包括我在內，想到的解決方案就是上面這樣的。但是，從OOP角度看，除了日志模塊本身，其他模塊的家務事絕大部分情況下應該都不會包含日志輸出功能。什么意思？以ActivityManagerService為例，你能說它的家務事里包含日志輸出嗎？顯然，ActivityManagerService的功能點中不包含輸出日志這一項。但實際上，軟件中的眾多模塊確實又需要打印日志。這個日志輸出功能，從整體來看，都是一個面上的。而這個面的范圍，就不局限在單個模塊里了，而是橫跨多個模塊。

在沒有AOP之前，各個模塊要打印日志，就是自己處理。反正日志模塊的那幾個API都已經(jīng)寫好了，你在其他模塊的任何地方，任何時候都可以調用。功能是得到了滿足，但是好像沒有Oriented的感覺了。是的，隨意加日志輸出功能，使得其他模塊的代碼和日志模塊耦合非常緊密。而且，將來要是日志模塊修改了API，則使用它們的地方都得改。這種搞法，一點也不酷。

AOP的目標就是解決上面提到的不cool的問題。在AOP中：

• 第一，我們要認識到OOP世界中，有些功能是橫跨并嵌入眾多模塊里的，比如打印日志，比如統(tǒng)計某個模塊中某些函數(shù)的執(zhí)行時間等。這些功能在各個模塊里分散得很厲害，可能到處都能見到。
• 第二，AOP的目標是把這些功能集中起來，放到一個統(tǒng)一的地方來控制和管理。如果說，OOP如果是把問題劃分到單個模塊的話，那么AOP就是把涉及到眾多模塊的某一類問題進行統(tǒng)一管理。比如我們可以設計兩個Aspects，一個是管理某個軟件中所有模塊的日志輸出的功能，另外一個是管理該軟件中一些特殊函數(shù)調用的權限檢查。

講了這么多，還是先來看個例子。在這個例子中，我們要：

• Activity的生命周期的幾個函數(shù)運行時，要輸出日志。
• 幾個重要函數(shù)調用的時候，要檢查有沒有權限。

二、沒有AOP的例子

先來看沒有AOP的情況下，代碼怎么寫。主要代碼都在AopDemoActivity中

[-->AopDemoActivity.java]

public class AopDemoActivity extends Activity {
 private static final String TAG = "AopDemoActivity";
 onCreate，onStart,onRestart,onPause,onResume,onStop,onDestory返回前，都輸出一行日志
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.layout_main);
 Log.e(TAG,"onCreate");
 }
 protected void onStart() {
 super.onStart();
 Log.e(TAG, "onStart");
 }
 protected void onRestart() {
 super.onRestart();
 Log.e(TAG, "onRestart");
 }
 protectedvoid onResume() {
 super.onResume();
 Log.e(TAG, "onResume");
 checkPhoneState會檢查app是否申明了android.permission.READ_PHONE_STATE權限
 checkPhoneState();
 }
 protected void onPause() {
 super.onPause();
 Log.e(TAG, "onPause");
 }
 protected void onStop() {
 super.onStop();
 Log.e(TAG, "onStop");
 }
 protected void onDestroy() {
 super.onDestroy();
 Log.e(TAG, "onDestroy");
 }
 private void checkPhoneState(){
 if(checkPermission("android.permission.READ_PHONE_STATE")== false){
 Log.e(TAG,"have no permission to read phone state");
 return;
 }
 Log.e(TAG,"Read Phone State succeed");
 return;
 }
 private boolean checkPermission(String permissionName){
 try{
 PackageManager pm = getPackageManager();
 //調用PackageMangaer的checkPermission函數(shù)，檢查自己是否申明使用某權限
 int nret = pm.checkPermission(permissionName,getPackageName());
 return nret == PackageManager.PERMISSION_GRANTED;
 }......
 }
}

代碼很簡單。但是從這個小例子中，你也會發(fā)現(xiàn)要是這個程序比較復雜的話，到處都加Log，或者在某些特殊函數(shù)加權限檢查的代碼，真的是一件挺繁瑣的事情。

三、AspectJ介紹

3.1  AspectJ極簡介

AOP雖然是方法論，但就好像OOP中的Java一樣，一些先行者也開發(fā)了一套語言來支持AOP。目前用得比較火的就是AspectJ了，它是一種幾乎和Java完全一樣的語言，而且完全兼容Java（AspectJ應該就是一種擴展Java，但它不是像Groovy[1]那樣的拓展。）。當然，除了使用AspectJ特殊的語言外，AspectJ還支持原生的Java，只要加上對應的AspectJ注解就好。所以，使用AspectJ有兩種方法：

• 完全使用AspectJ的語言。這語言一點也不難，和Java幾乎一樣，也能在AspectJ中調用Java的任何類庫。AspectJ只是多了一些關鍵詞罷了。
• 或者使用純Java語言開發(fā)，然后使用AspectJ注解，簡稱@AspectJ。

Anyway，不論哪種方法，最后都需要AspectJ的編譯工具ajc來編譯。由于AspectJ實際上脫胎于Java，所以ajc工具也能編譯java源碼。

AspectJ現(xiàn)在托管于Eclipse項目中，官方網(wǎng)站是：

• http://www.eclipse.org/aspectj/   <=AspectJ官方網(wǎng)站
• http://www.eclipse.org/aspectj/doc/released/runtime-api/index.html  <=AspectJ類庫參考文檔，內容非常少
• http://www.eclipse.org/aspectj/doc/released/aspectj5rt-api/index.html  <=@AspectJ文檔，以后我們用Annotation的方式最多。

3.2  AspectJ語法

題外話：AspectJ東西比較多，但是AOP做為方法論，它的學習和體會是需要一步一步，并且一定要結合實際來的。如果一下子講太多，反而會疲倦。更可怕的是，有些膽肥的同學要是一股腦把所有高級玩法全弄上去，反而得不償失。這就是是方法論學習和其他知識學習不一樣的地方。請大家切記。

3.2.1  Join Points介紹

Join Points（以后簡稱JPoints）是AspectJ中最關鍵的一個概念。什么是JPoints呢？JPoints就是程序運行時的一些執(zhí)行點。那么，一個程序中，哪些執(zhí)行點是JPoints呢？比如：

• 一個函數(shù)的調用可以是一個JPoint。比如Log.e()這個函數(shù)。e的執(zhí)行可以是一個JPoint，而調用e的函數(shù)也可以認為是一個JPoint。
• 設置一個變量，或者讀取一個變量，也可以是一個JPoint。比如Demo類中有一個debug的boolean變量。設置它的地方或者讀取它的地方都可以看做是JPoints。
• for循環(huán)可以看做是JPoint。

理論上說，一個程序中很多地方都可以被看做是JPoint，但是AspectJ中，只有如表1所示的幾種執(zhí)行點被認為是JPoints：

表1  AspectJ中的Join Point

表1列出了AspectJ所認可的JoinPoints的類型。下面我們來看個例子以直觀體會一把。

圖2  示例代碼

圖2是一個Java示例代碼，下面我們將打印出其中所有的join points。圖3所示為打印出來的join points：

圖3  所有的join points

圖3中的輸出為從左到右，我們來解釋紅框中的內容。先來看左圖的第一個紅框：

• staticinitialization(test.Test.<clinit>)：表示當前是哪種類型的JPoint，括號中代表目標對象是誰（此處是指Test class的類初始化）。由于Test類沒有指定static block，所以后面的at:Test.java:0 表示代碼在第0行（其實就是沒有找到源代碼的意思）。
• Test類初始化完后，就該執(zhí)行main函數(shù)了。所以，下一個JPoint就是execution(voidtest.Test.main(String[]))。括號中表示此JPoint對應的是test.Test.main函數(shù)。at:Test.java:30表示這個JPoint在源代碼的第30行。大家可以對比圖2的源碼，很準確！
• main函數(shù)里首先是執(zhí)行System.out.println。而這一行代碼實際包括兩個JPoint。一個是get(PrintStream java.lang.System.out)，get表示Field get，它表示從System中獲取out對象。另外一個是call(void java.io.PrintStream.println(String))，這是一個call類型的JPoint，表示執(zhí)行out.println函數(shù)。

再來看左圖第二個紅框，它表示TestBase的類的初始化，由于源碼中為TestBase定義了static塊，所以這個JPoint清晰指出了源碼的位置是at:Test.java:5

接著看左圖第三個紅框，它和對象的初始化有關。在源碼中，我們只是構造了一個TestDerived對象。它會先觸發(fā)TestDerived Preinitialization JPoint，然后觸發(fā)基類TestBase的PreInitialization JPoint。注意紅框中的before和after 。在TestDerived和TestBase所對應的PreInitialization before和after中都沒有包含其他JPoint。所以，Pre-Initialization應該是構造函數(shù)中一個比較基礎的Phase。這個階段不包括類中成員變量定義時就賦值的操作，也不包括構造函數(shù)中對某些成員變量進行的賦值操作。

而成員變量的初始化（包括成員變量定義時就賦值的操作，比如源碼中的int base = 0，以及在構造函數(shù)中所做的賦值操作，比如源碼中的this.derived = 1000）都被囊括到initialization階段。請讀者對應圖三第二個紅框到第三個紅框（包括第3個紅框的內容）看看是不是這樣的。

最后來看第5個紅框。它包括三個JPoint：

• testMethod的call類型JPoint
• testMethod的execution類型JPonint
• 以及對異常捕獲的Handler類型JPoint

好了。JPoint的介紹就先到此。現(xiàn)在大家對JoinPoint應該有了一個很直觀的體會，簡單直白粗暴點說，JoinPoint就是一個程序中的關鍵函數(shù)（包括構造函數(shù)）和代碼段（staticblock）。

為什么AspectJ首先要定義好JoinPoint呢？大家仔細想想就能明白，以打印log的AopDemo為例，log在哪里打??？自然是在一些關鍵點去打印。而誰是關鍵點？AspectJ定義的這些類型的JPoint就能滿足我們絕大部分需求。

注意，要是想在一個for循環(huán)中打印一些日志，而AspectJ沒有這樣的JPoint，所以這個需求我們是無法利用AspectJ來實現(xiàn)了。另外，不同的軟件框架對表1中的JPoint類型支持也不同。比如Spring中，不是所有AspectJ支持的JPoint都有。

3.2.2  Pointcuts介紹

pointcuts這個單詞不好翻譯，此處直接用英文好了。那么，Pointcuts是什么呢？前面介紹的內容可知，一個程序會有很多的JPoints，即使是同一個函數(shù)（比如testMethod這個函數(shù)），還分為call類型和execution類型的JPoint。顯然，不是所有的JPoint，也不是所有類型的JPoint都是我們關注的。再次以AopDemo為例，我們只要求在Activity的幾個生命周期函數(shù)中打印日志，只有這幾個生命周期函數(shù)才是我們業(yè)務需要的JPoint，而其他的什么JPoint我不需要關注。

怎么從一堆一堆的JPoints中選擇自己想要的JPoints呢？恩，這就是Pointcuts的功能。一句話，Pointcuts的目標是提供一種方法使得開發(fā)者能夠選擇自己感興趣的JoinPoints。

在圖2的例子中，怎么把Test.java中所有的Joinpoint選擇出來呢？用到的pointcut格式為：

pointcuttestAll():within(Test)。

AspectJ中，pointcut有一套標準語法，涉及的東西很多，還有一些比較高級的玩法。我自己琢磨了半天，需不需要把這些內容一股腦都搬到此文呢？回想我自己學習AOP的經(jīng)歷，好像看了幾本書，記得比較清楚的都是簡單的case，而那些復雜的case則是到實踐中，確實有需求了，才回過頭來，重新查閱文檔來實施的。恩，那就一步一步來吧。

（1） 一個Pointcuts例子

直接來看一個例子，現(xiàn)在我想把圖2中的示例代碼中，那些調用println的地方找到，該怎么弄？代碼該這么寫：

public pointcut testAll(): call(public * *.println(..)) && !within(TestAspect) ;

注意，aspectj的語法和Java一樣，只不過多了一些關鍵詞

我們來看看上述代碼

  第一個public：表示這個pointcut是public訪問。這主要和aspect的繼承關系有關，屬于AspectJ的高級玩法，本文不考慮。

  pointcut：關鍵詞，表示這里定義的是一個pointcut。pointcut定義有點像函數(shù)定義?？傊?，在AspectJ中，你得定義一個pointcut。

  testAll()：pointcut的名字。在AspectJ中，定義Pointcut可分為有名和匿名兩種辦法。個人建議使用named方法。因為在后面，我們要使用一個pointcut的話，就可以直接使用它的名字就好。

  testAll后面有一個冒號，這是pointcut定義名字后，必須加上。冒號后面是這個pointcut怎么選擇Joinpoint的條件。

  本例中，call(public  *  *.println(..))是一種選擇條件。call表示我們選擇的Joinpoint類型為call類型。

  public  **.println(..)：這小行代碼使用了通配符。由于我們這里選擇的JoinPoint類型為call類型，它對應的目標JPoint一定是某個函數(shù)。所以我們要找到這個/些函數(shù)。public  表示目標JPoint的訪問類型（public/private/protect）。第一個*表示返回值的類型是任意類型。第二個*用來指明包名。此處不限定包名。緊接其后的println是函數(shù)名。這表明我們選擇的函數(shù)是任何包中定義的名字叫println的函數(shù)。當然，唯一確定一個函數(shù)除了包名外，還有它的參數(shù)。在(..)中，就指明了目標函數(shù)的參數(shù)應該是什么樣子的。比如這里使用了通配符..，代表任意個數(shù)的參數(shù)，任意類型的參數(shù)。

  再來看call后面的&&：AspectJ可以把幾個條件組合起來，目前支持 &&，||，以及！這三個條件。這三個條件的意思不用我說了吧？和Java中的是一樣的。

  來看最后一個!within(TestAspectJ)：前面的!表示不滿足某個條件。within是另外一種類型選擇方法，特別注意，這種類型和前面講到的joinpoint的那幾種類型不同。within的類型是數(shù)據(jù)類型，而joinpoint的類型更像是動態(tài)的，執(zhí)行時的類型。

上例中的pointcut合起來就是：

• 選擇那些調用println（而且不考慮println函數(shù)的參數(shù)是什么）的Joinpoint。
• 另外，調用者的類型不要是TestAspect的。

圖4展示了執(zhí)行結果：

圖4  新pointcut執(zhí)行結果

我在圖2所示的源碼中，為Test類定義了一個public static void println()函數(shù)，所以圖4的執(zhí)行結果就把這個println給匹配上了。

看完例子，我們來講點理論。

（2） 直接針對JoinPoint的選擇

pointcuts中最常用的選擇條件和Joinpoint的類型密切相關，比如圖5：

圖5  不同類型的JPoint對應的pointcuts查詢方法

以圖5為例，如果我們想選擇類型為methodexecution的JPoint，那么pointcuts的寫法就得包括execution(XXX)來限定。

除了指定JPoint類型外，我們還要更進一步選擇目標函數(shù)。選擇的根據(jù)就是圖5中列出的什么MethodSignature，ConstructorSignature，TypeSinature，F(xiàn)ieldSignature等。名字聽起來陌生得很，其實就是指定JPoint對應的函數(shù)（包括構造函數(shù)），Static block的信息。比如圖4中的那個println例子，首先它的JPoint類型是call，所以它的查詢條件是根據(jù)MethodSignature來表達。一個Method Signature的完整表達式為：

@注解 訪問權限 返回值的類型 包名.函數(shù)名(參數(shù))
  @注解和訪問權限（public/private/protect，以及static/final）屬于可選項。如果不設置它們，則默認都會選擇。以訪問權限為例，如果沒有設置訪問權限作為條件，那么public，private，protect及static、final的函數(shù)都會進行搜索。
  返回值類型就是普通的函數(shù)的返回值類型。如果不限定類型的話，就用*通配符表示
  包名.函數(shù)名用于查找匹配的函數(shù)?？梢允褂猛ㄅ浞?，包括*和..以及+號。其中*號用于匹配除.號之外的任意字符，而..則表示任意子package，+號表示子類。
     比如：
     java.*.Date：可以表示java.sql.Date，也可以表示java.util.Date
     Test*：可以表示TestBase，也可以表示TestDervied
     java..*：表示java任意子類
     java..*Model+：表示Java任意package中名字以Model結尾的子類，比如TabelModel，TreeModel
     等
  最后來看函數(shù)的參數(shù)。參數(shù)匹配比較簡單，主要是參數(shù)類型，比如：
     (int, char)：表示參數(shù)只有兩個，并且第一個參數(shù)類型是int，第二個參數(shù)類型是char
     (String, ..)：表示至少有一個參數(shù)。并且第一個參數(shù)類型是String，后面參數(shù)類型不限。在參數(shù)匹配中，
     ..代表任意參數(shù)個數(shù)和類型
     (Object ...)：表示不定個數(shù)的參數(shù)，且類型都是Object，這里的...不是通配符，而是Java中代表不定參數(shù)的意思

是不是很簡單呢？

Constructorsignature和Method Signature類似，只不過構造函數(shù)沒有返回值，而且函數(shù)名必須叫new。比如：
public *..TestDerived.new(..)：
  public：選擇public訪問權限
  *..代表任意包名
  TestDerived.new：代表TestDerived的構造函數(shù)
  (..)：代表參數(shù)個數(shù)和類型都是任意
再來看Field Signature和Type Signature，用它們的地方見圖5。下面直接上幾個例子：
Field Signature標準格式：
@注解 訪問權限 類型 類名.成員變量名
  其中，@注解和訪問權限是可選的
  類型：成員變量類型，*代表任意類型
  類名.成員變量名：成員變量名可以是*，代表任意成員變量
比如，
set(inttest..TestBase.base)：表示設置TestBase.base變量時的JPoint
Type Signature：直接上例子
staticinitialization(test..TestBase)：表示TestBase類的static block
handler(NullPointerException)：表示catch到NullPointerException的JPoint。注意，圖2的源碼第23行截獲的其實是Exception，其真實類型是NullPointerException。但是由于JPointer的查詢匹配是靜態(tài)的，即編譯過程中進行的匹配，所以handler(NullPointerException)在運行時并不能真正被截獲。只有改成handler(Exception)，或者把源碼第23行改成NullPointerException才行。

以上例子，讀者都可以在aspectj-test例子中自己都試試。

（3） 間接針對JPoint的選擇

除了根據(jù)前面提到的Signature信息來匹配JPoint外，AspectJ還提供其他一些選擇方法來選擇JPoint。比如某個類中的所有JPoint，每一個函數(shù)執(zhí)行流程中所包含的JPoint。

特別強調，不論什么選擇方法，最終都是為了找到目標的JPoint。

表2列出了一些常用的非JPoint選擇方法：

表2  其它常用選擇方法

上面這些東西，建議讀者：

• 進入androidaopdemo/aspectj-test目錄。
• 修改test/TestAspect.aj文件。主要是其中的pointcuts:testAll()這一行。按照圖2中的解釋說明，隨便改改試試。
• 執(zhí)行./create-jar.sh，得到一個test.jar包，然后java -jar test.jar得到執(zhí)行結果

注意：this()和target()匹配的時候不能使用通配符。

圖6給出了修改示例和輸出：

圖6  示例代碼和輸出結果

注意，不是所有的AOP實現(xiàn)都支持本節(jié)所說的查詢條件。比如Spring就不支持withincode查詢條件。

3.2.3  advice和aspect介紹

恭喜，看到這個地方來，AspectJ的核心部分就掌握一大部分了?，F(xiàn)在，我們知道如何通過pointcuts來選擇合適的JPoint。那么，下一步工作就很明確了，選擇這些JPoint后，我們肯定是需要干一些事情的。比如前面例子中的輸出都有before，after之類的。這其實JPoint在執(zhí)行前，執(zhí)行后，都執(zhí)行了一些我們設置的代碼。在AspectJ中，這段代碼叫advice。簡單點說，advice就是一種Hook。

ASpectJ中有好幾個Hook，主要是根據(jù)JPoint執(zhí)行時機的不同而不同，比如下面的：

before():testAll(){
 System.out.println("before calling: " + thisJoinPoint);//打印這個JPoint的信息
 System.out.println(" at:" + thisJoinPoint.getSourceLocation());//打印這個JPoint對應的源代碼位置
}

testAll()是前面定義的pointcuts，而before()定義了在這個pointcuts選中的JPoint執(zhí)行前我們要干的事情。

表3列出了AspectJ所支持的Advice的類型：

表3  advice的類型

注意，after和before沒有返回值，但是around的目標是替代原JPoint的，所以它一般會有返回值，而且返回值的類型需要匹配被選中的JPoint。我們來看個例子，見圖7。

圖7  advice示例和結果

圖7中：

• 第一個紅框是修改后的testMethod，在這個testMethod中，肯定會拋出一個空指針異常。
• 第二個紅框是我們配置的advice，除了before以外，還加了一個around。我們重點來看around，它的返回值是Object。雖然匹配的JPoint是testMethod，其定義的返回值是void。但是AspectJ考慮的很周到。在around里，可以設置返回值類型為Object來表示返回任意類型的返回值。AspectJ在真正返回參數(shù)的時候，會自動進行轉換。比如，假設inttestMethod定義了int作為返回值類型，我們在around里可以返回一個Integer，AspectJ會自動轉換成int作為返回值。
• 再看around中的//proceed()這句話。這代表調用真正的JPoint函數(shù)，即testMethod。由于這里我們屏蔽了proceed，所以testMethod真正的內容并未執(zhí)行，故運行的時候空指針異常就不會拋出來。也就是說，我們完全截獲了testMethod的運行，甚至可以任意修改它，讓它執(zhí)行別的函數(shù)都沒有問題。。

注意：從技術上說，around是完全可以替代before和after的。圖7中第二個紅框還把after給注釋掉了。如果不注釋掉，編譯時候報錯，[error]circular advice precedence: can't determine precedence between two or morepieces of advice that apply to the same join point: method-execution(voidtest.Test$TestDerived.testMethod())（大家可以自己試試）。我猜測其中的原因是around和after沖突了。around本質上代表了目標JPoint，比如此處的testMethod。而after是testMethod之后執(zhí)行。那么這個testMethod到底是around還是原testMethod呢？真是傻傻分不清楚！

（我覺得再加一些限制條件給after是可以避免這個問題的，但是沒搞成功...）

advice講完了。現(xiàn)在回顧下3.2節(jié)從開始到現(xiàn)在我們學到了哪些內容：

• AspectJ中各種類型的JoinPoint，JPoint是一個程序的關鍵執(zhí)行點，也是我們關注的重點。
• pointcuts：提供了一種方法來選擇目標JPoint。程序有很多JPoint，但是需要一種方法來讓我們選擇我們關注的JPoint。這個方法就是利用pointcuts來完成的。
• 通過pointcuts選擇了目標JPoint后，我們總得干點什么吧？這就用上了advice。advice包括好幾種類型，一般情況下都夠我們用了。

上面這些東西都有點像函數(shù)定義，在Java中，這些東西都是要放到一個class里的。在AspectJ中，也有類似的數(shù)據(jù)結構，叫aspect。

public aspect 名字 {//aspect關鍵字和class的功能一樣，文件名以.aj結尾
 pointcuts定義...
 advice定義...
}

你看，通過這種方式，定義一個aspect類，就把相關的JPoint和advice包含起來，是不是形成了一個“關注面”？比如：

• 我們定義一個LogAspect，在LogAspect中，我們在關鍵JPoint上設置advice，這些advice就是打印日志
• 再定義一個SecurityCheckAspect，在這個Aspect中，我們在關鍵JPoint上設置advice，這些advice將檢查調用app是否有權限。

通過這種方式，我們在原來的JPoint中，就不需要寫log打印的代碼，也不需要寫權限檢查的代碼了。所有這些關注點都挪到對應的Aspectj文件中來控制。恩，這就是AOP的精髓。

注意，讀者在把玩代碼時候，一定會碰到AspectJ語法不熟悉的問題。所以請讀者記得隨時參考官網(wǎng)的文檔。這里有一個官方的語法大全：

http://www.eclipse.org/aspectj/doc/released/quick5.pdf 或者官方的另外一個文檔也可以：

http://www.eclipse.org/aspectj/doc/released/progguide/semantics.html

3.2.4  參數(shù)傳遞和JPoint信息

（1） 參數(shù)傳遞

到此，AspectJ最基本的東西其實講差不多了，但是在實際使用AspectJ的時候，你會發(fā)現(xiàn)前面的內容還欠缺一點，尤其是advice的地方：

l 前面介紹的advice都是沒有參數(shù)信息的，而JPoint肯定是或多或少有參數(shù)的。而且advice既然是對JPoint的截獲或者hook也好，肯定需要利用傳入給JPoint的參數(shù)干點什么事情。比方所around advice，我可以對傳入的參數(shù)進行檢查，如果參數(shù)不合法，我就直接返回，根本就不需要調用proceed做處理。

往advice傳參數(shù)比較簡單，就是利用前面提到的this(),target(),args()等方法。另外，整個pointcuts和advice編寫的語法也有一些區(qū)別。具體方法如下：

  先在pointcuts定義時候指定參數(shù)類型和名字

pointcut testAll(Test.TestDerived derived,int x):call(*Test.TestDerived.testMethod(..))
  && target(derived)&& args(x)

  注意上述pointcuts的寫法，首先在testAll中定義參數(shù)類型和參數(shù)名。這一點和定義一個函數(shù)完全一樣

  接著看target和args。此處的target和args括號中用得是參數(shù)名。而參數(shù)名則是在前面pointcuts中定義好的。這屬于target和args的另外一種用法。

  注意，增加參數(shù)并不會影響pointcuts對JPoint的匹配，上面的pointcuts選擇和

pointcut testAll():call(*Test.TestDerived.testMethod(..)) && target(Test.TestDerived) &&args(int)是一樣的

只不過我們需要把參數(shù)傳入advice，才需要改造

接下來是修改advice：

Object around(Test.TestDerived derived,int x):testAll(derived,x){
 System.out.println(" arg1=" + derived);
 System.out.println(" arg2=" + x);
 return proceed(derived,x); //注意，proceed就必須把所有參數(shù)傳進去。
}

  advice的定義現(xiàn)在也和函數(shù)定義一樣，把參數(shù)類型和參數(shù)名傳進來。

  接著把參數(shù)名傳給pointcuts，此處是testAll。注意，advice必須和使用的pointcuts在參數(shù)類型和名字上保持一致。

  然后在advice的代碼中，你就可以引用參數(shù)了，比如derived和x，都可以打印出來。

總結，參數(shù)傳遞其實并不復雜，關鍵是得記住語法：

• pointcuts修改：像定義函數(shù)一樣定義pointcuts，然后在this,target或args中綁定參數(shù)名（注意，不再是參數(shù)類型，而是參數(shù)名）。
• advice修改：也像定義函數(shù)一樣定義advice，然后在冒號后面的pointcuts中綁定參數(shù)名（注意是參數(shù)名）
• 在advice的代碼中使用參數(shù)名。

（2） JoinPoint信息收集

我們前面示例中都打印出了JPoint的信息，比如當前調用的是哪個函數(shù)，JPoint位于哪一行代碼。這些都屬于JPoint的信息。AspectJ為我們提供如下信息：

• thisJoinpoint對象：在advice代碼中可直接使用。代表JPoint每次被觸發(fā)時的一些動態(tài)信息，比如參數(shù)啊之類的、
• thisJoinpointStatic對象：在advice代碼中可直接使用，代表JPoint中那些不變的東西。比如這個JPoint的類型，JPoint所處的代碼位置等。
• thisEnclosingJoinPointStaticPart對象：在advice代碼中可直接使用。也代表JPoint中不可變的部分，但是它包含的東西和JPoint的類型有關，比如對一個call類型JPoint而言，thisEnclosingJoinPointStaticPart代表包含調用這個JPoint的函數(shù)的信息。對一個handler類型的JPoint而言，它代表包含這個try/catch的函數(shù)的信息。

關于thisJoinpoint，建議大家直接查看API文檔，非常簡單。其地址位于http://www.eclipse.org/aspectj/doc/released/runtime-api/index.html。

四、使用AOP的例子

現(xiàn)在正式回到我們的AndroidAopDemo這個例子來。我們的目標是為AopDemoActivity的幾個Activity生命周期函數(shù)加上log，另外為checkPhoneState加上權限檢查。一切都用AOP來集中控制。

前面提到說AspectJ需要編寫aj文件，然后把AOP代碼放到aj文件中。但是在Android開發(fā)中，我建議不要使用aj文件。因為aj文件只有AspectJ編譯器才認識，而Android編譯器不認識這種文件。所以當更新了aj文件后，編譯器認為源碼沒有發(fā)生變化，所以不會編譯它。

當然，這種問題在其他不認識aj文件的java編譯環(huán)境中也存在。所以，AspectJ提供了一種基于注解的方法來把AOP實現(xiàn)到一個普通的Java文件中。這樣我們就把AOP當做一個普通的Java文件來編寫、編譯就好。

4.1  打印Log

馬上來看AopDemoActivity對應的DemoAspect.java文件吧。先看輸出日志第一版本：

[-->第一版本]

package com.androidaop.demo;
import android.util.Log;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.JoinPoint;
 
@Aspect //必須使用@AspectJ標注，這樣class DemoAspect就等同于 aspect DemoAspect了
public class DemoAspect {
 staticfinal String TAG = "DemoAspect";
/*
@Pointcut：pointcut也變成了一個注解，這個注解是針對一個函數(shù)的，比如此處的logForActivity()
其實它代表了這個pointcut的名字。如果是帶參數(shù)的pointcut，則把參數(shù)類型和名字放到
代表pointcut名字的logForActivity中，然后在@Pointcut注解中使用參數(shù)名。
基本和以前一樣，只是寫起來比較奇特一點。后面我們會介紹帶參數(shù)的例子
*/
@Pointcut("execution(* com.androidaop.demo.AopDemoActivity.onCreate(..)) ||"
  +"execution(* com.androidaop.demo.AopDemoActivity.onStart(..))")
public void logForActivity(){}; //注意，這個函數(shù)必須要有實現(xiàn)，否則Java編譯器會報錯
 
/*
@Before：這就是Before的advice，對于after，after -returning，和after-throwing。對于的注解格式為
@After，@AfterReturning，@AfterThrowing。Before后面跟的是pointcut名字，然后其代碼塊由一個函數(shù)來實現(xiàn)。比如此處的log。
*/
 @Before("logForActivity()")
 public void log(JoinPoint joinPoint){
  //對于使用Annotation的AspectJ而言，JoinPoint就不能直接在代碼里得到多了，而需要通過
  //參數(shù)傳遞進來。
  Log.e(TAG, joinPoint.toShortString());
 }
}

提示：如果開發(fā)者已經(jīng)切到AndroidStudio的話，AspectJ注解是可以被識別并能自動補齊。

上面的例子僅僅是列出了onCreate和onStart兩個函數(shù)的日志，如果想在所有的onXXX這樣的函數(shù)里加上log，該怎么改呢？

@Pointcut("execution(* *..AopDemoActivity.on*(..))")
public void logForActivity(){};

圖8給出這個例子的執(zhí)行結果：

圖8  AopDemoActivity執(zhí)行結果

4.2  檢查權限

4.2.1  使用注解

檢查權限這個功能的實現(xiàn)也可以采用剛才打印log那樣，但是這樣就沒有太多意思了。我們玩點高級的。不過這個高級的玩法也是來源于現(xiàn)實需求：

• 權限檢查一般是針對API的，比如調用者是否有權限調用某個函數(shù)。
• API往往是通過SDK發(fā)布的。一般而言，我們會在這個函數(shù)的注釋里說明需要調用者聲明哪些權限。
• 然后我們在API檢查調用者是不是申明了文檔中列出的權限。

如果我有10個API，10個不同的權限，那么在10個函數(shù)的注釋里都要寫，太麻煩了。怎么辦？這個時候我想到了注解。注解的本質是源代碼的描述。權限聲明，從語義上來說，其實是屬于API定義的一部分，二者是一個統(tǒng)一體，而不是分離的。

Java提供了一些默認的注解，不過此處我們要使用自己定義的注解：

package com.androidaop.demo;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
//第一個@Target表示這個注解只能給函數(shù)使用
//第二個@Retention表示注解內容需要包含的Class字節(jié)碼里，屬于運行時需要的。
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface SecurityCheckAnnotation {//@interface用于定義一個注解。
 publicString declaredPermission(); //declarePermssion是一個函數(shù)，其實代表了注解里的參數(shù)
}

怎么使用注解呢？接著看代碼：

//為checkPhoneState使用SecurityCheckAnnotation注解，并指明調用該函數(shù)的人需要聲明的權限
 @SecurityCheckAnnotation(declaredPermission="android.permission.READ_PHONE_STATE")
 private void checkPhoneState(){
  //如果不使用AOP，就得自己來檢查權限
  if(checkPermission("android.permission.READ_PHONE_STATE") ==false){
   Log.e(TAG,"have no permission to read phone state");
   return;
  }
  Log.e(TAG,"Read Phone State succeed");
  return;
 }

4.2.2  檢查權限

下面，我們來看看如何在AspectJ中，充分利用這注解信息來幫助我們檢查權限。

/*
來看這個Pointcut，首先，它在選擇Jpoint的時候，把@SecurityCheckAnnotation使用上了，這表明所有那些public的，并且攜帶有這個注解的API都是目標JPoint
接著，由于我們希望在函數(shù)中獲取注解的信息，所有這里的poincut函數(shù)有一個參數(shù)，參數(shù)類型是
SecurityCheckAnnotation，參數(shù)名為ann
這個參數(shù)我們需要在后面的advice里用上，所以pointcut還使用了@annotation(ann)這種方法來告訴
AspectJ，這個ann是一個注解
*/
 @Pointcut("execution(@SecurityCheckAnnotation public * *..*.*(..)) && @annotation(ann)")
 publicvoid checkPermssion(SecurityCheckAnnotationann){};
 
/*
接下來是advice，advice的真正功能由check函數(shù)來實現(xiàn)，這個check函數(shù)第二個參數(shù)就是我們想要
的注解。在實際運行過程中，AspectJ會把這個信息從JPoint中提出出來并傳遞給check函數(shù)。
*/
 @Before("checkPermssion(securityCheckAnnotation)")
 publicvoid check(JoinPoint joinPoint,SecurityCheckAnnotationsecurityCheckAnnotation){
  //從注解信息中獲取聲明的權限。
  String neededPermission = securityCheckAnnotation.declaredPermission();
  Log.e(TAG, joinPoint.toShortString());
  Log.e(TAG, "\tneeded permission is " + neededPermission);
  return;
 }

如此這般，我們在API源碼中使用的注解信息，現(xiàn)在就可以在AspectJ中使用了。這樣，我們在源碼中定義注釋，然后利用AspectJ來檢查。圖9展示了執(zhí)行的結果

圖9  權限檢查的例子

4.2.3  和其他模塊交互

事情這樣就完了？很明顯沒有。為什么？剛才權限檢查只是簡單得打出了日志，但是并沒有真正去做權限檢查。如何處理？這就涉及到AOP如何與一個程序中其他模塊交互的問題了。初看起來容易，其實有難度。

比如，DemoAspect雖然是一個類，但是沒有構造函數(shù)。而且，我們也沒有在代碼中主動去構造它。根據(jù)AsepctJ的說明，DemoAspect不需要我們自己去構造，AspectJ在編譯的時候會把構造函數(shù)給你自動加上。具體在程序什么位置加上，其實是有規(guī)律的，但是我們并不知道，也不要去知道。

這樣的話，DemoAspect豈不是除了打打log就沒什么作用了？非也！以此例的權限檢查為例，我們需要：

• 把真正進行權限檢查的地方封裝到一個模塊里，比如SecurityCheck中。
• SecurityCheck往往在一個程序中只會有一個實例。所以可以為它提供一個函數(shù)，比如getInstance以獲取SecurityCheck實例對象。
• 我們就可以在DemoAspect中獲取這個對象，然后調用它的check函數(shù)，把最終的工作由SecurityCheck來檢查了。

恩，這其實是Aspect的真正作用，它負責收集Jpoint，設置advice。一些簡單的功能可在Aspect中來完成，而一些復雜的功能，則只是有Aspect來統(tǒng)一收集信息，并交給專業(yè)模塊來處理。

最終代碼：

 @Before("checkPermssion(securityCheckAnnotation)")
 publicvoid check(JoinPoint joinPoint,SecurityCheckAnnotation securityCheckAnnotation){
  String neededPermission = securityCheckAnnotation.declaredPermission();
  Log.e(TAG, "\tneeded permission is " + neededPermission);
  SecurityCheckManager manager =SecurityCheckManager.getInstanc();
  if(manager.checkPermission(neededPermission) == false){
   throw new SecurityException("Need to declare permission:" + neededPermission);
  }
  return;
 }

圖10所示為最終的執(zhí)行結果。

圖10  執(zhí)行真正的權限檢查

注意，

編譯：請在ubuntu下使用gradle assemble。編譯結果放在out/apps/目錄下。

五、其他、總結和參考文獻

最后我們來講講其他一些內容。首先是AspectJ的編譯。

5.1  AspectJ編譯

• AspectJ比較強大，除了支持對source文件（即aj文件、或@AspectJ注解的Java文件，或普通java文件）直接進行編譯外，
• 還能對Java字節(jié)碼（即對class文件）進行處理。有感興趣的同學可以對aspectj-test小例子的class文件進行反編譯，你會發(fā)現(xiàn)AspectJ無非是在被選中的JPoint的地方加一些hook函數(shù)。當然Before就是在調用JPoint之前加，After就是在JPoint返回之前加。
• 更高級的做法是當class文件被加載到虛擬機后，由虛擬機根據(jù)AOP的規(guī)則進行hook。

在Android里邊，我們用得是第二種方法，即對class文件進行處理。來看看代碼：

//AndroidAopDemo.build.gradle
//此處是編譯一個App，所以使用的applicationVariants變量，否則使用libraryVariants變量
//這是由Android插件引入的。所以，需要import com.android.build.gradle.AppPlugin;
android.applicationVariants.all { variant ->
 /*
  這段代碼之意是：
  當app編譯個每個variant之后，在javaCompile任務的最后添加一個action。此action
  調用ajc函數(shù)，對上一步生成的class文件進行aspectj處理。
 */
 AppPluginplugin = project.plugins.getPlugin(AppPlugin)
 JavaCompile javaCompile = variant.javaCompile
 javaCompile.doLast{
  String bootclasspath =plugin.project.android.bootClasspath.join(File.pathSeparator)
  //ajc是一個函數(shù)，位于utils.gradle中
  ajc(bootclasspath,javaCompile)
 }
}

ajc函數(shù)其實和我們手動試玩aspectj-test目標一樣，只是我們沒有直接調用ajc命令，而是利用AspectJ提供的API做了和ajc命令一樣的事情。

import org.aspectj.bridge.IMessage
import org.aspectj.bridge.MessageHandler
import org.aspectj.tools.ajc.Main
 
def ajc(String androidbootClassFiles,JavaCompile javaCompile){
 String[] args = ["-showWeaveInfo",
      "-1.8", //1.8是為了兼容java 8。請根據(jù)自己java的版本合理設置它
      "-inpath",javaCompile.destinationDir.toString(),
      "-aspectpath",javaCompile.classpath.asPath,
      "-d",javaCompile.destinationDir.toString(),
      "-classpath",javaCompile.classpath.asPath,
     "-bootclasspath", androidbootClassFiles]
 MessageHandlerhandler = new MessageHandler(true);
 new Main().run(args,handler)
 
 deflog = project.logger
 for(IMessage message : handler.getMessages(null, true)) {
  switch (message.getKind()) {
  case IMessage.ABORT:
  case IMessage.ERROR:
  case IMessage.FAIL:
   log.error message.message, message.thrown
   throw message.thrown
   break;
  case IMessage.WARNING:
  case IMessage.INFO:
   log.info message.message, message.thrown
   break;
  case IMessage.DEBUG:
   log.debug message.message, message.thrown
   break;
  }
 }
 }

主要利用了https://eclipse.org/aspectj/doc/released/devguide/ajc-ref.html中TheAspectJ compiler API一節(jié)的內容。由于代碼已經(jīng)在csdn git上，大家下載過來直接用即可。

5.2  總結

除了hook之外，AspectJ還可以為目標類添加變量。另外，AspectJ也有抽象，繼承等各種更高級的玩法。根據(jù)本文前面的介紹，這些高級玩法一定要靠需求來驅動。AspectJ肯定對原程序是有影響的，如若貿然使用高級用法，則可能帶來一些未知的后果。關于這些內容，讀者根據(jù)情況自行閱讀文后所列的參考文獻。

最后再來看一個圖。

圖11 未使用AOP的情況

圖11中，左邊是一個程序的三個基于OOP而劃分的模塊（也就是concern）。安全、業(yè)務邏輯、交易管理。這三個模塊在設計圖上一定是互相獨立，互不干擾的。

但是在右圖實現(xiàn)的時候，這三個模塊就攪在一起了。這和我們在AndroidAopDemo中檢查權限的例子中完全一樣。在業(yè)務邏輯的時候，需要顯示調用安全檢查模塊。

自從有了AOP，我們就可以去掉業(yè)務邏輯中顯示調用安全檢查的內容，使得代碼歸于干凈，各個模塊又能各司其職。而這之中千絲萬縷的聯(lián)系，都由AOP來連接和管理，豈不美哉？！

5.3  參考文獻

[1]  Manning.AspectJ.in.Action第二版

看書還是要挑簡單易懂的，AOP概念并不復雜，而AspectJ也有很多書，但是真正寫得通俗易懂的就是這本，雖然它本意是介紹Spring中的AOP，但對AspectJ的解釋真得是非常到位，而且還有對@AspectJ注解的介紹。本文除第一個圖外，其他參考用圖全是來自于此書。

[2]  http://fernandocejas.com/2014/08/03/aspect-oriented-programming-in-android/

Android中如何使用AspectJ，最重要的是它教會我們怎么使用aspectj編譯工具API。

好了，以上就是這篇文章的全部內容了，希望本文的內容對大家的學習或者工作具有一定的參考學習價值，如果有疑問大家可以留言交流，謝謝大家對腳本之家的支持。

最新評論