AspectJ 在 Android 中的使用

在介绍 AspectJ 之前，我们先看看常见的几种编程架构思想。

• 面向对象编程 Object Oriented Programming
• 面向过程编程 Procedure Oriented Programming
• 面向切面编程 Aspect Oriented Programming

面向对象、面向过程、面向切面， 这三种是我们常见的三种编程架构思想，在日常的编程中， OOP 是 Android 开发中最常见的，其他的两种比较少见。

一、AOP

AOP 是面向切面编程，它在我们的日志系统、权限管理方面有着比较好的应用。
在项目中，我们的很多功能都是分散到各个模块，例如日志打印，AOP 的目标就是要把这些功能集中起来，放到一个统一的地方来控制和管理。

二、AspectJ

AOP 是一种编程的思想，在具体的编程中需要实际的工具去实现这套思想。 AspectJ 就是这样的一个工具。使用 AspectJ 有两种方式

• 1. 完全使用 AspectJ 的语言开发；
• 2. 使用 AspectJ 注解，完全的使用纯 Java 开发

我们后续讲的，基本上都是以 AspectJ 注解的方法，同时在最后也会附上 AspectJ 和 AspectJ 注解的等价。

1.AspectJ 语法

这里只是介绍简单的一些概念，如果想要去了解深入的用法，可参考文后的链接，去官网查看。

1. JoinPoint

JoinPoint: A particular point in a program that might be the target of code injection.
JoinPoint 简单一点说就是程序运行时要执行一些动作的点。

AspectJ 中可以选择的 JoinPoint

JoinPoint 的选择要结合下面的 Pointcuts 表达式来看

2. Pointcut

Pointcut: An expression which tell a code injection tool where to inject a particular piece of code
Pointcut 简单的说就是从一堆的 JoinPoint 中挑选感兴趣的 JoinPoint 的表达式。

例如

pointcut anyCall(): call(* *.println(..)) && !within(TestAspect);

在 AspectJ 的语言中定义一个 Pointcout 需要用关键词 pointcut .
上面的这里是

• pointcut: 是定一个 Pointcut 的关键词
• anyCall(): 是 Pointcut 的名称
• call : 表示 JoinPoint 的类型为 call
• 第一个 '*' 号是返回值， ‘*’ 代表是任意返回值； 第二个 ‘*’ 号代表是包名，‘*’ 代表是任意包名,这边表明我们是选择任意包名下的 println 函数；在 （..） 中指定参数类型，‘..’ 通配符表示任意类型；
• &&！ 表示组合条件，有 &&， || 以及 ！
• within(TestAspect): within 是 JoinPoint 间接选择过滤的一个方法，后面会讲到。 ！within(TestAspect) 表示调用者的类型不是 TestAspect.

3. JointPoint 的选择

JointPoint 的选择有分成直接选择和间接选择两种方式

• JointPoint 的直接选择就是通过和 Pointcut 的语法一一对应关系中选择；
• JointPoint 的间接选择就是通过一些通配符进行筛选过滤的选择，上面例子中的 within 就是间接选择的一种。

1.JointPoint 直接选择

JoinPoint 的选择策略和 Pointcut 的语法对应关系

JoinPoint 的策略的选择对应着不同 Pointcut，特别是 Pointcut 里面有着不同的 Signature。

以下有详细的说明：

Method Signature 表达式
语法

@注解 访问权限 返回值的类型 包名.函数名(参数)
例子：
@before("execution(* android.app.Activity.on**(..))");

• 注解： 是可选项; 这里是 @before,关于注解的在后面 Adivce 中有更详细的说明

• 访问权限: 可选项; 有 public, private, protected 类型；例子没有设置

• 返回值的类型: 与普通函数的返回值类型是一样的，如果不限定类型，用通配符 * 表示。例子中是 *

