看AspectJ在Android中的強勢插入

JulHlw 7年前發布 | 25K 次閱讀 AspectJ 安卓開發 Android開發 移動開發

什么是AOP

AOP是Aspect Oriented Programming的縮寫，即『面向切面編程』。它和我們平時接觸到的OOP都是編程的不同思想，OOP，即『面向對象編程』，它提倡的是將功能模塊化，對象化，而AOP的思想，則不太一樣，它提倡的是針對同一類問題的統一處理，當然，我們在實際編程過程中，不可能單純的安裝AOP或者OOP的思想來編程，很多時候，可能會混合多種編程思想，大家也不必要糾結該使用哪種思想，取百家之長，才是正道。

那么AOP這種編程思想有什么用呢，一般來說，主要用于不想侵入原有代碼的場景中，例如SDK需要無侵入的在宿主中插入一些代碼，做日志埋點、性能監控、動態權限控制、甚至是代碼調試等等。

AspectJ

AspectJ實際上是對AOP編程思想的一個實踐，當然，除了AspectJ以外，還有很多其它的AOP實現，例如ASMDex，但目前最好、最方便的，依然是AspectJ。

在Android項目中使用AspectJ

AOP的用處非常廣，從Spring到Android，各個地方都有使用，特別是在后端，Spring中已經使用的非常方便了，而且功能非常強大，但是在Android中，AspectJ的實現是略閹割的版本，并不是所有功能都支持，但對于一般的客戶端開發來說，已經完全足夠用了。

在Android上集成AspectJ實際上是比較復雜的，不是一句話就能compile，但是，鄙司已經給大家把這個問題解決了，大家現在直接使用這個SDK就可以很方便的在Android Studio中使用AspectJ了。

接入說明

首先，需要在項目根目錄的build.gradle中增加依賴：

classpath 'com.hujiang.aspectjx:gradle-android-plugin-aspectjx:1.0.8'

完整代碼如下：

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:2.3.0-beta2'
        classpath 'com.hujiang.aspectjx:gradle-android-plugin-aspectjx:1.0.8'



    // NOTE: Do not place your application dependencies here; they belong
    // in the individual module build.gradle files
}



}</code></pre> 
  
然后再主項目或者庫的build.gradle中增加AspectJ的依賴：
 
  
compile 'org.aspectj:aspectjrt:1.8.9'
 
  
同時在build.gradle中加入AspectJX模塊：
 
  
apply plugin: 'android-aspectjx'
 
  
這樣就把整個Android Studio中的AspectJ的環境配置完畢了，如果在編譯的時候，遇到一些『can’t determine superclass of missing type xxxxx』這樣的錯誤，請參考項目README中關于excludeJarFilter的使用。
 
  
aspectjx {
    //includes the libs that you want to weave
    includeJarFilter 'universal-image-loader', 'AspectJX-Demo/library'



//excludes the libs that you don't want to weave
excludeJarFilter 'universal-image-loader'



}</code></pre> 
  
AspectJ入門
 
  
我們通過一段簡單的代碼來了解下基本的使用方法和功能，新建一個AspectTest類文件，代碼如下：
 
  
@Aspect
public class AspectTest {



private static final String TAG = "xuyisheng";

@Before("execution(* android.app.Activity.on**(..))")
public void onActivityMethodBefore(JoinPoint joinPoint) throws Throwable {
    String key = joinPoint.getSignature().toString();
    Log.d(TAG, "onActivityMethodBefore: " + key);
}



}</code></pre> 
  
在類的最開始，我們使用@Aspect注解來定義這樣一個AspectJ文件，編譯器在編譯的時候，就會自動去解析，并不需要主動去調用AspectJ類里面的代碼。
 
  
我的原始代碼很簡單：
 
  
public class MainActivity extends AppCompatActivity {



@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
}



}</code></pre> 
  
