Android AOP编程入门

最近在工作中遇到了需要对用户的行为信息进行采集的需求（包括打开APP的时间，功能页面停留时间，全局捕获异常，点击事件收集等），如果使用我们传统的编程方式实现以上功能的话是完全没有问题，但是在使用时就会发现如果要监听每一个功能页，每一个点击事件时就需要写很多重复的代码，这样不仅代码显得臃肿，如果后期更改也会是很麻烦。所以就了解到了使用AOP的方式来实现。

我们先来了解一下什么是AOP：

AOP是Aspect-Oriented Progreming的缩写，即面向切面编程。在OOP设计中有个单一职责原则，在很多时候都不会有问题，但是当很多模块都需要同一个功能的时候，这个时候还用OOP就会很麻烦。那么AOP在Android中的应用就应运而生。

看了以上解释会发现对于AOP还是一脸懵 *，其实AOP和我们平常所说的OOP（面向对象）编程一样都是一种编程的设计理念。那么在实际项目中我们要怎么运用AOP呢，其实前辈大神们已经把他封装成了许多的工具或库。如下：

AspectJ: 一个 JavaTM 语言的面向切面编程的无缝扩展（适用Android）。
Javassist for Android: 用于字节码操作的知名 java 类库 Javassist 的 Android 平台移植版。
DexMaker: Dalvik 虚拟机上，在编译期或者运行时生成代码的 Java API。
ASMDEX: 一个类似 ASM 的字节码操作库，运行在Android平台，操作Dex字节码。

本篇我们将介绍 AspectJ的基本使用。

AspectJ语法

配置项目中APP下gradle文件，配置如下：

//下面这些代码块都是与android代码块同级
buildscript{
    repositories{
        mavenCentral()
    }

    dependencies{
        classpath 'org.aspectj:aspectjtools:1.8.9'
        classpath 'org.aspectj:aspectjweaver:1.8.9'
    }
}
import org.aspectj.bridge.IMessage
import org.aspectj.bridge.MessageHandler
import org.aspectj.tools.ajc.Main

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.8",
                         "-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
            }
        }
    }
}

android {//android块中代码配置不变  此处我们省略部分代码
      ***
}

dependencies {
        ***
        implementation 'org.aspectj:aspectjrt:1.8.9'
}

Aop术语

通知（Advice）：即想要实现的功能以及什么时候执行
连接点（joinPoint）：连接点即接入通知的地方，连接点是一个概念，在代码中比如一个方法的调用，执行结束等都是一个连接点。
切入点（Pointcut）: 可以理解为对连接点的筛选，因为连接点只是一个概念，每个方法都可以是一个连接点，切入点就是选出一个或多个连接点来执行我们的通知。（PS：如果是第一次接触AOP的话，看概念是很不理解的，下面我们会通过代码来实现）
切面（Aspect）: 切面是通知和切入点的集合。定义的通知与切入点必须是在切面中的。

AOP注解

AspectJ在android中使用是通过注解的方式来实现的

声明切面：@Aspect
切入点：@Pointcut(切点表达式) ，后面我们会接受切点表达式
通知：通知有多种，如前置通知@Before、后置通知@After 、环绕通知@Around、返回通知@AfterReturning、异常通知@AfterThrowing。通知的使用与切入点类似，也是必须定义切点表达式。也可使用已经标记为切入点的方法名。

切面表达式

切面表达式可以理解为筛选规则，比如想要在Activity的onCreate方法执行开始时打印Log，就可以使用切面表达式。首先我们选收一下Pointcut语法就是匹配规则

call(MethodSignature)：表示方法被调用。
call(ConstructorSignature) ：表示构造函数被调用。
execution(MethodSignature)：表示方法内部执行。
execution(ConstructorSignature)：表示构造函数内部执行。
get(FieldSignature)：读变量，就是获取某个变量值时会触发该规则。
set(FieldSignature)：设置变量，为某个变量设置值时会触发该规则。
staticinitialization(TypeSignature)：静态代码块初始化（PS：在测试时，类中并没有静态代码块时还是会触发该规则）。
handler（TypeSignature）：匹配catch 到的异常。