• 包名.函数名：用于查找匹配的函数，可以使用通配符
  
  通配符的类型

  • ' * '表示用于匹配处 . 号之外的任意字符；
  • ' .. ' 表示任意子 package
  • ' + '号表示子类

  
  例子：

  • java.*.Data: 可以表示 java.sql.Data ，也可以表示 java.util.Date;
  • Test* : 表示Test开头的函数，可以表示 TestBase, 也可以表示 TestDervied
  • java..* : 表示 java 任意子类
  • java..*Model+: 表示 Java 任意 package 中名字以 Model 结尾的子类，比如 TabelModel, TreeModel 等

• 函数参数
  参数有不同的型式

  • (int, char): 表示参数只有两个， 并且第一个参数是 int, 第二个参数是 char;
  • (String, ..): 表示参数至少有一个。并且第一个参数是 String, 后面参数类型不限。在参数匹配中， .. 代表任意参数个数和类型；
  • （Oject ...）: 表示不定个数的参数，并且类型都是 Object, 这里的 ... 不是通配符，而是 java 中不定参数的意思；

Constructor Signature 表达式
和 Method Signature 类似
不同点：
构造函数没有返回值，并且函数名必须叫 new
例子：

public *..TestDeived.new(..)

• public: 表示选择 public 访问权限的
• *.. : 代表任意包名
• TestDeived.new: 代表 TestDerived 的构造函数
• (..): 代表参数个数和类型都是任意的

Field Signature表达式
语法

@注解 访问权限 类型 类名.成员变量名

• @注解和访问权限是可选的
• 类型：成员变量类型， * 表示任意类型
• 类名.成员变量名： 成员变量名可以是*， 代表任意成员变量

例子, 用 AspectJ 打印成员变量赋值前后的值

// TraceAspect.java　set field 的切面
private static final String POINTCUT_FILEED =
        "set(int org.android10.viewgroupperformance.activity.MainActivity.mTest) && args(newValue) && target(t)";

@Before(POINTCUT_FILEED)
public void onFiled(JoinPoint joinPoint, Object newValue, Object t) throws IllegalAccessException {
    Object object = joinPoint.getThis();

    FieldSignature fieldSignature = (FieldSignature) joinPoint.getSignature();
    String fileName = fieldSignature.getName();
    Field field = fieldSignature.getField();
    field.setAccessible(true);
    Class clazz = fieldSignature.getFieldType();
    String clazzName = clazz.getSimpleName();

    Object oldValue = field.get(t);

    Log.i("MainActivity", "\nonFiled value = " + newValue.toString() + "\n fieldSignature =" + fieldSignature.toString()
                + "\nfield = " + field.toString() + " +  \nFileName = " + fileName
                + "\nclazzName = " + clazzName + " \noldValue = " + oldValue.toString() );
}

// 在 MainActivity.java 中
@Override
protected void onResume() {
        super.onResume();
        mTest = 100;
}

打印结果

onFiled value = 100
fieldSignature =int org.android10.viewgroupperformance.activity.MainActivity.mTest
field = private int org.android10.viewgroupperformance.activity.MainActivity.mTest +
FileName = mTest
clazzName = int
oldValue = -1

TypeSignature表达式
例子：
staticinitlization(test..TestBase): 表示 TestBase 类的 static block
handler(NullPointException): 表示 catch 到 NullPointerException 的 JPoin

2.JointPoint 间接选择

JointPoint 的直接选择是通过 Signature 信息匹配的，除此之外还有其他的方式，这些方式都可以归类到间接选择

3.call 与 execution 区别

当 call 捕获 joinPoint 时，捕获的签名方法的调用点;execution 捕获 joinPoint 时，捕获的则是执行点。
两个的区别在于一个是 ”调用点“， 一个是 ”执行点“

对于 call 来讲

call(Before)
Pointcut {
    Pointcut Method
}
call(After)

对于 execution 来说

Pointcut {
   Execution(Before)
   Pointcut Method
   Execution(After)
}

3.AspectJ 注解的等价

