好久没有写简书了，这几天实习工作比较轻松，于是乎这一周基本处于划水状态。。。😆
不过虽然没怎么写项目，但是学习还是不能止步滴，So 我开始了一系列的 瞎折腾 ，折腾几天总算有点成果，所以趁十一假期前赶紧稍微总结一下。

这一系列的折腾起源于看到了这篇博客AOP面向切面编程 - 淘宝京东网络处理 一篇关于面向切面编程的博客 ，从中我了解到Aspect ，突然眼前一亮 ヾ(｡｀Д´｡)我擦 可以搞点事情啊！

什么是AOP呢

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
嗯咳咳~ 此段内容来自百度百科。。。
这种模式在一般的Android项目中还比较少见，但是在java web 的Spring框架中广为应用。

Android中的AOP编程

参考 aspect-oriented-programming-in-android

我们先来实现简单一个AOP模式的方法调用的调试计时器

首先编写一个注解接口

@Retention(RetentionPolicy.CLASS)                ///编译时存在
@Target({ElementType.METHOD , ElementType.CONSTRUCTOR})  ///可以注解在方法 和 构造方法上
public @interface DebugTrack {
}

然后写一个TimerWatcher的计时器工具类

public class TimerWatcher {

    private long startTime;
    private long endTime;
    private long runningTime;

    public TimerWatcher() {
//        startTime = 0;
//        endTime = 0;
//        runningTime = 0;
    }

    private void reset() {
        startTime = 0;
        endTime = 0;
        runningTime = 0;
    }

    public long start()
    {
        startTime = System.nanoTime();
        return startTime;
    }

    public long stop()
    {
        if(startTime == 0) return 0;
        endTime = System.nanoTime();
        return endTime;
    }

    public long getRunningTime()
    {
        return (startTime == 0 || endTime == 0) ? 0 : TimeUnit.NANOSECONDS.toMillis(endTime - startTime);
    }

}

接着编写一个Aspect容器类，Aspect类主要负责管理注解的处理和代码织入。

@Aspect
public class DebugTrackAspect {

    private static final String POINTCUT_METHOD = "execution(@com.sundae.aoplib.annotation.DebugTrack * *(..))";
    private static final String POINTCUT_CONSTRUCTOR = "execution(@com.sundae.aoplib.annotation.DebugTrack *.new(..))";

    @Pointcut(POINTCUT_METHOD)
    public void methodDebugTrack() {}

    @Pointcut(POINTCUT_CONSTRUCTOR)
    public void constructorDebugTrack() {}

    @Around("methodDebugTrack() || constructorDebugTrack()")
    public Object debugTrack(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        String className = methodSignature.getDeclaringType().getName();
        String methodName = methodSignature.getName();

        TimerWatcher timerWatcher = new TimerWatcher();
        timerWatcher.start();
        Object result = joinPoint.proceed();
        timerWatcher.stop();

        outputLogText(className , methodName , timerWatcher.getRunningTime());
        return result;
    }

    public void outputLogText(String className , String methodName , long time)
    {
        LogUtil.e("------------------------------------------------");
        LogUtil.e("  ClassName   : " + className                    );
        LogUtil.e("  MethodName  : " + methodName                   );
        LogUtil.e("  RunningTime : " + time                         );
        LogUtil.e("------------------------------------------------");
    }

}

注解说明

@Aspect
作用是把当前类标识为一个切面供容器读取
@Before标识一个前置增强方法，相当于BeforeAdvice的功能，相似功能的还有
@AfterReturning
后置增强，相当于AfterReturningAdvice，方法正常退出时执行
@AfterThrowing
异常抛出增强，相当于ThrowsAdvice
@After
final增强，不管是抛出异常或者正常退出都会执行
@Around
环绕增强，相当于MethodInterceptor
@DeclareParents
引介增强，相当于IntroductionInterceptor

execution切点函数

execution函数用于匹配方法执行的连接点，语法为：
execution(方法修饰符(可选) 返回类型 方法名 参数 异常模式(可选))

参数部分允许使用通配符：

• 匹配任意字符，但只能匹配一个元素
  .. 匹配任意字符，可以匹配任意多个元素，表示类时，必须和*联合使用

• 必须跟在类名后面，如Horseman+，表示类本身和继承或扩展指定类的所有类

示例中的* DebugTrack(..)解读为：
方法修饰符 无
返回类型 *匹配任意数量字符，表示返回类型不限
方法名 DebugTrack表示匹配名称为DebugTrack的方法
参数 (..)表示匹配任意数量和类型的输入参数
异常模式 不限

更多示例：

