Android监测用户行为之中AOP编程之AspectJ实战

文章背景

• 最近在给某某银行做项目的时，涉及到了数据埋点，性能监控等问题，那我们起先想到的有两种方案:

  • 方案之一就是借助第三方，比如友盟、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

• 2、再创建一个module(Android Library)

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

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
微信公众号：终端研发部

技术+职场