什么是AOP

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

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

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

AOP框架

AspectJ

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

eclipse
下载AspectJ，不用，所以说了
Android Studio
AspectJ官方关于在gradle中的使用

原理

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

使用

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

自定义一个注解，用来做标记，标记在方法上（AspectJ会在编译时替代javac，在被这个注解标记的方法前后插入逻辑代码）

/**
 * Created by xuekai on 2017/12/8.
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)//这里写成RUNTIME是为了在处理逻辑代码的时候可以拿到注解的内容
public @interface BehaviorTrace {
    String value();
}

在要被处理的方法上用2中的注解注释，该方法可以被一个切点关联，关联之后可以理解为切点即该方法

    @BehaviorTrace(value = "add方法")
    public void add(View view) {
        Log.i("MainActivity", "add-->执行方法");
    }

创建一个类，用来处理切点

/**
 * 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代码

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

什么是AOP

AOP框架

AspectJ

原理

使用

关于编译流程的猜想

你可能感兴趣的:(Android中的面向切面编程——AspectJ框架的简单使用)