AOP面向切面编程

在项目中我们经常遇见统计耗时，统计是否被点击等等需求，比如统计耗时通常的写法就是在执行的前后都加时间点。

public void sao(View view) {
        Log.d(TAG,mDateFormat.format(new Date()));
        long beagin = System.currentTimeMillis();
        SystemClock.sleep(3000);//假设这在执行操作

        long end = System.currentTimeMillis();
        Log.d(TAG,(end - beagin)+"ms");
    }

面向对象设计讲究单一性，这个方法不仅有逻辑操作还有耗时的统计，代码一旦较多就很难看。
我们就可以使用AOP(面向切面编程)来解决。使用AOP需要下载 aspectj

搭建AOP
在app/build.gradle中配置aspectj的路径

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 = null
    if (variant.hasProperty('javaCompileProvider')) {
        //gradle 4.10.1 +
        TaskProvider<JavaCompile> provider =  variant.javaCompileProvider
        javaCompile = provider.get()
    } else {
        javaCompile = variant.hasProperty('javaCompiler') ? variant.javaCompiler : 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;
            }
        }
    }
}

在项目的build.gradle中配置aspectj

把下载的aspectjrt.jar拷贝进libs目录下，其他不需要

implementation files('libs/aspectjrt.jar')

环境搭建完毕，还是很简单的。

写一个简单的demo
首先写一个注解作为切点(就是标记我需要在哪个地方使用AOP)我这里是在方法上使用

/**
 * 切点
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface BehaviorTrace {
    String value();
}

写一个切面(就是拿到我们需要的方法后怎么处理，就在这里处理)

/**
 * 切面
 * <p>
 * 通过切点切下来之后在这里处理
 */
@Aspect
public class BehaviorAspect {
    private SimpleDateFormat mDateFormat = new SimpleDateFormat();

    /**
     * 找到添加有BehaviorTrace注解的方法
     * * * 表示所有含有BehaviorTrace注解的方法
     * ..表示方法的任意参数
     */
    @Pointcut("execution(@com.example.aopdemo.BehaviorTrace * *(..))")
    public void annoBehavior() {

    }

    @Around("annoBehavior()")
    public Object dealPoint(ProceedingJoinPoint point) throws Throwable {
        //处理找到的方法
        MethodSignature signature = (MethodSignature) point.getSignature();
        //拿到方法的BehaviorTrace注解
        BehaviorTrace behaviorTrace = signature.getMethod().getAnnotation(BehaviorTrace.class);
        //拿到注解里的值
        String value = behaviorTrace.value();
        Log.d("TAG", value + "使用时间" + mDateFormat.format(new Date()));

        long beagin = System.currentTimeMillis();
        //方法执行时(找到注解对应的方法，如 MainActivity中的 yao方法，这个方法正在执行)
        Object object = point.proceed();//开始执行方法
        //方法执行完成
        long end = System.currentTimeMillis();
        Log.d("TAG", value + "消耗时间：" + (end - beagin));
        return object;
    }
}

设置需要切入的方法
@Around，@Before，@After 定义具体插入的代码

使用就很简单了

只需要在你想要的方法上添加一个注解就可以了。再也不用写耗时统计相关的代码了。

原理：
原本我们的java文件要生成class文件需要用到javac.exe,aspectJ使用的自己的javaC文件把我们的java文件编译成class文件，当然它是遵守java的编译规则的。
反编译一下生成的class文件。

@BehaviorTrace("看见")
  public void yao(View view)
  {
    View localView = view; 
    JoinPoint localJoinPoint = Factory.makeJP(ajc$tjp_1, this, this, localView);
    Object[] arrayOfObject = new Object[3];
    arrayOfObject[0] = this; arrayOfObject[1] = localView; 
    arrayOfObject[2] = localJoinPoint; 
    BehaviorAspect.aspectOf().dealPoint(new AjcClosure3(arrayOfObject).linkClosureAndJoinPoint(69648));
  }

在最后一句dealPoint调用的就是我们在切面里面实现的dealPoint方法，aspectOf()单例返回我们的BehaviorAspect对象。
而我们原有的代码它会重新帮我们实现这个方法

static final void yao_aroundBody2(MainActivity paramMainActivity, View paramView, JoinPoint paramJoinPoint)
  {
    JoinPoint paramJoinPoint;
    View paramView;
    SystemClock.sleep(3000L);
    Log.d("TAG", "看见到美女啦");
  }

当我们在dealPoint方法中调用point.proceed()的时候就会调用上面的方法。