Android監測使用者行為之中AOP程式設計之AspectJ實戰

codeGoogle發表於2017-07-14
Android程式設計

文章背景

  • 最近在給某某銀行做專案的時，涉及到了資料埋點，效能監控等問題，那我們起先想到的有兩種方案:

    • 方案之一就是藉助第三方，比如友盟、Bugly等，由於專案是部署在銀行的網路框架之內的，所以該方案不可行。
    • 另外一種方案是就是給每一個方法裡面資料打點，然後寫入SD卡，定時上報給自己的伺服器，伺服器來進行統計分析

    這種方案看上去似乎可行，但有弊端，不僅會給程式設計師增加巨大工作量、而且最致命的是會嚴重拖累整個APP的效能。

  • 好多都應無奈之舉放棄了該需求，但資料埋點實現使用者行為的收集分析和效能監控對於技術部和運營部來說是一件非常有價值的事情，所以作為程式的我必應尋找解決方案

  • 慶幸的是我們除了OOP程式設計思想外，還有一種程式設計思想就是AOP程式設計，這種程式設計思想能解決此類問題。

文章目標

  • 實現使用者行為採集
  • 實現方法效能監控
  • 探討AOP程式設計實戰

看圖簡單解讀Android的AOP實戰

看到沒有，在LinearLayoutTestActivity中除了載入佈局的操作外，我並沒有幹其他的什麼，但當我點選選單跳轉到該Activity時，onCreate的方法和引數被列印出來，甚至LinearLayoutTestActivity類資訊也被列印出來了，幹這個事情的是TraceAspect這個類。到這裡上面所說的使用者的行為跟蹤就輕而易舉得以實現，那麼下面我們開始來了解一下這種技術。

什麼是AOP

  • 面向切面程式設計（AOP，Aspect-oriented programming）需要把程式邏輯分解成『關注點』（concerns，功能的內聚區域）。

  • 這意味著，在 AOP 中，我們不需要顯式的修改就可以向程式碼中新增可執行的程式碼塊。這種程式設計正規化假定『橫切關注點』（cross-cutting concerns，多處程式碼中需要的邏輯，但沒有一個單獨的類來實現）應該只被實現一次，且能夠多次注入到需要該邏輯的地方。

  • 程式碼注入是 AOP 中的重要部分：它在處理上述提及的橫切整個應用的『關注點』時很有用，例如日誌或者效能監控。這種方式，並不如你所想的應用甚少，相反的，每個程式設計師都可以有使用這種注入程式碼能力的場景，這樣可以避免很多痛苦和無奈。

  • AOP 是一種已經存在了很多年的程式設計正規化。我發現把它應用到 Android 開發中也很有用。經過一番調研後，我認為我們用它可以獲得很多好處和有用的東西。

AspectJ是什麼

  • AspectJ實際上是對AOP程式設計思想的一個實踐，它不是一個新的語言，它就是一個程式碼編譯器（ajc）

  • 在Java編譯器的基礎上增加了一些它自己的關鍵字識別和編譯方法。因此，ajc也可以編譯Java程式碼。

  • 它在編譯期將開發者編寫的Aspect程式編織到目標程式中，對目標程式作了重構，目的就是建立目標程式與Aspect程式的連線（耦合，獲得對方的引用（獲得的是宣告型別，不是執行時型別）和上下文資訊），從而達到AOP的目的（這裡在編譯期還是修改了原來程式的程式碼，但是是ajc替我們做的）。

  • 當然，除了AspectJ以外，還有很多其它的AOP實現，例如XPosed、DexPosed、ASMDex。

    為什麼用 AspectJ？

  • 功能強大:它就是一個編譯器+一個庫，可以讓開發者最大限度的發揮，實現形形色色的AOP程式！

  • 非侵入式監控： 可以在不修監控目標的情況下監控其執行，截獲某類方法，甚至可以修改其引數和執行軌跡！

  • 支援編譯期和載入時程式碼注入，不影響效能。

  • 易用易學:它就是Java，只要會Java就可以用它。

    如何Android專案中使用AspectJ

    使用方法有兩種：

  • 外掛的方式：網上有人在github上提供了整合的外掛gradle-android-aspectj-plugin。這種方式配置簡單方便，但經測試無法相容databinding框架，這個問題現在作者依然沒有解決，希望作者能夠快速解決。

  • Gradle配置的方式：配置有點麻煩，不過國外一個大牛在build檔案中新增了一些指令碼，雖然有點難懂，但可以在AS中使用。文章出處：fernandocejas.com/2014/08/03/…