通過這種方式編譯后，我們來看下生成的代碼是怎樣的。AspectJ的原理實際上是在編譯的時候，根據一定的規則解析，然后插入一些代碼，通過aspectjx生成的代碼，會在Build目錄下：
 
  
 
  
通過反編譯工具查看下生成內容：
 
  
 
  
我們可以發現，在onCreate的最前面，插入了一行AspectJ的代碼。這個就是AspectJ的主要功能，拋開AOP的思想來說，我們想做的，實際上就是『在不侵入原有代碼的基礎上，增加新的代碼』。
 
  
AspectJ之Join Points
 
  
Join Points，簡稱JPoints，是AspectJ的核心思想之一，它就像一把刀，把程序的整個執行過程切成了一段段不同的部分。例如，構造方法調用、調用方法、方法執行、異常等等，這些都是Join Points，實際上，也就是你想把新的代碼插在程序的哪個地方，是插在構造方法中，還是插在某個方法調用前，或者是插在某個方法中，這個地方就是Join Points，當然，不是所有地方都能給你插的，只有能插的地方，才叫Join Points。
 
  
AspectJ之Pointcuts
 
  
Join Points和Pointcuts的區別實際上很難說，我也不敢說我理解的一定對，但這些都是概念上的內容，并不影響我們去使用。
 
  
Pointcuts，在我理解，實際上就是在Join Points中通過一定條件選擇出我們所需要的Join Points，所以說，Pointcuts，也就是帶條件的Join Points，作為我們需要的代碼切入點。
 
  
AspectJ之Advice
 
  
又來一個Advice，Advice其實是最好理解的，也就是我們具體插入的代碼，以及如何插入這些代碼。我們最開始舉的那個例子，里面就是使用的最簡單的Advice——Before。類似的還有After、Around，我們后面來講講他們的區別。
 
  
AspectJ之切點語法
 
  
我們以前面的Demo來看下最簡單的AspectJ語法：
 
  
@Before("execution(* android.app.Activity.on**(..))")
public void onActivityMethodBefore(JoinPoint joinPoint) throws Throwable {
}
 
  
這里會分成幾個部分，我們依次來看：
 
  
     
   
  • @Before：Advice，也就是具體的插入點
    •  
   
  • execution：處理Join Point的類型，例如call、execution
    •  
   
  • (* android.app.Activity.on**(..))：這個是最重要的表達式，第一個『*』表示返回值，『*』表示返回值為任意類型，后面這個就是典型的包名路徑，其中可以包含『*』來進行通配，幾個『*』沒區別。同時，這里可以通過『&&、||、!』來進行條件組合。()代表這個方法的參數，你可以指定類型，例如android.os.Bundle，或者(..)這樣來代表任意類型、任意個數的參數。
    •  
   
  • public void onActivityMethodBefore：實際切入的代碼。
    •  
  
 
  
這里還有一些匹配規則，可以作為示例來進行講解：
 
  
 
    
    
 
     表達式 
     含義 
    
 
    
    
    
 
     java.lang.String 
     匹配String類型 
    
 
    
 
     java.*.String 
     匹配java包下的任何“一級子包”下的String類型，如匹配java.lang.String，但不匹配java.lang.ss.String 
    
 
    
 
     java..* 
     匹配java包及任何子包下的任何類型,如匹配java.lang.String、java.lang.annotation.Annotation 
    
 
    
 
     java.lang.*ing 
     匹配任何java.lang包下的以ing結尾的類型 
    
 
    
 
     java.lang.Number+ 
     匹配java.lang包下的任何Number的自類型，如匹配java.lang.Integer，也匹配java.math.BigInteger 
    
 
    
  
 
  
 
    
    
 
     參數 
     含義 
    
 
    
    
    
 
     () 
     表示方法沒有任何參數 
    
 
    
 
     (..) 
     表示匹配接受任意個參數的方法 
    
 
    
 
     (..,java.lang.String) 
     表示匹配接受java.lang.String類型的參數結束，且其前邊可以接受有任意個參數的方法 
    
 
    
 
     (java.lang.String,..) 
     表示匹配接受java.lang.String類型的參數開始，且其后邊可以接受任意個參數的方法 
    
 
    
 
     (*,java.lang.String) 
     表示匹配接受java.lang.String類型的參數結束，且其前邊接受有一個任意類型參數的方法 
    
 
    
  
 
  
AspectJ實例
 
  
Before、After
 
  
這兩個Advice應該是使用的最多的，所以，我們先來看下這兩個Advice的實例，首先看下Before和After。
 
  
@Before("execution( com.xys.aspectjxdemo.MainActivity.on(android.os.Bundle))")
public void onActivityMethodBefore(JoinPoint joinPoint) throws Throwable {
    String key = joinPoint.getSignature().toString();
    Log.d(TAG, "onActivityMethodBefore: " + key);
}


