一、閑談AOP

大家都知道OOP，即ObjectOriented Programming，面向?qū)ο缶幊?。而本文要介紹的是AOP。AOP是Aspect Oriented Programming的縮寫，中譯文為面向切向編程。OOP和AOP是什么關(guān)系呢？

首先：

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

圖1  Android Framework中的模塊

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

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

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

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

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

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

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

• Activity的生命周期的幾個(gè)函數(shù)運(yùn)行時(shí)，要輸出日志。
• 幾個(gè)重要函數(shù)調(diào)用的時(shí)候，要檢查有沒有權(quán)限。

二、沒有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會(huì)檢查app是否申明了android.permission.READ_PHONE_STATE權(quán)限
 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();
 //調(diào)用PackageMangaer的checkPermission函數(shù)，檢查自己是否申明使用某權(quán)限
 int nret = pm.checkPermission(permissionName,getPackageName());
 return nret == PackageManager.PERMISSION_GRANTED;
 }......
 }
}

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

三、AspectJ介紹

3.1  AspectJ極簡(jiǎn)介

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

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

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

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

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

3.2  AspectJ語(yǔ)法

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

3.2.1  Join Points介紹

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

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

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

表1  AspectJ中的Join Point

表1列出了AspectJ所認(rèn)可的JoinPoints的類型。下面我們來看個(gè)例子以直觀體會(huì)一把。

圖2  示例代碼

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

圖3  所有的join points

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

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

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

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

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

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

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

好了。JPoint的介紹就先到此?，F(xiàn)在大家對(duì)JoinPoint應(yīng)該有了一個(gè)很直觀的體會(huì)，簡(jiǎn)單直白粗暴點(diǎn)說，JoinPoint就是一個(gè)程序中的關(guān)鍵函數(shù)（包括構(gòu)造函數(shù)）和代碼段（staticblock）。

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

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

3.2.2  Pointcuts介紹

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

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

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

pointcuttestAll():within(Test)。

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

（1） 一個(gè)Pointcuts例子

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

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

注意，aspectj的語(yǔ)法和Java一樣，只不過多了一些關(guān)鍵詞

我們來看看上述代碼

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

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

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

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

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

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

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

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

上例中的pointcut合起來就是：

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

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

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

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

看完例子，我們來講點(diǎn)理論。

（2） 直接針對(duì)JoinPoint的選擇

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

圖5  不同類型的JPoint對(duì)應(yīng)的pointcuts查詢方法

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

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

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

是不是很簡(jiǎn)單呢？

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

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

（3） 間接針對(duì)JPoint的選擇

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

特別強(qiáng)調(diào)，不論什么選擇方法，最終都是為了找到目標(biāo)的JPoint。

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

表2  其它常用選擇方法

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

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

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

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

圖6  示例代碼和輸出結(jié)果

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

3.2.3  advice和aspect介紹

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

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

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

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

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

表3  advice的類型

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

圖7  advice示例和結(jié)果

圖7中：

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

注意：從技術(shù)上說，around是完全可以替代before和after的。圖7中第二個(gè)紅框還把a(bǔ)fter給注釋掉了。如果不注釋掉，編譯時(shí)候報(bào)錯(cuò)，[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())（大家可以自己試試）。我猜測(cè)其中的原因是around和after沖突了。around本質(zhì)上代表了目標(biāo)JPoint，比如此處的testMethod。而after是testMethod之后執(zhí)行。那么這個(gè)testMethod到底是around還是原testMethod呢？真是傻傻分不清楚！

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

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

• AspectJ中各種類型的JoinPoint，JPoint是一個(gè)程序的關(guān)鍵執(zhí)行點(diǎn)，也是我們關(guān)注的重點(diǎn)。
• pointcuts：提供了一種方法來選擇目標(biāo)JPoint。程序有很多JPoint，但是需要一種方法來讓我們選擇我們關(guān)注的JPoint。這個(gè)方法就是利用pointcuts來完成的。
• 通過pointcuts選擇了目標(biāo)JPoint后，我們總得干點(diǎn)什么吧？這就用上了advice。advice包括好幾種類型，一般情況下都?jí)蛭覀冇昧恕?/li>

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

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

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

• 我們定義一個(gè)LogAspect，在LogAspect中，我們?cè)陉P(guān)鍵JPoint上設(shè)置advice，這些advice就是打印日志
• 再定義一個(gè)SecurityCheckAspect，在這個(gè)Aspect中，我們?cè)陉P(guān)鍵JPoint上設(shè)置advice，這些advice將檢查調(diào)用app是否有權(quán)限。

通過這種方式，我們?cè)谠瓉淼腏Point中，就不需要寫log打印的代碼，也不需要寫權(quán)限檢查的代碼了。所有這些關(guān)注點(diǎn)都挪到對(duì)應(yīng)的Aspectj文件中來控制。恩，這就是AOP的精髓。

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

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

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

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

（1） 參數(shù)傳遞

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

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

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

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

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

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

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

  注意，增加參數(shù)并不會(huì)影響pointcuts對(duì)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ù)傳進(jìn)去。
}

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

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

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

總結(jié)，參數(shù)傳遞其實(shí)并不復(fù)雜，關(guān)鍵是得記住語(yǔ)法：

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

（2） JoinPoint信息收集

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

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

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

四、使用AOP的例子

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

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

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

4.1  打印Log

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

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

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

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

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

圖8  AopDemoActivity執(zhí)行結(jié)果

4.2  檢查權(quán)限

4.2.1  使用注解

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

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

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

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

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

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

//為checkPhoneState使用SecurityCheckAnnotation注解，并指明調(diào)用該函數(shù)的人需要聲明的權(quán)限
 @SecurityCheckAnnotation(declaredPermission="android.permission.READ_PHONE_STATE")
 private void checkPhoneState(){
  //如果不使用AOP，就得自己來檢查權(quán)限
  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  檢查權(quán)限

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

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

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

圖9  權(quán)限檢查的例子

4.2.3  和其他模塊交互

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

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

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

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

恩，這其實(shí)是Aspect的真正作用，它負(fù)責(zé)收集Jpoint，設(shè)置advice。一些簡(jiǎn)單的功能可在Aspect中來完成，而一些復(fù)雜的功能，則只是有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í)行結(jié)果。

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

注意，

編譯：請(qǐng)?jiān)趗buntu下使用gradle assemble。編譯結(jié)果放在out/apps/目錄下。

五、其他、總結(jié)和參考文獻(xiàn)

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

5.1  AspectJ編譯

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

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

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

ajc函數(shù)其實(shí)和我們手動(dòng)試玩aspectj-test目標(biāo)一樣，只是我們沒有直接調(diào)用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。請(qǐng)根據(jù)自己java的版本合理設(shè)置它
      "-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é)的內(nèi)容。由于代碼已經(jīng)在csdn git上，大家下載過來直接用即可。

5.2  總結(jié)

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

最后再來看一個(gè)圖。

圖11 未使用AOP的情況

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

但是在右圖實(shí)現(xiàn)的時(shí)候，這三個(gè)模塊就攪在一起了。這和我們?cè)贏ndroidAopDemo中檢查權(quán)限的例子中完全一樣。在業(yè)務(wù)邏輯的時(shí)候，需要顯示調(diào)用安全檢查模塊。

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

5.3  參考文獻(xiàn)

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

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

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

Android中如何使用AspectJ，最重要的是它教會(huì)我們?cè)趺词褂胊spectj編譯工具API。

好了，以上就是這篇文章的全部?jī)?nèi)容了，希望本文的內(nèi)容對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，如果有疑問大家可以留言交流，謝謝大家對(duì)腳本之家的支持。