利用AspectJ实现Android端非侵入式埋点

时间  2019-11-16
标签 利用 aspectj 实现 android 侵入 栏目 Java 繁體版
原文   原文链接

前言

最近在项目中遇到经过埋点对用户行为进行收集的需求，因为项目运行在局域网，并且有一些很细化的需求，比较几种技术方案以后，选择了经过AspectJ进行埋点。本文主要介绍笔者对学习和使用AspectJ的总结。javascript

AspectJ是什么

正如面向对象编程是对常见问题的模块化同样，面向切面编程是对横向的同一问题进行模块化，好比在某个包下的全部类中的某一类方法中都须要解决一个类似的问题，能够经过AOP的编程方式对此进行模块化封装，统一解决。关于AOP的具体解释，能够参照维基百科。而AspectJ就是面向切面编程在Java中的一种具体实现。html

AspectJ向Java引入了一个新的概念——join point，它包括几个新的结构： pointcuts，advice，inter-type declarations 和 aspects。java

join point是在程序流中被定义好的点。pointcut在那些点上选出特定的join point和值。advice是到达join point时被执行的代码。android

AspectJ还具备不一样类型的类型间声明（inter-type declarations），容许程序员修改程序的静态结构，即其类的成员和类之间的关系。git

AspectJ中的几个名词术语解释

  • Cross-cutting concerns：即便在面向对象编程中大多数类都是执行一个单一的、特定的功能，它们也有时候须要共享一些通用的辅助功能。好比咱们想要在一个线程进入和退出一个方法时，在数据层和UI层加上输出log的功能。尽管每个类的主要功能时不一样的，可是它们所须要执行的辅助功能是类似的。程序员

  • Advice：须要被注入到.class字节码文件的代码。一般有三种：before，after和around，分别是在目标方法执行前，执行后以及替换目标代码执行。除了注入代码到方法中外，更进一步的，你还能够作一些别的修改，例如添加成员变量和接口到一个类中。github

  • Join point：程序中执行代码插入的点，例如方法调用时或者方法执行时。编程

  • Pointcut：告诉代码注入工具在哪里注入特定代码的表达式（即须要在哪些Joint point应用特定的Advice）。它能够选择一个这样的点（例如，一个单一方法的执行）或者许多类似的点（例如，全部被自定义注解@DebugTrace标记的方法）。缓存

  • Aspect： Aspect将pointcut和advice 联系在一块儿。例如，咱们经过定义一个pointcut和给出一个准确的advice实现向咱们的程序中添加一个打印日志功能的aspect。app

  • Weaving：向目标位置（join point）注入代码（advice）的过程。

上面几个名词间的关系的示意图以下：

AOP编程的具体使用场景

  • 日志记录
  • 持久化
  • 行为监测
  • 数据验证
  • 缓存
    ...

注入代码的时机

  • 运行时：你的代码对加强代码的需求很明确，好比，必须使用动态代理（这能够说并非真正的代码注入）。

  • 加载时：当目标类被Dalvik或者ART加载的时候修改才会被执行。这是对Java字节码文件或者Android的dex文件进行的注入操做。

  • 编译时：在打包发布程序以前，经过向编译过程添加额外的步骤来修改被编译的类。

具体使用哪种方式视使用状况而定。

几个经常使用的工具和类库

  • AspectJ：和Java语言无缝衔接的面向切面的编程的扩展工具（可用于Android）。

  • Javassist for Android：一个移植到Android平台的很是知名的操纵字节码的java库。

  • DexMaker：用于在Dalvik VM编译时或运行时生成代码的基于java语言的一套API。

  • ASMDEX：一个字节码操做库（ASM），但它处理Android可执行文件（DEX字节码）。

为何选择AspectJ

  • 很是强大

  • 易于使用

  • 支持编译时和加载时的代码注入

举个栗子

如今有一个需求，咱们须要计算一个方法的运行时间，咱们想经过给这个方法加上咱们自定义的注解@DebugTrace来实现这个需求，而不是在业务代码中很生硬地插入计算时间的代码。这里咱们就能够经过AspectJ来实现咱们的目的。

这里咱们有两点须要知道：

  • 注解将在咱们编译过程当中的一个新步骤中被处理。

  • 必要的模板代码将会被生成和注入到被注解的方法中。

这个过程能够经过下面的示意图理解：

在这个实例中，咱们将分出两个module，一个用于业务代码，一个用于利用AspectJ进行代码注入。（这里要说明一下，AspectJ自己是一套java library，为了让AspectJ在Android上正确运行，咱们使用了android library，由于咱们必须在编译应用程序时使用一些钩子，只能使用android-library gradle插件。）

建立注解
@Retention(RetentionPolicy.CLASS)
@Target({ ElementType.CONSTRUCTOR, ElementType.METHOD })
public @interface DebugTrace {}复制代码
建立用于控制监听的类
/** * Class representing a StopWatch for measuring time. */
public class StopWatch {
  private long startTime;
  private long endTime;
  private long elapsedTime;

