What?

As we all know，在进行项目构建时，追求各模块高内聚，模块间低耦合。然而现实并不总是如此美好，某些通用功能是横跨并嵌入到其他各模块中的。比如日志打印、方法的执行时间统计、参数校验等。这些功能星罗棋布得分散在项目工程中，既不方便统一管理，也不利于后期维护。

如何对这些零散却通用的功能做一些优化处理呢？ AOP（Aspect-Oriented Programming），为我们提供了一种新的思路。AOP翻译成中文是面向切面编程，其与OOP一样，是一种编程范式。如果说OOP是把问题划分到单个模块的话，那么AOP就是把涉及到众多模块的某一类问题进行统一管理。AOP可通过预编译和运行时动态代理的方式实现，从而更好地组织工程和代码结构，AOP的实现原理如图1所示。

图1 AOP实现原理

AOP已广泛应用于服务端编程，并取得了巨大的成功，如大名鼎鼎的Spring框架。而在本文中，我们将AOP引入Android工程，用以解决开篇提到的编程痛点。阅读完本文后便会发现，AOP在Android项目中同样可以做一些有趣的事。

Where?

AOP在Android工程中能用在哪？或者说能用AOP来做什么？下面列举了一些使用场景：

• 日志记录；
• 持久化；
• 性能监控；
• 方法的参数校验；
• 缓存；
• 权限检查：业务权限（如登陆，或用户等级）、系统权限（如拍照定位）。
• 其他更多

当然，用AOP还可以实现一些具体的业务需求。

How?

介绍了这么多AOP的概念，那么如何进行具体应用呢？下面介绍几种现有的工具和类库，可以很方便地实现AOP编程。

• AspectJ 一种基于JavaTM编程语言的面向切面编程无缝扩展，适用Android，编译期织入目标字节码文件中，实现无缝侵入。
• Javassist for Android 知名Java类库Javassist的Android平台移植版，同样操作字节码文件。
• DexMaker 在Dalvik VM上编译期或运行时生成目标代码的Java API。
• ASMDEX 一个类似ASM的字节码操作库，运行在Android平台，操作字节码文件。

琳琅满目的兵器库中，当然要选择一件最趁手的，就是AspectJ了。选择AspectJ的具体原因主要有三点：1、功能强大，能满足大部分需求；2、支持编译期和加载时代码注入，无侵入实现；3、易于使用。

AspectJ是一种几乎和Java完全一样的语言而且完全兼容Java。使用AspectJ有两种方法，除了使用AspectJ的语法之外，还支持原生Java。然而，无论使用哪种方法，最后都需要AspectJ的编译工具ajc来实现编译，由于AspectJ实际上脱胎于Java，所以ajc工具也能编译Java源码。

AspectJ支持编译期和加载时代码注入，可以理解为是一种Hook。在开始之前，我们先看几个关键词：Join Point、Pointcut、Advice、Aspect、Weaving。这几个关键词在AspectJ中的抽象关系如图2所示。

图2 AspectJ中各组件的抽象关系

接下来详细阐述各个关键词的含义和作用。

• Join point: 程序中可能作为代码注入目标的特定的入口。通俗来说就是可能被我们Hook的入口，这个入口可以是方法调用、执行、某个变量、类初始化、异常处理等，Join Point的常用类型如表所示。

• Pointcut: 告诉代码注入工具，在何处注入一段特定代码的表达式。可以将Ponitcut理解为Join Point的过滤规则，通过过滤规则筛选出一些特定的Join Point。
  举个Pointcut的栗子可能更容易说明问题：

public pointcut test call(public * *.method(…)) && !within(A);

• 第一个public：表示该pointcut的访问权限是public的，这与AspectJ的继承关系有关，属于AspectJ的高级语法，涉及到的应用场景较少，此处暂不讨论；
• pointcut：关键字，表示该语句是一个pointcut；
• test：pointcut可分为具名和匿名两种形式，考虑方便调用起见，建议使用具名的方式。namedPointcut的冒号后面部分是真正pointcut的内容，也就是筛选规则；
• call：表示选择的Join point是一种“方法调用”类型，对应表一的method call，下表展示了常用的Pointcut类型；

Pointcut的过滤规则语法内容较多，规则如下：

@注解(可选) 访问权限(可选) 返回值的类型 包名.函数名(参数)