AspectJ 提供了相应的注解，注解的方式和 AspectJ 语言编写是等效的。我们在 Android 中一般也是采用注解的方式

Aspect

public aspect Foo{}
等效
@Aspect
public class Foo{}

call

@Pointcut("call(* .(..))")
void anyCall(){}
等效
pointcut anyCall(): call(* .(..))

要绑定参数的时候，只需要将参数作为备注解的方法的参数即可

@Pointcut("call(* .(int)) && arg(i) && target(callee)")
void anyCall(int i, Fool callee){}
等效
pointcut anyCall(int i, Foo callee): call(* .(int)) && arg(i) && target(callee){};
说明要先定义参数 int i, Foo callee

before

@Before("call(* org.android10.viewgroupperformance.activity..(..)) && this(foo)")
public void callFromFoo(Foo foo){}
等效
before(Foo foo): call( org.android10.viewgroupperformance.activity..*(..)) && this(foo){}

returning

@AfterReturning(pointcut="call(Foo+.new(..))", returning="f")
public void itsAFoo(foo f){}
等效
after returning(Foo f): call(Foo+.new(..)){}

其他的表达式也是类似的

4. Advice

Advice: Advice defines pieces of aspect implementation that execute at well-defined points in the execution of the program.

通过前面的 Pointcuts 找到了相应的 JointPoint, 需要对这些 JointPoint 最一些事情，相当于对 JointPoint 进行 hook, 这就是 advice 要做的事。

advice 的分类

例子：
我们需要在 Activity 中的 onResume 方法调用前后输出

// MainActivity.java
@Override
protected void onResume() {
    super.onResume();
    Log.i(TAG, "--- onResume---");
}

// TraceAspect.java
private static final String POINTCUT_ONMETHOD =
        "execution(* android.app.Activity.on**(..))";

@Before(POINTCUT_ONMETHOD)
public void beforeOnMethod(JoinPoint joinPoint) {
    MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
    String className = methodSignature.getDeclaringType().getSimpleName();
    String methodName = methodSignature.getName();
    Log.i(className, "before " + methodName + " log");

}

@After(POINTCUT_ONMETHOD)
public void onMethLog(JoinPoint joinPoint){
    MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
    String className = methodSignature.getDeclaringType().getSimpleName();
    String methodName = methodSignature.getName();
    Log.i(className, "after " + methodName + " log");
}

查看输出

aspectj_1.png

改成 Around 的方式

// TraceAspect.java
private static final String POINTCUT_ONMETHOD =
        "execution(* android.app.Activity.on**(..))";
@Pointcut(POINTCUT_ONMETHOD)
public void annotationOnMethodTrace(){

}

@Around("annotationOnMethodTrace()")
public Object weaveOnMethodJoinPoint(ProceedingJoinPoint joinPoint) throws Throwable {

  MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
  String className = methodSignature.getDeclaringType().getSimpleName();
  String methodName = methodSignature.getName();

  Log.i("MainActivity", "before joinPoint proceed className = " + className + " methodName = " + methodName);

  Object result  = joinPoint.proceed();
  Log.i("MainActivity", "after joinPoint proceed className = " + className + " methodName = " + methodName);

  return result;
}

输出

aspectj_2.png

从上面例子的输出我们可以看到 around 等价于 before + after, 另外 JointPoint#proceed 是原来的 JointPoint，在这里是 onResume 方法， 输出中的 “--- onResume---” 就是在 onResume 中打印的。

5. 参数传递和 JointPoint 信息

经过前面的几个步骤，我们已经拿到了 JointPoint,但是我们经常需要对一些 advice 传入参数，然后进行处理的。例如如果传入的参数不合法，就不用调 JointPoint#proceed 方法处理了。

参数传递

advice 参数的方法由 this, target(), args()

