Android中的面向切面编程——AspectJ框架的简单使用

什么是AOP

我们把某个方面的功能(日志功能)与其他一批对象(需要打日志的对象)进行隔离,降低这个功能与那一批对象的耦合性

接下来是面向切面编程中的几个概念,从别处拷贝来的:

  • 通知、增强处理(Advice):就是你想要的功能,也就是上面说的日志、耗时计算等。
  • 连接点(JoinPoint):允许你通知(Advice)的地方,那可就真多了,基本每个方法的前、后(两者都有也行),或抛出异常是时都可以是连接点(spring只支持方法连接点)。AspectJ还可以让你在构造器或属性注入时都行,不过一般情况下不会这么做,只要记住,和方法有关的前前后后都是连接点。
  • 切点(Pointcut):上面说的连接点的基础上,来定义切入点,你的一个类里,有15个方法,那就有十几个连接点了对吧,但是你并不想在所有方法附件都使用通知(使用叫织入,下面再说),你只是想让其中几个,在调用这几个方法之前、之后或者抛出异常时干点什么,那么就用切入点来定义这几个方法,让切点来筛选连接点,选中那几个你想要的方法。
  • 切面(Aspect):切面是通知和切入点的结合。现在发现了吧,没连接点什么事,连接点就是为了让你好理解切点搞出来的,明白这个概念就行了。通知说明了干什么和什么时候干(什么时候通过before,after,around等AOP注解就能知道),而切入点说明了在哪干(指定到底是哪个方法),这就是一个完整的切面定义。
  • 织入(weaving) 把切面应用到目标对象来创建新的代理对象的过程。

AOP框架

AspectJ

java是通过C语言编译成class文件的(javac这个工具是C写的)
AspectJ是用一个专门的编译器来代替javac去生成class文件,这样就可以在编译时做一些事情了(跟注解处理器类似,不过貌似比它更深入、彻底)

原理

就是在一个方法上加一个注解,使其在编译时生成代码,可以在方法前和方法后(称为连接点)加上业务代码比如打日志之类的
代理是发生在运行时
AspectJButterKnife都是在编译时的

使用

  1. module下的build.gradle中作如下配置
import org.aspectj.bridge.IMessage
import org.aspectj.bridge.MessageHandler
import org.aspectj.tools.ajc.Main
apply plugin: 'com.android.application'
android {
    ...
}
dependencies {
    ...
    compile 'org.aspectj:aspectjrt:1.8.1'
}
buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'org.aspectj:aspectjtools:1.8.9'
        classpath 'org.aspectj:aspectjweaver:1.8.9'
    }
}
repositories {
    mavenCentral()
}
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;
            }
        }
    }
}
  1. 自定义一个注解,用来做标记,标记在方法上(AspectJ会在编译时替代javac,在被这个注解标记的方法前后插入逻辑代码)
/**
 * Created by xuekai on 2017/12/8.
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)//这里写成RUNTIME是为了在处理逻辑代码的时候可以拿到注解的内容
public @interface BehaviorTrace {
    String value();
}
  1. 在要被处理的方法上用2中的注解注释,该方法可以被一个切点关联,关联之后可以理解为切点即该方法
    @BehaviorTrace(value = "add方法")
    public void add(View view) {
        Log.i("MainActivity", "add-->执行方法");
    }
  1. 创建一个类,用来处理切点
/**
 * Created by xuekai on 2017/12/8.
 */
@Aspect
public class BehaviorAspect {

    /**
     * 定义一个切点,用来关联一个方法,可以理解这个切点就是要处理的方法
     * execution里面描述的是这个切点关联的方法签名,用正则表达式匹配,下面这个匹配出的是 注解为@com.xk.aopdemo.aspectj.BehaviorTrace,返回值为*,方法名为*(这里的返回值和方法名都可以指定),参数为随意 的方法
     */
    @Pointcut("execution(@com.xk.aopdemo.aspectj.BehaviorTrace  * *(..))")
    public void annoBehavior() {
    }

    /**
     * 该方法对切点进行处理,参数就是切点方法
     * 该方法被Around注解,表示可以在切点前后加业务逻辑
     * Around里面的参数是annoBehavior,表示该方法处理的切点是如      
     * 上方法注解中声明的切点
     * 通过这个参数,就可以拿到方法的签名,从而拿到各种数据
     * ,调用 object = point.proceed();即可执行切点方法
     */
    @Around("annoBehavior()")
    public Object dealPoint(ProceedingJoinPoint point) throws Throwable {
        //方法执行前
        MethodSignature methodSignature = (MethodSignature) point.getSignature();
        BehaviorTrace behaviorTrace = methodSignature.getMethod().getAnnotation(BehaviorTrace.class);
        Log.i("BehaviorAspect", "dealPoint-->前" + behaviorTrace.value());
        long beagin = System.currentTimeMillis();
        //方法执行时
        Object object = null;
        object = point.proceed();
        //方法执行完成
        Log.i("BehaviorAspect", "dealPoint-->后" + behaviorTrace.value());

        return object;
    }
}

关于编译流程的猜想

代码编译时,不再用javac了,而是用AspectJ的编译器来编译,首先会找到@Aspect注解的类,然后找到被@Around注解的方法(还有其他类型的注解,现在先不考虑),开始处理切点方法,具体处理哪些方法呢?找@Around的参数,通过匹配@Pointcut的参数中的方法签名,凡是遇到该签名的方法,编译的时候都按照处理该切点方法的方式去处理
可以看看切点方法编译后的class代码

    原文作者:X_Sation
    原文地址: https://www.jianshu.com/p/4cb7e17b3100
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