• 第二个public：表示的是目标Join Point的访问权限，为可选项，如目标Join Point是一个方法，则该方法的访问类型为public。如果不设置，则默认所有访问权限(public|protected|defult|private)都匹配；
• **.method(..)：第一个*表示的是方法返回值类型，此处为任意类型。第二个*表示完整的类名，此处为任意包名和类名。method表示方法名称，..表示参数类型和参数个数，此处意为任意类型和任意参数个数。包名.方法名用于查找匹配的方法，可以使用通配符。包括*和..和+。其中*匹配除.之外的任意字符，而..则匹配某个包下的任意子包，+匹配某个类的任意子类。举些栗子：

com.*.util：可以表示com.netease.util，也可以表示com.google.util；
com.netease.*AOP，可以表示com.netease.AndroidAOP，也可以表示com.neteast.JavaAOP；
com..*表示com包中任意子包下的任意子类；
com..*AOP+表示com包下任意子包下以AOP结尾的子类，如AndroidAop的子类；

方法参数也有相应的匹配规则：

(int, String)：表示第一个参数为int，第二个参数为String；
(int, ..)：表示第一个参数为int，后面参数任意数量和类型；
(String …)：表示不定参数，且类型都为String；
(..)：表示任意数量和类型的参数；

• !within(A)：这是对Join Point的附加筛选。与Java语法相似，!代表非逻辑，within(A)表示某个包或类中的所有Join Point，此处为类A中所有Join Point。常用的附加筛选条件如表所示。

所以，总结起来，上文的Pointcut的栗子的语义就是：

选择那些任意包名和类名的&&访问权限为public的&&方法名为method的&&参数任意的方法作为目标Join Point。但需要排除class A中的所有Join Point。

• Advice: 典型的 Advice 类型有 before、after 和 around，分别表示在目标方法执行前、执行后和完全替代目标方法执行的代码。Advice的作用就是，在Pointcut筛选出特定的执行点和入口，做真正的Hook操作。常见的Advice类型如表所示。

• Aspect: Pointcut 和 Advice的组合可看做切面Aspect，这是一个抽象的概念，理解即可。例如，我们在应用中通过定义一个 Pointcut 和给定恰当的Advice，添加一个日志切面，将该切面切入原有的业务代码中。
• Weaving: 注入代码（Advices）到目标位置（Join points）的过程，由编译器ajc完成。

引入AOP的栗子

在项目中引入AOP的方式共有三种，分别是原生AspectJ语言，在Java代码中使用AspectJ，结合自定义注解的方式在Java代码中使用AspectJ。考虑到易用性和非侵入性，本栗子的方式是在Java代码中使用AspectJ，在不修改业务代码的前提下，实现onCreate方法性能的监控。

首先考虑未引入AOP的情形，我们如何完成对业务代码的性能监控。

public class MainActivity extends AppCompatActivity
        implements NavigationView.OnNavigationItemSelectedListener {
    private static final String TAG = MainActivity.class.getSimpleName();
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        TimeWatcher watcher = new TimeWatcher();
        watcher.start();

        initView();

        watcher.stop();
        Log.i(TAG, "onCreate execute with " + watcher.getTotalTime() + "ms");
    }

很容易可以发现，业务代码和性能监控的功能性代码交织在一起，结构不清晰，耦合度较高。而且更关键的是，每当一处业务代码需要做性能统计，就需要把统计代码重新复制一份。后期如果需要修改性能统计代码的逻辑，比如修改统计日志内容、增加日志上传功能，需要找到每一处引用到的代码进行修改，这样无疑增加了工作量和出错的概率。

引入AOP可以很好地剥离项目中业务代码和性能统计代码。首先创建aspect Module，引入AspectJ的相关类库，并构建主类和辅助类，项目结构如图3所示。

图3 项目结构

在aspect这个module下新建一个Java类。

@Aspect
public class TimeWatchAspect {
    private static final String POINTCUT_TIME_WATCH =
            "execution(* com.netease.aopdemo.MainActivity.onCreate(..))";

    @Pointcut(POINTCUT_TIME_WATCH)
    public void timeWatch() {}

    @Around("timeWatch()")
    public Object weaveJoinPoint(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature ms = (MethodSignature) joinPoint.getSignature();
        String methodName = ms.getName();
        String className = ms.getDeclaringType().getSimpleName();

        TimeWatcher watcher = new TimeWatcher();
        watcher.start();
        Object result = joinPoint.proceed();
        watcher.stop();

        Log.i(className, methodName + " execute with " + watcher.getTotalTime() + "ms");

        return result;
    }
}