接下来介绍MethodSignature、ConstructorSignature、FieldSignature、Type Signature这几个表达式的规则

MethodSignature：

@注解 访问权限 返回值的类型 包名.函数名(参数)  
  @注解和访问权限（public/private/protect，以及static/final）属于可选项。如果不设置它们，则默认都会选择。以访问权限为例，如果没有设置访问权限作为条件，那么public，private，protect及static、final的函数都会进行搜索。  
  返回值类型就是普通的函数的返回值类型。如果不限定类型的话，就用*通配符表示  
  包名.函数名用于查找匹配的函数。可以使用通配符，包括*和..以及+号。其中*号用于匹配除.号之外的任意字符，而..则表示任意子package，+号表示子类。  
     比如：  
     java.*.Date：可以表示java.sql.Date，也可以表示java.util.Date  
     Test*：可以表示TestBase，也可以表示TestDervied  
     java..*：表示java任意子类  
     java..*Model+：表示Java任意package中名字以Model结尾的子类，比如TabelModel，TreeModel  
     等  
  最后来看函数的参数。参数匹配比较简单，主要是参数类型，比如：  
     (int, char)：表示参数只有两个，并且第一个参数类型是int，第二个参数类型是char  
     (String, ..)：表示至少有一个参数。并且第一个参数类型是String，后面参数类型不限。在参数匹配中，  
     ..代表任意参数个数和类型  
     (Object ...)：表示不定个数的参数，且类型都是Object，这里的...不是通配符，而是Java中代表不定参数的意思

ConstructorSignature：

Constructorsignature和Method Signature类似，只不过构造函数没有返回值，而且函数名必须叫new。比如：  
public *..TestDerived.new(..)：  
  public：选择public访问权限  
  *..代表任意包名  
  TestDerived.new：代表TestDerived的构造函数  
  (..)：代表参数个数和类型都是任意

Field Signature

Field Signature标准格式：  
@注解 访问权限 类型 类名.成员变量名  
  其中，@注解和访问权限是可选的  
  类型：成员变量类型，*代表任意类型  
  类名.成员变量名：成员变量名可以是*，代表任意成员变量  
比如，  
set(inttest..TestBase.base)：表示设置TestBase.base变量时的JPoint

Type Signature

Type Signature：
staticinitialization(test..TestBase)：表示TestBase类的static block  
handler(java.lang.NullPointerException)：表示catch到NullPointerException的JPoint。

上面说了一大堆，看完肯定是一脸懵*，接下来我们用代码来解释

切面的定义

@Aspect
public class AspectJTest {
    
}

上面代码就是定义了一个切面，是不是发现很简单，然后接下来的通知与切入点就是在切面中定义。下面接着看。

切入点定义

@Aspect
public class AspectJTest {
    @Pointcut("execution(* com..MainActivity.onCreate(..))")
    public void executionAspectJ() {
    }
}

上面代码中在切面中定义一个切入点，该切入点为MainActivity的onCreate方法。结合上面表达式规则，上面的表达式省略了注解和访问权限，返回类型为通配符，然后类名为com包下任意包的MainActivity类，然后方法中的参数为热议参数个数和类型。使用的execution表示在onCreate方法执行内部切入。（PS：上面定义方法为public，这个并不是固定，其他修饰符均可，包括static，建议使用 public）
接下来就是通知了。

通知定义

@Aspect
public class AspectJTest {
    @Pointcut("execution(* com..MainActivity.onCreate(..))")
    public void executionAspectJ() {
    }

    @Around("executionAspectJ()")
     public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        Log.d("AspectJText", "onCreate开始执行了" + joinPoint);
        joinPoint.proceed();//调用原生方法
        Log.d("AspectJText", "onCreate执行完了" + joinPoint);
    }
}