@After("execution( com.xys.aspectjxdemo.MainActivity.on(android.os.Bundle))")
public void onActivityMethodAfter(JoinPoint joinPoint) throws Throwable {
    String key = joinPoint.getSignature().toString();
    Log.d(TAG, "onActivityMethodAfter: " + key);
}</code></pre> 
  
經過上面的語法解釋，現在看這個應該很好理解了，我們來看下編譯后的類：
 
  
 
  
我們可以看見，在原始代碼的基礎上，增加了Before和After的代碼，Log也能被正確的插入并打印出來。
 
  
Around
 
  
Before和After其實還是很好理解的，也就是在Pointcuts之前和之后，插入代碼，那么Around呢，從字面含義上來講，也就是在方法前后各插入代碼，是的，他包含了Before和After的全部功能，代碼如下：
 
  
@Around("execution(* com.xys.aspectjxdemo.MainActivity.testAOP())")
public void onActivityMethodAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    String key = proceedingJoinPoint.getSignature().toString();
    Log.d(TAG, "onActivityMethodAroundFirst: " + key);
    proceedingJoinPoint.proceed();
    Log.d(TAG, "onActivityMethodAroundSecond: " + key);
}
 
  
其中，proceedingJoinPoint.proceed()代表執行原始的方法，在這之前、之后，都可以進行各種邏輯處理。
 
  
原始代碼：
 
  
public class MainActivity extends AppCompatActivity {



@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    testAOP();
}

public void testAOP() {
    Log.d("xuyisheng", "testAOP");
}



}</code></pre> 
  
我們先來看下編譯后的代碼：
 
  
 
  
我們可以發現，Around確實實現了Before和After的功能，但是要注意的是，Around和After是不能同時作用在同一個方法上的，會產生重復切入的問題。
 
  
自定義Pointcuts
 
  
自定義Pointcuts可以讓我們更加精確的切入一個或多個指定的切入點。
 
  
首先，我們需要自定義一個注解類，例如——DebugTool.java：
 
  
/**


    

  • 自定義AOP注解
    • 

  • <p>
    • 

  • Created by xuyisheng on 17/1/12.
*/
    • 



@Retention(RetentionPolicy.CLASS)
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD})
public @interface DebugTool {
}</code></pre> 
  
然后在需要插入代碼的地方使用這個注解：
 
  
public class MainActivity extends AppCompatActivity {



@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    testAOP();
}

@DebugTool
public void testAOP() {
    Log.d("xuyisheng", "testAOP");
}



}</code></pre> 
  
最后，我們來創建自己的切入文件。
 
  
@Pointcut("execution(@com.xys.aspectjxdemo.DebugTool  (..))")
public void DebugToolMethod() {
}


@Before("DebugToolMethod()")
public void onDebugToolMethodBefore(JoinPoint joinPoint) throws Throwable {
    String key = joinPoint.getSignature().toString();
    Log.d(TAG, "onDebugToolMethodBefore: " + key);
}</code></pre> 
  
先定義Pointcut，并申明要監控的方法名，最后，在Before或者其它Advice里面添加切入代碼，即可完成切入。
 
  
編譯好的代碼如下：
 
  
 
  
通過這種方式，我們可以非常方便的監控指定的Pointcut，從而增加監控的粒度。
 
  
call和execution
 
  
在AspectJ的切入點表達式中，我們前面都是使用的execution，實際上，還有一種類型——call，那么這兩種語法有什么區別呢，我們來試驗下就知道了。
 
  
被切代碼依然很簡單：
 
  
public class MainActivity extends AppCompatActivity {



@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    testAOP();
}

public void testAOP() {
    Log.d("xuyisheng", "testAOP");
}



}</code></pre> 
  