打上@Aspect注解，则该类可以被ajc编译器识别为一个Asepct，在工程项目编译时便能非常方便地实现代码织入。图5中可以看到AspectJ的三个要素，Join Point、Advice和Aspect。好像少了Join Point？Join Point早已定义在Pointcut的字符串常量中，即MainActivity的onCreate方法。Pointcut以注解的形式定义，注解了timeWatch方法，从而timeWatch就是这个Pointcut的名称，注解参数则使用定义好的字符串常量，作为Join Point的过滤规则。同样，Advice也是将类型关键字(此处为Around)注解在特定的方法weaveJoinPoint之上，注解的参数为具名的Pointcut，即timeWatch。上文提到Around类型即用该方法替换原Join Point的实现，图5中Object result = joinPoint.proceed()等价于原有的被Hook方法，即MainActivity的onCreate()。在该语句的前后，是性能统计的代码片段。

public class MainActivity extends AppCompatActivity
        implements NavigationView.OnNavigationItemSelectedListener {
    private static final String TAG = MainActivity.class.getSimpleName();
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        initView();
    }

再看一眼我们重构后的业务代码，仅需要专注于业务逻辑处理，是不是变得非常简洁。

编译并运行项目代码后，结果如图4所示。

图4 AOP运行结果

那么ajc编译器在字节码层面到底做了什么呢？

  protected void onCreate(Bundle paramBundle)
  {
    JoinPoint localJoinPoint = Factory.makeJP(ajc$tjp_0, this, this, paramBundle);
    TimeWatchAspect.aspectOf().weaveJoinPoint(new MainActivity.AjcClosure1(new Object[] { this, paramBundle, localJoinPoint }).linkClosureAndJoinPoint(69648));
  }


  public class MainActivity$AjcClosure1 extends AroundClosure
{
  public MainActivity$AjcClosure1(Object[] paramArrayOfObject)
  {
    super(paramArrayOfObject);
  }

  public Object run(Object[] paramArrayOfObject)
  {
    Object[] arrayOfObject = this.state;
    MainActivity.onCreate_aroundBody0((MainActivity)arrayOfObject[0], (Bundle)arrayOfObject[1], (JoinPoint)arrayOfObject[2]);
    return null;
  }
}

反编译项目生成的apk后可以看到，ajc在Join Point处织入了代码，用TimeWatchAspect.aspectOf().weaveJoinPoint()实现了替换。

踩过的坑

正所谓人不能两次踏进同一条河流，我踩过的坑希望大家可以避免。
由于AspectJ在字节码层面将功能性代码织入业务代码中，源码层面无法看到变化，且无法在功能性代码中进行断点调试。所以一旦出错，调试成本相对较高。如果项目运行结果与预期不符，首先检查编译问题，能否正常实现代码织入(可以看apk中的class文件树结构)，再检查Join Point、Pointcut和Advice是否符合AspectJ语法，Hook是否正确。

如果Android Studio中的Instant Run开启，则在编译时可能会影响代码的正常织入，所以建议关闭Instant Run。

另外，一般初级阶段会选择日志打印的方式验证AspectJ接入的可行性。如果测试机是魅族系列手机，则注意把项目中Log等级提升到D以上，或者在手机的开发者选项中选择显示所有等级的日志，否则默认情况下你看不到D及D以下等级日志的输出（惨痛的教训，浪费了两天时间排查问题）。

总结

本文主要介绍了Android AOP的编程思想和应用场景，AOP这种编程范式已经在服务端取得了成功，我相信在Android客户端编程中，也一样可以有用武之地。通过AspectJ这种工具可以很方便地实现AOP编程，在文中重点介绍了AspectJ的语法和使用方式，并以实例的方式展示了如何通过AspectJ重构代码，降低了耦合度并利于后期维护。最后介绍了我自己踩过的坑，避免重复入坑。AOP是一种编程思想，理解并运用到工程中将会大有裨益，AspectJ同样是非常强大的工具，文中只介绍了一些基本用法，还有很多高级特性待探索和实践。只要脑洞够大，一定能实现一些意想不到的效果。最后，希望我的文章能给大家带来一些启发，在今后的开发过程中，可以用AOP来做一些exciting的事情。

参考文章

1. http://fernandocejas.com/2014/08/03/aspect-oriented-programming-in-android/
2. https://blog.egorand.me/going-aspect-oriented-with-aspectj-and-google-analytics/
3. http://blog.csdn.net/innost/article/details/49387395

Demo源码

https://github.com/Master-Neo/AopDemo