• this(Type or Id): 捕获当前对象（被绑定 this）实例执行的连接点 -- 实例由 Type 或者 Id 描述
• target(Type or Id): 捕获目标对象（被应用与对象上的调用和属性操作）实例的连接点 -- 实例由 Type 和 Id 描述（必须绑定和封装后放入通知或者切点定义）。它不匹配任何静态的调用、应用和设置成员。
• args(Type or Id): 捕获具有适当类型样式的实例连接点

下面是例子说明
我们在 MainActivity 定义一个成员变量 mTest, 初始值为 -1，在 OnResume() 方法对它进行赋值，用 target 和 args 对 mTest 赋值前后的值进行监听

// MainActivity.java
private int mTest = -1;
@Override
protected void onResume() {
    super.onResume();
    Log.i(TAG, "--- onResume---");
    mTest = 100;
}

// TraceAspect.java
//　set field 的切面
private static final String POINTCUT_FILEED =
        "set(int org.android10.viewgroupperformance.activity.MainActivity.mTest) && args(newValue) && target(t)";

@Before(POINTCUT_FILEED)
public void onFiled(JoinPoint joinPoint, Object newValue, Object t) throws IllegalAccessException {

    FieldSignature fieldSignature = (FieldSignature) joinPoint.getSignature();
    String fileName = fieldSignature.getName();
    Field field = fieldSignature.getField();
    field.setAccessible(true);
    Class clazz = fieldSignature.getFieldType();
    String clazzName = clazz.getSimpleName();

    Object oldValue = field.get(t);

    Log.i("MainActivity",
               "\nonFiled value = " + newValue.toString()
                    + "\ntarget = " + t.toString()
                    + "\n fieldSignature =" + fieldSignature.toString()
                    + "\nfield = " + field.toString()
                    + "\nFileName = " + fileName
                    + "\nclazzName = " + clazzName
                    + " \noldValue = " + oldValue.toString() );
}

我们看看输出

aspectj_3.png

定义切面表达式使用 args(newValue) && target(t) 它们的参数值 newValue, t,必须要和方法中的定义的对的上

public void onFiled(JoinPoint joinPoint, Object newValue, Object t)

JointPoint 信息
在 advice 中我们可以拿到 JointPoint 的信息，一般包含

• JointPoint 对象信息：例如参数、前面之类的

JoinPoint.getSignature() 包含有

1. MethodSignature 方法的签名
2. FieldSignature 成员变量的签名
3. ConstructorSignature 构造函数的签名
4. InitializerSignature 初始化的签名

不同的签名对应不同的场景

• JointPoint 源代码部分的信息，例如类型、所处的位置
• JointPoint 静态部分信息

例子：

@Around("methodAnnotatedWithDebugTrace() || constructorAnnotatedDebugTrace()")
public Object weaveJoinPoint(ProceedingJoinPoint joinPoint) throws Throwable {
    // joint 对象信息
    MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
    String className = methodSignature.getDeclaringType().getSimpleName();
    String methodName = methodSignature.getName();
    
    // 源代码部分信息
    SourceLocation sourceLocation = joinPoint.getSourceLocation();
    String fileName = sourceLocation.getFileName();
    int line = sourceLocation.getLine();
    String soucreClassName = sourceLocation.getWithinType().getName();
    DebugLog.log(className, "\nfileName = " + fileName + "\nline = " + line + "\nsoucreClassName = " + soucreClassName);
        
    // 静态部分
    JoinPoint.StaticPart staticPart = joinPoint.getStaticPart();
        
return result;
}

更详细的信息参考文档
https://www.eclipse.org/aspectj/doc/released/runtime-api/index.html

总结一下，使用 AspectJ 的步骤：

1. 设置 Pointcut 的表达式
2. 选择相应的 advice
3. 对 JointPoint 或参数进行相应的处理

三、AspectJ 集成在 Android studio 中

前面已经介绍完了 AspectJ, 那接下来看看在 Android 中的实际使用；
实例代码是在这个例子上进行修改的Android-AOPExample。

1. Library 库依赖方式使用

项目的结构如下

aspectj_4.png

