Android开发集锦程序员手机移动程序开发

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

2017-04-16  本文已影响900人  说码解字

前言

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

AspectJ是什么

正如面向对象编程是对常见问题的模块化一样,面向切面编程是对横向的同一问题进行模块化,比如在某个包下的所有类中的某一类方法中都需要解决一个相似的问题,可以通过AOP的编程方式对此进行模块化封装,统一解决。关于AOP的具体解释,可以参照维基百科。而AspectJ就是面向切面编程在Java中的一种具体实现。

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

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

AspectJ还具有不同类型的类型间声明(inter-type declarations),允许程序员修改程序的静态结构,即其类的成员和类之间的关系。

AspectJ中的几个名词术语解释

上面几个名词间的关系的示意图如下:

AOP编程的具体使用场景

注入代码的时机

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

几个常用的工具和类库

为什么选择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的构成:

在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中是无法使用的,需要在实际使用过程中进行总结。

上一篇 下一篇

猜你喜欢

热点阅读