Step

  • 1、建立一個AS原工程

    Paste_Image.png
    Paste_Image.png

  • 2、再建立一個module(Android Library)

Paste_Image.png
Paste_Image.png

  • 3、在gintonic中新增AspectJ依賴，同時編寫build指令碼，新增任務，使得IDE使用ajc作為編譯器編譯程式碼，然後把該Module新增至主工程Module中。

      Android.libraryVariants.all { variant ->
    LibraryPlugin plugin = project.plugins.getPlugin(LibraryPlugin)
    JavaCompile javaCompile = variant.javaCompile
    javaCompile.doLast {
      String[] args = ["-showWeaveInfo",
                       "-1.5",
                       "-inpath", javaCompile.destinationDir.toString(),
                       "-aspectpath", javaCompile.classpath.asPath,
                       "-d", javaCompile.destinationDir.toString(),
                       "-classpath", javaCompile.classpath.asPath,
                       "-bootclasspath", plugin.project.android.bootClasspath.join(
              File.pathSeparator)]

      MessageHandler handler = new MessageHandler(true);
      new Main().run(args, handler)

      def log = 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
            break;
          case IMessage.WARNING:
          case IMessage.INFO:
            log.info message.message, message.thrown
            break;
          case IMessage.DEBUG:
            log.debug message.message, message.thrown
            break;
        }
      }
    }
  }複製程式碼

  • 4、在主build.gradle(Module:app)中新增也要新增AspectJ依賴，同時編寫build指令碼，新增任務，目的就是為了建立兩者的通訊，使得IDE使用ajc編譯程式碼。

        dependencies {
        compile fileTree(include: ['*.jar'], dir: 'libs')
        androidTestCompile('com.android.support.test.espresso:espresso-    core:2.2.2', {
          exclude group: 'com.android.support', module: 'support-annotations'
      })
      //compile 'com.android.support:appcompat-v7:25.3.1'
      //compile 'com.android.support.constraint:constraint-layout:1.0.2'
      testCompile 'junit:junit:4.12'
      compile project(':gintonic')
      compile 'org.aspectj:aspectjrt:1.8.1'
  }複製程式碼

  • 5、在Module(gintonic)中新建一個名為”TraceAspect”類

    @Aspect
public class TraceAspect {

  //ydc start
  private static final String TAG = "ydc";
  @Before("execution(* android.app.Activity.on**(..))")
  public void onActivityMethodBefore(JoinPoint joinPoint) throws Throwable {
    String key = joinPoint.getSignature().toString();
    Log.d(TAG, "onActivityMethodBefore: " + key+"\n"+joinPoint.getThis());
  }複製程式碼

  • 6、LinearLayoutTestActivity類

      public class LinearLayoutTestActivity extends Activity {

    private LinearLayout myLinearLayout;

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

      myLinearLayout = (LinearLayout) findViewById(R.id.linearLayoutOne);
      myLinearLayout.invalidate();
    }
  }複製程式碼

然後執行我們的程式看日誌列印效果

上面的程式碼片段中有兩處地方值得注意，一個是把這個類註解為@Aspect，另一個是給方法的的註解並加上了類似正規表示式的過濾條件，我們先按照我的步驟走，後面會一一講解。

根據圖片我們會驚奇的發現LinearLayoutTestActivity中的onCreate(Bundle savedInstanceState)方法被TraceAspect類赤裸裸的監控了，不僅擷取到了LinearLayoutTestActivity類資訊和方法及方法引數。

那這到底是怎麼回事呢？我們可以使用反編譯我的apk看一下相關的程式碼
[圖片上傳中。。。（6）]