上面代码中使用@Around注解的便是通知，通知用来控制切入点的时机，所以注解中的表达式为切入点方法名，上面整体通知的意思就是在onCreate方法内部的开始与结束打印Log。
都注意到了通知方法中的参数ProceedingJoinPoint ，其实是由于@Around的特殊性，@Around环绕通知会拦截原方法内容的执行，必须手动调用代码中 joinPoint.proceed() 方法，否则会报错，在使用其他通知类型时，参数是JoinPoint 类，这个参数包含了切点的所有信息，如类方法名，方法中的参数等。方法中的参数可通过如下方法获取：

Object[] args = joinPoint.getArgs();//这里会获取一个数组  数组中便是方法中的参数。

接下来再看看其他的通知与切入点使用的示例：

@Aspect
public class AspectjTest {
    String Tag = "AspectJ"
    @Pointcut("execution(* com..MainActivity.onCreate(..))")
    public void executionAspectJ() {

    }

    @Pointcut("execution(* android.view.View.OnClickListener.onClick(..))")
    public void buttonAspectj() {

    }

    //call适合自定义的方法  系统级的方法暂时无效 可能是调用的不对
    @Pointcut("call(* com..MainActivity.call(..))")
    public void callAspectJ() {

    }

    @Pointcut("set(String com..MainActivity.aopFlag)")
    public void setFields() {

    }

    @Pointcut("get(String com..MainActivity.aopFlag)")
    public void getFields() {

    }

   @Pointcut("staticinitialization(com..Test)")
    public void staticinitializations() {

    }

    @Pointcut("handler(java.lang.NullPointerException)")
    public void cacheErr() {

    }

    @Around("executionAspectJ()")
    void aroundAspectJ(ProceedingJoinPoint joinPoint) throws Throwable {
        Log.d(Tag, "onCreate开始执行" + joinPoint);
        joinPoint.proceed();
        Log.d(Tag, "onCreate执行完" + joinPoint);
    }

    @After("buttonAspectj()")
    void afterAspectJ(JoinPoint joinPoint) {
//        View view = (View) ;
        Object[] args = joinPoint.getArgs();
        int length = args.length;
        View view = (View) joinPoint.getArgs()[0];
        Log.d(Tag, "点击方法执行完了" + joinPoint.getKind() + ",  View:" + view.getId());
    }

    @Before("callAspectJ()")
    void callTest(JoinPoint joinPoint) {
        Log.d(Tag, "call 被调用: " + joinPoint.getArgs()[0]);
    }

    @Before("setFields()")
    void setTestFields(JoinPoint joinPoint) {
        Log.d(Tag, "setFlage : " + joinPoint.getArgs()[0]);
    }

    @Before("getFields()")
    void getTestFields(JoinPoint joinPoint) throws NoSuchFieldException, IllegalAccessException {
        Class<?> aClass = joinPoint.getThis().getClass();
        Field field = aClass.getField(joinPoint.getSignature().getName());

        Log.d(Tag, "getFlage : " + field.getName());
    }

    @Before("staticinitializations()")
    void staticTest() {
        Log.d(Tag, "静态方法初始化");
    }

    @Before("cacheErr()")
    void errTest() {
        Log.d(Tag, "NullPointerException");
    }
}

关于Get 规则，使用set时，可以获取到设置的值，然后使用get没有获取的，还望大神指点。
关于staticinitializations规则，该规则的匹配是某个类的静态代码块，测试时发现这个类没有定义静态代码块时也会匹配到。
关于handler规则，该规则是捕获异常信息的，如果定义的为NullPoinerException，就只能匹配到NullPoinerException的错误，其他的是错误是无法匹配的。使用handler时，不能使用after与Around。这点也要注意。

参考资料
1
2
3

渣渣一枚，以上如有不对之处还望指正（抱拳）。