Android AOP — AspectJ的使用

目录

前言

AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，它有一个专门的编译器（ajc）用来生成遵守Java字节编码规范的Class文件

有关AOP的概念不是很清楚的可以看：https://www.jianshu.com/p/c40528c8df17

为什么要使用AspectJ

在使用Aspectj之前，先来看下面这么一个例子，以便于我们理解我们为什么要使用它

最近项目在做性能优化，需要统计一些方法的的耗时，那我们一般会这么去做

    public void parserHtml() {
        long currentTimeMillis = System.currentTimeMillis();
       
        //下面省略解析html的业务代码
        .........
      
        long time = System.currentTimeMillis() - currentTimeMillis;
        System.out.println("parserHtml方法耗时：" + time + "ms");
    }

但是如果我们有很多方法都需要做耗时统计呢，如果这些统计策略随着产品需求所改变呢。难道我们需要在每个方法中的前后都手动编写这样的统计代码？这样的写法不仅会产生代码的重复，同时也给代码的维护工作造成了麻烦。所以这时候我们就要用到AOP这种面向切面编程的思想来进行程序设计

AspectJ提供了相应的方法，可以帮助我们方便快捷的在编译期对方法前后进行代码插桩，从而实现业务需求和功能需求的解耦

AspectJ集成步骤

在实际项目中，我们往往会把AspectJ相关的代码单独放到一个module中

1. 新建android module命名为aspectj

目录结构

2. 在aspectJ module中添加jar包依赖

repositories {
    mavenCentral()
}
dependencies {
    api 'org.aspectj:aspectjrt:1.8.9'
}

3. 在aspectJ module中添加classpath依赖

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

4. 在aspectJ module中添加gradle执行脚本

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

android.libraryVariants.all { variant ->
    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)
        ]

        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;
            }
        }
    }
}

5. 在app module中添加aspect module依赖

dependencies {
    api project(':aspectj')
}

6. 同样需要在app module下添加classpath依赖和gradle执行脚本

app/build.gradle完整代码

aspectj/build.gradle完整代码

gradle配置参考文章：Aspect Oriented Programming in Android

AspectJ初体验

我们现在使用AspectJ来实现我们上面说到的方法统计

1. 新建一个注解类BehaviorTrace

这是一个运行时注解。虽然我们在编译期间就完成了代码的注入，但是我们将我们的注解保留到运行时，以便于获取注解中的value

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface BehaviorTrace {
    String value();
}

2. 在需要统计耗时的方法上加上BehaviorTrace注解

@BehaviorTrace("摇一摇")
public void shake(View btn) {
    Log.i(TAG, "摇一摇...");
    //模拟执行耗费时间的代码
    SystemClock.sleep(20);
}

3. 编写切面类

我们先尝试跟着注释理解一下代码，稍后还会做更详细地介绍

@Aspect
public class BehaviorAspect {
    private static final String POINTCUT_METHOD =
            "execution(@com.geekholt.aspectj.annotation.BehaviorTrace * *(..))";

    //任何一个包下面的任何一个类下面的任何一个带有BehaviorTrace的方法，构成了这个切面
    @Pointcut(POINTCUT_METHOD)
    public void annoHaviorTrace() {
        Log.i("geekholt", "annoHaviorTrace");
    }

    //拦截方法
    @Around("annoHaviorTrace()")
    public Object weaveJoinPoint(ProceedingJoinPoint joinPoint) throws Throwable {
        Log.i("", "weaveJoinPoint");
        //拿到方法的签名
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        //类名
        String className = methodSignature.getDeclaringType().getSimpleName();
        //方法名
        String methodName = methodSignature.getName();
        //功能名
        BehaviorTrace behaviorTrace = methodSignature.getMethod().getAnnotation(BehaviorTrace.class);
        String fun = behaviorTrace.value();

        //方法执行前
        long begin = System.currentTimeMillis();

        //执行拦截方法
        Object result = joinPoint.proceed();

        //方法执行后
        long duration = System.currentTimeMillis() - begin;
        Log.i("geekholt", String.format("功能：%s，%s的%s方法执行，耗时：%d ms", fun, className, methodName, duration));
        return result;
    }
}

5. 运行程序

我们只在shake方法上加上了注解，并没有在方法中添加其他代码，但是却完成了方法耗时统计。如果还有别的方法需要进行统计，我们同样只需要在方法上加上注解就可以了

运行结果

使用AspectJ实现方法统计不仅代码优雅，侵入性非常低，还可以将业务代码和相关功能代码在不同的模块中进行管理

6. 查看build⁩ /⁨intermediates⁩/javac目录下的文件