在 library 项目 gintoinc 的 build.gradle 文件要添加 aspectj 的依赖

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

apply plugin: 'com.android.library'

repositories {
  mavenCentral()
}

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

android {
  compileSdkVersion 21
  buildToolsVersion '21.1.2'

  lintOptions {
    abortOnError false
  }
}

// -showWeaveInfo，输出编织过程信息
// -1.5 设置规范1.5，匹配java1.5
// -inpath class文件目录或者jar包， 源字节码，需要处理的类
// -aspectpath  定义的切面类
// -d 存放编辑产生的class文件
// -classpath ，所有class文件，源class，java包，编织时需要用到的一些处理类
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;
      }
    }
  }
}

在引用库工程的工程 build.gradle 也要进行相应的配置

import org.aspectj.bridge.IMessage
import org.aspectj.bridge.MessageHandler
import org.aspectj.tools.ajc.Main

buildscript {
  repositories {
    mavenCentral()
  }
  dependencies {
    classpath 'org.aspectj:aspectjtools:1.8.1'
  }
}

apply plugin: 'com.android.application'

repositories {
  mavenCentral()
}

dependencies {
  compile project(':gintonic')
  compile 'org.aspectj:aspectjrt:1.8.1'
}

android {
  compileSdkVersion 21
  buildToolsVersion '21.1.2'

  defaultConfig {
    applicationId 'android10.org.viewgroupperformance'
    minSdkVersion 15
    targetSdkVersion 21
  }

  lintOptions {
    abortOnError true
  }
}

final def log = project.logger
final def variants = project.android.applicationVariants

variants.all { variant ->
  if (!variant.buildType.isDebuggable()) {
    log.debug("Skipping non-debuggable build type '${variant.buildType.name}'.")
    return;
  }

  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", project.android.bootClasspath.join(File.pathSeparator)]
    log.debug "ajc args: " + Arrays.toString(args)

    MessageHandler handler = new MessageHandler(true);
    new Main().run(args, handler);
    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:
          log.warn message.message, message.thrown
          break;
        case IMessage.INFO:
          log.info message.message, message.thrown
          break;
        case IMessage.DEBUG:
          log.debug message.message, message.thrown
          break;
      }
    }
  }
}

文章Aspect Oriented Programming in Android 是通过注解去查看方法执行的时间，我们在这个基础上进行修改，去监听一个成员变量赋值变化的监听。

我们需要监听 MainActivity 中 mTest

private int mTest = -1;
@Override
protected void onResume() {
    super.onResume();
    Log.i(TAG, "--- onResume---");
    mTest = 100;
}

第一步. 设置 Pointcut 的表达式
在 TraceAspect.java中

 //　set field 的切面
    private static final String POINTCUT_FILEED =
            "set(int org.android10.viewgroupperformance.activity.MainActivity.mTest) && args(newValue) && target(t)";
            

根据 JoinPoint 的选择策略和 Pointcut 的语法对应关系，成员变量选择的 set, 参数传递的监听使用 args(newValue) && target(t)

第二步. 选择相应的 advice

@Before(POINTCUT_FILEED)
public void onFiled(JoinPoint joinPoint, Object newValue, Object t) throws IllegalAccessException {
    
    ...
    
}

这里我们选择的是 Before, 注意在第一步 args(newValue) && target(t) 中的 newValue 和 t 是要在 advice 函数中定义的 Object newValue, Object t.

第三步. 对 JointPoint 或参数进行相应的处理

@Before(POINTCUT_FILEED)
public void onFiled(JoinPoint joinPoint, Object newValue, Object t) throws IllegalAccessException {

    FieldSignature fieldSignature = (FieldSignature) joinPoint.getSignature();
    String fileName = fieldSignature.getName();
    Field field = fieldSignature.getField();
    field.setAccessible(true);
    Class clazz = fieldSignature.getFieldType();
    String clazzName = clazz.getSimpleName();

    // 获取旧的值
    Object oldValue = field.get(t);

    Log.i("MainActivity",
               "\nonFiled value = " + newValue.toString()
                    + "\ntarget = " + t.toString()
                    + "\n fieldSignature =" + fieldSignature.toString()
                    + "\nfield = " + field.toString()
                    + "\nFileName = " + fileName
                    + "\nclazzName = " + clazzName
                    + " \noldValue = " + oldValue.toString() );
    
}