先來看execution，代碼如下：
 
  
@Before("execution(* com.xys.aspectjxdemo.MainActivity.testAOP(..))")
public void methodAOPTest(JoinPoint joinPoint) throws Throwable {
    String key = joinPoint.getSignature().toString();
    Log.d(TAG, "methodAOPTest: " + key);
}
 
  
編譯之后的代碼如下所示：
 
  
 
  
再來看下call，代碼如下：
 
  
@Before("call(* com.xys.aspectjxdemo.MainActivity.testAOP(..))")
public void methodAOPTest(JoinPoint joinPoint) throws Throwable {
    String key = joinPoint.getSignature().toString();
    Log.d(TAG, "methodAOPTest: " + key);
}
 
  
編譯之后的代碼如下所示：
 
  
 
  
其實對照起來看就一目了然了，execution是在被切入的方法中，call是在調用被切入的方法前或者后。
 
  
對于Call來說：
 
  
Call（Before）
Pointcut{
    Pointcut Method
}
Call（After）
 
  
對于Execution來說：
 
  
Pointcut{
  execution（Before）
    Pointcut Method
  execution（After）
}
 
  
切入點過濾與withincode
 
  
除了前面提到的call和execution，比較常用的還有一個withincode。這個語法通常來進行一些切入點條件的過濾，作更加精確的切入控制。我們可以參考下面這個例子：
 
  
public class MainActivity extends AppCompatActivity {



@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    testAOP1();
    testAOP2();
}

public void testAOP() {
    Log.d("xuyisheng", "testAOP");
}

public void testAOP1() {
    testAOP();
}

public void testAOP2() {
    testAOP();
}



}</code></pre> 
  
testAOP1()和testAOP2()都調用了testAOP()方法，但是，現在想在testAOP2()方法調用testAOP()方法的時候，才切入代碼，那么這個時候，就需要使用到Pointcut和withincode組合的方式，來精確定位切入點。
 
  
// 在testAOP2()方法內
@Pointcut("withincode(* com.xys.aspectjxdemo.MainActivity.testAOP2(..))")
public void invokeAOP2() {
}


// 調用testAOP()方法的時候
@Pointcut("call(* com.xys.aspectjxdemo.MainActivity.testAOP(..))")
public void invokeAOP() {
}


// 同時滿足前面的條件，即在testAOP2()方法內調用testAOP()方法的時候才切入
@Pointcut("invokeAOP() && invokeAOP2()")
public void invokeAOPOnlyInAOP2() {
}


@Before("invokeAOPOnlyInAOP2()")
public void beforeInvokeAOPOnlyInAOP2(JoinPoint joinPoint) {
    String key = joinPoint.getSignature().toString();
    Log.d(TAG, "onDebugToolMethodBefore: " + key);
}</code></pre> 
  
我們再來看下編譯后的代碼：
 
  
 
  
我們可以看見，只有在testAOP2()方法中被插入了代碼，這就做到了精確條件的插入。
 
  
異常處理AfterThrowing
 
  
AfterThrowing是一個比較少見的Advice，他用于處理程序中 未處理的異常 ，記住，這點很重要，是 未處理的異常 ，具體原因，我們等會看反編譯出來的代碼就知道了。我們隨手寫一個異常，代碼如下：
 
  
public void testAOP() {
    View view = null;
    view.animate();
}
 
  
然后使用AfterThrowing來進行AOP代碼的編寫：
 
  
@AfterThrowing(pointcut = "execution(* com.xys.aspectjxdemo.*.*(..))", throwing = "exception")
public void catchExceptionMethod(Exception exception) {
    String message = exception.toString();
    Log.d(TAG, "catchExceptionMethod: " + message);
}
 
  
這段代碼很簡單，同樣是使用我們前面類似的表達式，但是這里是為了處理異常，所以，使用了*.*來進行通配，在異常中，我們執行一行日志，編譯好的代碼如下：
 
  
 
  
我們可以看見com.xys.aspectjxdemo包下的所有方法都被加上了try catch，同時，在catch中，被插入了我們切入的代碼，但是最后，他依然會throw e，也就是說，這個異常已經會被拋出去，崩潰依舊是會發生的。同時，如果你的原始代碼中已經try catch了，那么同樣也無法處理，具體原因，我們看一個反編譯的代碼：
 
  
 
  
可以看見，實際上，原始代碼的catch中，又被套了一層try catch，所以，e.printStackTrace()被try catch，也就不會再有異常發生了，也就無法切入了。
 
  
 
 
  
 
 
  
來自：http://blog.csdn.net/eclipsexys/article/details/54425414
 
  
 
 本文由用戶 JulHlw 自行上傳分享，僅供網友學習交流。所有權歸原作者，若您的權利被侵害，請聯系管理員。
 轉載本站原創文章，請注明出處，并保留原始鏈接、圖片水印。
 本站是一個以用戶分享為主的開源技術平臺，歡迎各類分享！