  public StopWatch() {
    //empty
  }

  private void reset() {
    startTime = 0;
    endTime = 0;
    elapsedTime = 0;
  }

  public void start() {
    reset();
    startTime = System.nanoTime();
  }

  public void stop() {
    if (startTime != 0) {
      endTime = System.nanoTime();
      elapsedTime = endTime - startTime;
    } else {
      reset();
    }
  }

  public long getTotalTimeMillis() {
    return (elapsedTime != 0) ? TimeUnit.NANOSECONDS.toMillis(endTime - startTime) : 0;
  }
}复制代码
封装一下android.util.Log
/** * Wrapper around {@link android.util.Log} */
public class DebugLog {

  private DebugLog() {}

  /** * Send a debug log message * * @param tag Source of a log message. * @param message The message you would like logged. */
  public static void log(String tag, String message) {
    Log.d(tag, message);
  }
}复制代码
关键的Aspect类的实现
/** * Aspect representing the cross cutting-concern: Method and Constructor Tracing. */
@Aspect
public class TraceAspect {

  private static final String POINTCUT_METHOD =
      "execution(@org.android10.gintonic.annotation.DebugTrace * *(..))";

  private static final String POINTCUT_CONSTRUCTOR =
      "execution(@org.android10.gintonic.annotation.DebugTrace *.new(..))";

  @Pointcut(POINTCUT_METHOD)
  public void methodAnnotatedWithDebugTrace() {}

  @Pointcut(POINTCUT_CONSTRUCTOR)
  public void constructorAnnotatedDebugTrace() {}

  @Around("methodAnnotatedWithDebugTrace() || constructorAnnotatedDebugTrace()")
  public Object weaveJoinPoint(ProceedingJoinPoint joinPoint) throws Throwable {
    MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
    String className = methodSignature.getDeclaringType().getSimpleName();
    String methodName = methodSignature.getName();

    final StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    // 被注解的方法在这一行代码被执行
    Object result = joinPoint.proceed();
    stopWatch.stop();

    DebugLog.log(className, buildLogMessage(methodName, stopWatch.getTotalTimeMillis()));

    return result;
  }

  /** * Create a log message. * * @param methodName A string with the method name. * @param methodDuration Duration of the method in milliseconds. * @return A string representing message. */
  private static String buildLogMessage(String methodName, long methodDuration) {
    StringBuilder message = new StringBuilder();
    message.append("Gintonic --> ");
    message.append(methodName);
    message.append(" --> ");
    message.append("[");
    message.append(methodDuration);
    message.append("ms");
    message.append("]");

    return message.toString();
  }
}复制代码

关于上面这段代码这里提两点：

  • 咱们声明了两个公共方法和两个pointcut用于过滤全部被"org.android10.gintonic.annotation.DebugTrace"标记的方法和构造器。

  • 咱们定义的 "weaveJointPoint(ProceedingJoinPoint joinPoint)" 这个方法被添加了"@Around"注解，这意味着咱们的代码注入将发生在被"@DebugTrace"注解标记的方法先后。

下面的一张图将有助于理解pointcut的构成：

在build.gradle文件中的一些必要的配置

要是AspectJ在Android上正确运行，还须要在build.gradle文件中进行一些必要的配置，以下：

import com.android.build.gradle.LibraryPlugin
import org.aspectj.bridge.IMessage
import org.aspectj.bridge.MessageHandler
import org.aspectj.tools.ajc.Main

buildscript {
  repositories {
    mavenCentral()
  }
  dependencies {
    classpath 'com.android.tools.build:gradle:0.12.+'
    classpath 'org.aspectj:aspectjtools:1.8.1'
  }
}

apply plugin: 'android-library'

repositories {
  mavenCentral()
}

dependencies {
  compile 'org.aspectj:aspectjrt:1.8.1'
}

android {
  compileSdkVersion 19
  buildToolsVersion '19.1.0'

  lintOptions {
    abortOnError false
  }
}

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;
      }
    }
  }
}复制代码
测试方法
@DebugTrace
  private void testAnnotatedMethod() {
    try {
      Thread.sleep(10);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }复制代码

运行结果：

Gintonic --> testAnnotatedMethod --> [10ms]复制代码

咱们能够经过对apk文件进行反编译来查看被注入后的代码。

总结

AOP编程在进行用户行为统计是是一种很是可靠的解决方案，避免了直接在业务代码中进行埋点，而AOP编程的应用还不只于此，它在性能监控，数据采集等方面也有着普遍的应用，后续将继续研究，并整理发布。AspectJ是一个很强大的用于AOP编程的库，使用AspectJ关键在于掌握它的pointcut的语法，这里给一个AspectJ的官方的doc连接，须要注意的是，通过实际测试，有一些语法在Android中是没法使用的，须要在实际使用过程当中进行总结。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程