我們可以發現，在onCreate執行之前，插入了一些AspectJ的程式碼，並且呼叫了TraceAspect中的 onActivityMethodBefore(JoinPoint joinPoint)方法。這個就是AspectJ的主要功能，拋開AOP的思想來說，我們想做的，實際上就是『在不侵入原有程式碼的基礎上，增加新的程式碼』。

監控Activity的下其它被呼叫的方法

看到沒有我們僅僅在TraceAspect類中編寫一個方法就可以監控RelativeLayoutTestActivity中被使用者點選的方法，這樣就可以輕輕鬆鬆採集使用者行

  • 程式碼：

     @Around("execution(* com.example.myaspectjapplication.activity.RelativeLayoutTestActivity.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);
   }複製程式碼

我們還是照樣看來看一下反編譯的程式碼
這是在RelativeLayoutTestActivity類中呼叫testAOP()我們的原始碼：

public class RelativeLayoutTestActivity extends Activity {

  Button btn_test,btn_test2;
  //public static String A="88888";
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_relative_layout_test);
    btn_test=(Button)findViewById(R.id.btn_test);
    btn_test.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        testAOP();
      }
    });
    btn_test2=(Button)findViewById(R.id.btn_test2);
    btn_test2.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
          mytestDebug();
      }
    });

  }

  private  void testAOP(){

    int cunt=0;
    for ( int i=0;i<1000;i++){
      cunt++;

    }
    //Log.d("ydc","cunt:"+cunt+"");
  }

  private void method4Call() {
    //System.out.println("in method method4Call");
  }

  @DebugTrace
  private void  mytestDebug(){

  }
}複製程式碼

下面是反編譯的程式碼，讀者只要關注testAOP()方法即可

public class RelativeLayoutTestActivity extends Activity
{
  private static final JoinPoint.StaticPart ajc$tjp_0;
  private static final JoinPoint.StaticPart ajc$tjp_1;
  private static final JoinPoint.StaticPart ajc$tjp_2;
  Button btn_test;
  Button btn_test2;

  static
  {
    ajc$preClinit();
  }

  private static void ajc$preClinit()
  {
    Factory localFactory = new Factory("RelativeLayoutTestActivity.java", RelativeLayoutTestActivity.class);
    ajc$tjp_0 = localFactory.makeSJP("method-execution", localFactory.makeMethodSig("4", "onCreate", "com.example.myaspectjapplication.activity.RelativeLayoutTestActivity", "android.os.Bundle", "savedInstanceState", "", "void"), 27);
    ajc$tjp_1 = localFactory.makeSJP("method-execution", localFactory.makeMethodSig("2", "testAOP", "com.example.myaspectjapplication.activity.RelativeLayoutTestActivity", "", "", "", "void"), 48);
    ajc$tjp_2 = localFactory.makeSJP("method-execution", localFactory.makeMethodSig("2", "mytestDebug", "com.example.myaspectjapplication.activity.RelativeLayoutTestActivity", "", "", "", "void"), 63);
  }

  private void method4Call()
  {
  }

  @DebugTrace
  private void mytestDebug()
  {
    JoinPoint localJoinPoint = Factory.makeJP(ajc$tjp_2, this, this);
    TraceAspect.aspectOf().weaveJoinPoint(new RelativeLayoutTestActivity.AjcClosure3(new Object[] { this, localJoinPoint }).linkClosureAndJoinPoint(69648));
  }

  static final void mytestDebug_aroundBody2(RelativeLayoutTestActivity paramRelativeLayoutTestActivity, JoinPoint paramJoinPoint)
  {
  }

  private void testAOP()
  {
    JoinPoint localJoinPoint = Factory.makeJP(ajc$tjp_1, this, this);
    TraceAspect.aspectOf().onActivityMethodAround(new RelativeLayoutTestActivity.AjcClosure1(new Object[] { this, localJoinPoint }).linkClosureAndJoinPoint(69648));
  }