通过 JoinPoint 获取相应的信息。

在 build 之后，在 app/intermediates/classes/debug 目录下的

aspectj_5.png

MainActivity.class 文件中

protected void onResume() {
    super.onResume();
    Log.i("MainActivity", "--- onResume---");
    byte var1 = 100;
    JoinPoint var3 = Factory.makeJP(ajc$tjp_2, this, this, Conversions.intObject(var1));
    TraceAspect.aspectOf().onFiled(var3, Conversions.intObject(var1), this);
    this.mTest = var1;
}

我们发现上面生成了一下代码，这些生成的代码就是 AspectJ 根据我们前面设置的 Pointcut 和 adive 生成的。

输出
在 build 之后，在 app/intermediates/classes/debug 目录下的

<img src="AspectJ在Android中的使用/aspectj_3.png" width="70%" height="100%">

2. Plugin 插件方式使用

如果是多个 Module 都依赖 AspectJ, 可以写成 plugin 插件的型式

aspectj_6.png

关于如果使用 Android studio 的 Plugin 插件，可以去查看相关资料

项目的 build.gradle

buildscript {
    repositories {
        mavenCentral()
        // 本地仓库
        maven {
            url uri('repo')
        }
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:2.1.0'
        // 引入插件
        classpath 'com.yxhuang:autotrack.android:1.0.1'
    }
}

allprojects {
  repositories {
    mavenCentral()
      maven {
          url 'https://maven.google.com/'
          name 'Google'
      }
  }
}

//task wrapper(type: Wrapper) {
//  gradleVersion = '2.12'
//}
task clean(type: Delete) {
    delete rootProject.buildDir
}

gintonic 的 build.gradle 文件

buildscript {
  repositories {
    mavenCentral()
    //　本地代码仓
    maven{
      url uri('../repo')
    }
  }
  dependencies {
    classpath 'com.android.tools.build:gradle:2.1.0'
    classpath 'com.yxhuang:autotrack.android:1.0.1' // 引用插件
  }
}

apply plugin: 'com.android.library'
apply plugin: 'com.yxhuang.android' // 引用插件

repositories {
  mavenCentral()
}

dependencies {
}

android {
  compileSdkVersion 21
  buildToolsVersion '21.1.2'

  lintOptions {
    abortOnError false
  }
}

app module 的 build.gradle 文件

apply plugin: 'com.android.application'
apply plugin: 'com.yxhuang.android'  //引入插件

buildscript {
  repositories {
    mavenCentral()

    //　本地代码仓
    maven{
      url uri('../repo')
    }
  }
  dependencies {
    classpath 'com.yxhuang:autotrack.android:1.0.1' //引入插件
  }
}

repositories {
  mavenCentral()
}

dependencies {
  compile project(':gintonic')
}

android {
  compileSdkVersion 21
  buildToolsVersion '21.1.2'

  defaultConfig {
    applicationId 'android10.org.viewgroupperformance'
    minSdkVersion 15
    targetSdkVersion 21
  }

  lintOptions {
    abortOnError true
  }
}

具体的代码可以去 github AndroidAopDemo 选择 tag v2 即可。

四、参考

• 1.深入理解Android之AOP
• 2.Aspect Oriented Programming in Android
• 3.《Android 全埋点解决方案》第 8 章，AppClick 全埋点方案5：AspectJ
• 4.极客时间专栏《Android 开发高手课》第 27 讲， 编译插桩的三种方法： AspectJ, ASM, ReDex
• 5.AspectJ 官方手册