目录
前言
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中
- 新建android module命名为aspectj
目录结构
- 在aspectJ module中添加jar包依赖
repositories {
mavenCentral()
}
dependencies {
api 'org.aspectj:aspectjrt:1.8.9'
}
- 在aspectJ module中添加classpath依赖
buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath 'org.aspectj:aspectjtools:1.8.9'
}
}
- 在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;
}
}
}
}
- 在app module中添加aspect module依赖
dependencies {
api project(':aspectj')
}
- 同样需要在app module下添加classpath依赖和gradle执行脚本
gradle配置参考文章：Aspect Oriented Programming in Android
AspectJ初体验
我们现在使用AspectJ来实现我们上面说到的方法统计
- 新建一个注解类BehaviorTrace
这是一个运行时注解。虽然我们在编译期间就完成了代码的注入，但是我们将我们的注解保留到运行时，以便于获取注解中的value
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface BehaviorTrace {
String value();
}
- 在需要统计耗时的方法上加上BehaviorTrace注解
@BehaviorTrace("摇一摇")
public void shake(View btn) {
Log.i(TAG, "摇一摇...");
//模拟执行耗费时间的代码
SystemClock.sleep(20);
}
- 编写切面类
我们先尝试跟着注释理解一下代码，稍后还会做更详细地介绍
@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;
}
}
- 运行程序
我们只在shake方法上加上了注解，并没有在方法中添加其他代码，但是却完成了方法耗时统计。如果还有别的方法需要进行统计，我们同样只需要在方法上加上注解就可以了
运行结果
使用AspectJ实现方法统计不仅代码优雅，侵入性非常低，还可以将业务代码和相关功能代码在不同的模块中进行管理
- 查看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，通过正确的切点表达式找准切入点
网友评论