  static final void testAOP_aroundBody0(RelativeLayoutTestActivity paramRelativeLayoutTestActivity, JoinPoint paramJoinPoint)
  {
    int i = 0;
    for (int j = 0; j < 1000; j++)
      i++;
  }

  protected void onCreate(Bundle paramBundle)
  {
    JoinPoint localJoinPoint = Factory.makeJP(ajc$tjp_0, this, this, paramBundle);
    TraceAspect.aspectOf().onActivityMethodBefore(localJoinPoint);
    super.onCreate(paramBundle);
    setContentView(2130903043);
    this.btn_test = ((Button)findViewById(2131230727));
    this.btn_test.setOnClickListener(new View.OnClickListener()
    {
      public void onClick(View paramAnonymousView)
      {
        RelativeLayoutTestActivity.this.testAOP();
      }
    });
    this.btn_test2 = ((Button)findViewById(2131230728));
    this.btn_test2.setOnClickListener(new View.OnClickListener()
    {
      public void onClick(View paramAnonymousView)
      {
        RelativeLayoutTestActivity.this.mytestDebug();
      }
    });
  }
}複製程式碼

我們不難發現我們的程式碼輕鬆被AspectJ重構了，而且這種重構是在不修改原有程式碼的情況下無縫的被插入。

Fragment的中的方法監控

上面我已經演示過Activity中的方法強勢插入，在Fragment中依然可行

@Before("execution(* android.app.Fragment.on**(..))")
  public void onActivityMethodBefore(JoinPoint joinPoint) throws Throwable {
    String key = joinPoint.getSignature().toString();
    Log.d(TAG, "onActivityMethodBefore: " + key+"\n"+joinPoint.getThis());
  }複製程式碼

Paste_Image.png
Paste_Image.png

AspectJ原理剖析

  • 1、Join Points(連線點)
    Join Points，簡稱JPoints，是AspectJ的核心思想之一，它就像一把刀，把程式的整個執行過程切成了一段段不同的部分。例如，構造方法呼叫、呼叫方法、方法執行、異常等等，這些都是Join Points，實際上，也就是你想把新的程式碼插在程式的哪個地方，是插在構造方法中，還是插在某個方法呼叫前，或者是插在某個方法中，這個地方就是Join Points，當然，不是所有地方都能給你插的，只有能插的地方，才叫Join Points。

  • 2、Pointcuts(切入點)
    告訴程式碼注入工具，在何處注入一段特定程式碼的表示式。例如，在哪些 joint points 應用一個特定的 Advice。切入點可以選擇唯一一個，比如執行某一個方法，也可以有多個選擇,可簡單理解為帶條件的Join Points，作為我們需要的程式碼切入點。

  • 3、Advice（通知）
    如何注入到我的class檔案中的程式碼。典型的 Advice 型別有 before、after 和 around，分別表示在目標方法執行之前、執行後和完全替代目標方法執行的程式碼。 上面的例子中用的就是最簡單的Advice——Before。
  • 4、Aspect（切面）: Pointcut 和 Advice 的組合看做切面。例如，我們在應用中通過定義一個 pointcut 和給定恰當的advice，新增一個日誌切面。
  • 5、Weaving（織入）: 注入程式碼（advices）到目標位置（joint points）的過程。
    由於微信對篇幅大小的限制，這裡只是關於部分AOP的部分講解。
    更多參考： blog.csdn.net/xinanheisha…

注意這裡

AOP 應用場景非常多。
只要在我們想監控的方法上加上 @DebugTrace即可，我在這裡給onMeasure方法上註解，當我進入LinearLayoutTestActivity 類時，執行如下：

專案結果顯示
專案結果顯示

部落格地址:

blog.csdn.net/xinanheisha…

最後附上Dome下載地址：

download.csdn.net/download/xi…

提供一個反編譯工具：

apk反編譯工具下載地址
blog.csdn.net/xinanheisha…

相信自己，沒有做不到的，只有想不到的

如果你覺得此文對您有所幫助，歡迎入群 QQ交流群 ：232203809
微信公眾號：終端研發部

技術+職場
技術+職場

相關文章