可以看出，aspectJ会在编译时帮我们在shake方法中插入一些代码

 @BehaviorTrace("摇一摇")
    public void shake(View btn) {
        JoinPoint var3 = Factory.makeJP(ajc$tjp_0, this, this, btn);
        BehaviorAspect var10000 = BehaviorAspect.aspectOf();
        Object[] var4 = new Object[]{this, btn, var3};
        var10000.weaveJoinPoint((new MainActivity$AjcClosure1(var4)).linkClosureAndJoinPoint(69648));
    }

AspectJ详解

相关注解介绍

• @Aspect：声明切面，标记类
• @Pointcut(切点表达式)：定义切点，标记方法
• @Before(切点表达式)：前置通知，切点之前执行
• @Around(切点表达式)：环绕通知，切点前后执行
• @After(切点表达式)：后置通知，切点之后执行
• @AfterReturning(切点表达式)：返回通知，切点方法返回结果之后执行
• @AfterThrowing(切点表达式)：异常通知，切点抛出异常时执行

@Pointcut、@Before、@Around、@After、@AfterReturning、@AfterThrowing需要在切面类中使用，即标注了@Aspect的类中

切点表达式

切点表达式的组成如下：

除了返回类型模式、方法名模式和参数模式外，其它项都是可选的。修饰符模式指的是public、private、protected，异常模式指的是NullPointException等

execution(<修饰符模式>? <返回类型模式> <方法名模式>(<参数模式>) <异常模式>?)

下面列出几个例子说明一下

• 匹配所有public方法，在方法执行之前打印"Geekholt"

@Before("execution(public * *(..))")
public void before(JoinPoint point) {
    System.out.println("Geekholt");
}

• 匹配所有以"to"结尾的方法，在方法执行之前打印"Geek"，在方法执行之后打印"holt"

@Around("execution(* *to(..))")
public void around(ProceedingJoinPoint joinPoint) {
    System.out.println("Geek");
    joinPoint.proceed();
    System.out.println("holt");
}

• 匹配com.geekholt包下及其子包中以"to"结尾的方法，在方法执行之后打印"Geekholt"

@After("execution(* com.geekholt..*to(..))")
public void after(JoinPoint point) {
    System.out.println("Geekholt");
}

• 匹配com.geekholt包下所有返回类型是int的方法，在方法返回结果之后打印"Geekholt"

@AfterReturning("execution(int com.geekholt.*(..))")
public void afterReturning(JoinPoint point, Object returnValue) {
    System.out.println("Geekholt");
}

• 匹配com.geekholt包及其子包中的所有方法，当方法抛出异常时，打印"ex = 报错信息"

@AfterThrowing(value = "execution(* com.geekholt..*(..))", throwing = "ex")
public void afterThrowing(Throwable ex) {
    System.out.println("ex = " + ex.getMessage());
}

@Pointcut的使用

@Pointcut是专门用来定义切点的，让切点表达式可以复用

你可能需要在切点执行之前和切点报出异常时做些动作（如：出错时记录日志），可以这么做：

@Before("execution(* com.geekholt..*(..))")
public void before(JoinPoint point) {
    System.out.println("Geekholt");
}

@AfterThrowing(value = "execution(* com.geekholt..*(..))", throwing = "ex")
public void afterThrowing(Throwable ex) {
    System.out.println("记录日志");
}

可以看到，表达式是一样的，那要怎么重用这个表达式呢？这就需要用到@Pointcut注解了，@Pointcut注解是注解在一个空方法上的，如：

@Pointcut("execution(* com.geekholt..*(..))")
public void pointcut() {}

这时，pointcut()就等价于execution(* com.geekholt..*(..))，那么上面的代码就可以改成这样

@Pointcut("execution(* com.geekholt..*(..))")
public void pointcut() {}

@Before("pointcut()")
public void before(JoinPoint point) {
    System.out.println("Geekholt");
}

@AfterThrowing(value = "pointcut()", throwing = "ex")
public void afterThrowing(Throwable ex) {
    System.out.println("记录日志");
}

Kotlin中使用AspectJ

虽然是kotlin和java之间可以互相调用，但是想要在kotlin中直接使用aspectJ是不会有效果的，这里推荐一个大神写的框架aspectjx，很好的支持了Kotlin，具体的使用直接看github上的文档，这里就不过多介绍啦

总结

AspectJ在Android中还可以做很多事情，比如无埋点、参数校验和判空、Android API23+权限控制、事件防抖、异常处理、缓存等等
学习AspectJ重要的是理解AOP的思想，在合适的场景下使用AOP，通过正确的切点表达式找准切入点