void chop(String,int)
匹配目标类任意修饰符方法、返回void、方法名chop、带有一个String和一个int型参数的方法
public void chop()
匹配目标类public修饰、返回void、方法名chop、带有一个任意类型参数的方法
public String o(..)
匹配目标类public修饰、返回String类型、方法名中带有一个o字符、带有任意数量任意类型参数的方法
public void o(String,..)
匹配目标类public修饰、返回void、方法名中带有一个o字符、带有任意数量任意类型参数，但第一个参数必须有且为String型的方法
也可以指定类：
public void examples.chap03.Horseman.(..)
匹配Horseman的public修饰、返回void、不限方法名、带有任意数量任意类型参数的方法
public void examples.chap03.man.(..)
匹配以man结尾的类中public修饰、返回void、不限方法名、带有任意数量任意类型参数的方法
指定包：
public void examples.chap03..chop(..)
匹配examples.chap03包下所有类中public修饰、返回void、方法名chop、带有任意数量任意类型参数的方法
public void examples...chop(..)
匹配examples.包下和所有子包中的类中public修饰、返回void、方法名chop、带有任意数量任意类型参数的方法可以用这些表达式替换StorageAdvisor中的代码并观察效果

更多切点函数

除了execution()，Spring中还支持其他多个函数，这里列出名称和简单介绍，以方便根据需要进行更详细的查询
@annotation()
表示标注了指定注解的目标类方法
例如 @annotation(org.springframework.transaction.annotation.Transactional) 表示标注了@Transactional的方法
args()
通过目标类方法的参数类型指定切点
例如 args(String) 表示有且仅有一个String型参数的方法
@args()
通过目标类参数的对象类型是否标注了指定注解指定切点
如 @args(org.springframework.stereotype.Service) 表示有且仅有一个标注了@Service的类参数的方法
within()
通过类名指定切点
如 with(examples.chap03.Horseman) 表示Horseman的所有方法
target()
通过类名指定，同时包含所有子类
如 target(examples.chap03.Horseman) 且Elephantman extends Horseman，则两个类的所有方法都匹配
@within()
匹配标注了指定注解的类及其所有子类
如 @within(org.springframework.stereotype.Service) 给Horseman加上@Service标注，则Horseman和Elephantman 的所有方法都匹配
@target()
所有标注了指定注解的类
如 @target(org.springframework.stereotype.Service) 表示所有标注了@Service的类的所有方法
this()
大部分时候和target()相同，区别是this是在运行时生成代理类后，才判断代理类与指定的对象类型是否匹配

逻辑运算符

表达式可由多个切点函数通过逻辑运算组成
&&
与操作，求交集，也可以写成and
例如 execution(* chop(..)) && target(Horseman) 表示Horseman及其子类的chop方法
||
或操作，求并集，也可以写成or
例如 execution(* chop(..)) || args(String) 表示名称为chop的方法或者有一个String型参数的方法
!
非操作，求反集，也可以写成not
例如 execution(* chop(..)) and !args(String) 表示名称为chop的方法但是不能是只有一个String型参数的方法

关于Aspect的注解可以参考这篇文章循序渐进之Spring AOP(6) - 使用@Aspect注解

最后我们需要在需要调试的方法上加入@DebugTrack注解

@DebugTrack
private void test(){
    ...
}

然而这样我们运行并调用此方法的时候并没有发生什么，为什么呢

我们使用Aspect的库 ， 要使用这个库不仅仅需要导包，还需要使用 AspectJ 的编译器（ajc，一个java编译器的扩展）对所有受 aspect 影响的类进行织入。

这就需要我们在app的build.gradle中增加一些配置

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

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'org.aspectj:aspectjtools:1.8.9'
        //classpath 'com.sundae.aoplib.plugin:aoplib-plugin:0.0.1'
    }
}

dependencies {
    ...
    compile 'org.aspectj:aspectjrt:1.8.9'
}

project.android.applicationVariants.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调用test方法后就会看到如下Log输出

QQ20171001-000606@2x.png

现在我们想测试哪个方法就只需要在方法上加一个@DebugTrack标签即可，是不是很方便呢😁😁😁

注意

如果我们实在Android Library中写的话则需要将gradle中的
project.android.applicationVariants.all
更改为
project.android.libraryVariants.all

扩展

当我们使用库来写这些内容的时候就很出现一个比较蛋疼的东西，那就是不仅在library的gradle文件中增加一些编译器的配置，在app的gradle中也需要增加编译器的配置，这样就有点麻烦了，要多写很多内容，不仅显得很不简洁，而且如果写的库给别人使用的话无疑增加了一些难度。

那么这种情况怎么办呢？

这种情况我们就需要编写一个gradle的插件来自动完成这些工作了。
那如何编写这个插件呢?别急 ，我还没写。。。

先上一波我的源码(GitHub)一个Android的AOP面向切面编程的小例子

Android AOP面向切面编程和Gradle插件编写(二)

ps：菜鸟上路，有问题的地方请多指教😁