概念
AOP(Aspect Oriented Programming)简而言之就是面向切面编程。它所要实现的目标就是解耦，提供代码的灵活性和可扩展性。
与OOP的区别
OOP(Object Oriented Programming)面对对象编程。
这其实是两种不同的设计思想：
- OOP是把同一对象的属性放到一个对象里，把同一类别的类放到一个模块里；这里同一的评判标准可以按照业务来划分，也可以通过行为来划分
- AOP则是提取相同的功能和方法，针对这样的横切面来归类。
用图来弥补下言语的匮乏：
OOP
AOP
AOP的应用领域
在Android开发过程中，我们时长遇到需要统计事件，性能监测，权限检查等需求。而这些需求是独立业务开发之外的。在业务开发过程中，开发人员不想被这些需求打扰而中断了业务逻辑的梳理。这个时候，就可以用到AOP的思想来解决问题。
- 打印日志：独立的日志模块，在业务开发后期嵌入到各个业务模块中，在代码里不存在日志相关代码。
- 性能监测：时长需要对生命周期函数，view绘制函数监测其运行时长来监测性能。但如果在代码开发阶段考虑就要，实现每个生命周期函数，在绘制view的函数中加入时间统计代码，这样不仅会导致冗余代码还会影响方法本身的性能。
- 权限检查：使方法功能单一，剥离权限检查部分。
其实，总结起来，最终的目的就是为了解耦，尽量将业务无关的，且同一类方法，功能中需要做的重复动作，提取出来。
AspectJ
AOP的实现有很多中，AspectJ只是其中一种，在Java中用得比较多。AspectJ可以说是一种语言，它完全兼容Java，使用原生的Java来开发的话，只需要加上AspectJ的注解就可以。因此两种方式：
- 通过AspectJ的关键字来实现
- 原生java+AspectJ的相关注解来开发
但是无论是通过何种方式实现，其编译都必须要通过AspectJ的编译工具ajc来编译。
AspectJ的语法
在介绍AspectJ的语法之前，先介绍几个概念，也是AspectJ中的关键字，了解他们的含义，对于开发至关重要。
- aspect(切面) 针对切面的模块。也就说独立于业务，需要被插入的部分。
- joinpoint(连接点) 顾名思义就是连接切面模块和业务模块的地方；也可以理解为就是业务模块中需要被嵌入代码的地方。
- pointcut 这个理解起来跟joinpoint应该是一个意思，只不过它可以添加一些附加条件
- advice(处理逻辑) 说逻辑处理有点牵强，它表示的意思应该是被插入的代码，以及插入的时机，如：Before，After，Around等。
常用的切入点
切入点一般是通过joinpoint和advice的组合来实现的，常用的可以看下表：
| joinpoint | advice | 切入点 |
|---|---|---|
| execution | before | 方法执行之前，切入点在方法内 |
| execution | after | 方法执行之后，切入点在方法内 |
| execution | around | 方法执行前后，可以替换原方法，切入点在方法内 |
| call | before | 方法调用之前，切入点在方法外 |
| call | after | 方法调用之后，切入点在方法外 |
| call | around | 方法调用前后，可以替换原方法，切入点在方法外 |
PS：以上是常用的一些切入点，还有通过cflow来切入每一行字节码。这个控制较难，控制不好会产生StackOverFlow，这个以后再说。
PSS: Advice的各个类型是可以组合使用的，但是切记Around与After是不可以同时使用的，会发生重复调用的问题。
JoinPoint的匹配规则
通过call 和 execution 我们可以知道切入点的时机是在方法调用还是在方法执行。但是如何才能找到方法呢，这就需要一定的匹配规则去找到需要切入的方法。
举个例子：
cn.test.fwl.Test.main() 这样的表达式，可以指定到包名为<cn.test.fwl>,类名为<Test>中无参数的main方法；那么如果我们需要匹配到这个类里所有的main方法，又或者我们需要匹配到这个包里所有类的main方法，再或者我们需要匹配到包含main字符的方法该如何来写表达式呢？
通配符
AspectJ中提供了一些通配符来方便我们找到满足规则的方法。
| 通配符 | 含义 |
|---|---|
| * | 匹配除了[.]之外的所有字符，用在路径中表示任意包名字符串，用在类名中标识任意类名字符串，方法中表示任意方法名字符串 |
| .. | 表示任意的子package，或者任意的参数 |
| + | 表示子类 |
举例：
- java.*.Date : 可以表示java.sql.Date,也可以表示java.util.Date
- Test* : 表示以Test开头的任意字符串
- java..* : 表示java包中的任意类
- java..*Model+ : 表示java包中以Model结尾的类的子类
- test(..) : 表示方法名为test，任意的参数，没有参数，有一个，两个都可以匹配
- test(int,char) : 表示方法名为test，有且仅有两个参数，类型为int，char
- test(String,..) : 表示方法名为test，至少有一个参数，第一个类型为String，其他任意
- test(String ...) : 表示方法名为test，参数个数不定，但必须都是String类型，这里的[...] 不是通配符，而是java中不定参数的意思。
JoinPoint的约束
除了上面的匹配规则外，AspectJ还提供了一些其他方法来更加精确的选择JoinPoint，比如某个类中的JoinPoint或者某个函数执行流程中的JoinPoint。
| 关键词 | 说明 | 举个栗子 |
|---|---|---|
| within(pattern) | pattern可以通过通配符表示，代表某个包或者类 | 满足pattern适配的JoinpPoint。比如说within(Test)就标识在Test类中（包括内部类）所有的JoinPoint。 |
| withinCode(Constructor Signature/Method Signature) | 表示某个构造函数或其他函数执行过程中涉及到的 JoinPoint | 比如：withinCode(* Test.testMethod(..))表示testMethod涉及的JoinPoint； withinCode(*.Test.new(..))表示Test构造函数涉及的JoinPoint |
| cflow(pointcuts) | cflow的条件是一个pointcut，表示某个流程中涉及的JoinPoint | 比如cflow(call Test.testMethod):表示调用Test.testMethod函数时所包含的JoinPoint，包括testMethod的call这个JoinPoint本身 |
| cflowbelow(pointcuts) | 比如：cflowbelow(call Test.testMethod):表示调用Test.testMethod函数时所包含的JoinPont，不包含testMethod的call这个JoinPont本身 | |
| this(Type) | JoinPoint的this对象是Type类型。包括其子类 | JPoint所在的这个类的类型是Type标示的类型或是其子类，则和它相关的JPoint将全部被选中。比如：Animal中的Move方法，则Bird，cat中的Move方法都会被选中 |
| target(Type) | JoinPoint的target对象是Type类型 | target一般用在call的情况。call一个函数，这个函数可能定义在其他类。比如Bird的move方法在调用时被选中，那么其他的Move的方法则不会。 |
| args(Type) | 用来对JoinPoint的参数进行条件约束 | 比如args(int,..),表示第一个参数是int，后面参数个数和类型不限 |
Advice的注意点
关于Advice前面已经说过了，他其实就是被嵌入的部分，而嵌入的时机，也在切入点的表格里提到过。这里主要讲下注意点：
- After：表示函数执行或者调用完成后运行被嵌入的代码部分。但是函数可能执行结束可能有两种退出方式：一个正常的Return，或者抛出异常，因此After也做了区分： after():return(type) 和
after():throwing(Throwable) - Around: 除了之前说Around和After不能同时使用之外，Around因为是可以替代原函数执行的，因此，要特别注意被嵌入的代码的返回值一定要和原来的方法一致。
环境配置
Eclipse
Android现在很少有用Eclipse开发的了，但是Eclipse的插件却是对AspectJ开发支持最友好的。基础的AOP实例，打算用Eclipse来开发AspectJ对Java的横切，因此，这里也介绍下，Eclipse的搭建。
Help -> Install New Software
Eclipse插件安装
然后一直下一步就好
Android Studio
首先在工程目录中导入相关的编译工具：
buuildscript{
repositories {
jcenter()
mavenCentral()
}
dependencies {
classpath 'com.android.tools.build:gradle:2.3.1'
classpath 'org.aspectj:aspectjtools:1.8.9'
classpath 'org.aspectj:aspectjweaver:1.8.9'
// NOTE: Do not place your application dependencies here; they belong
// in the individual module build.gradle files
}
}
然后在Aspect的module的build.gradle中添加依赖库：
compile 'org.aspectj:aspectjrt:1.8.9'
添加aspect编译的脚本：
def variants = android.libraryVariants
variants.all{ variant ->
LibraryPlugin plugin = project.plugins.getPlugin(LibraryPlugin)
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 msg: handler.getMessages(null,true)){
switch(msg.getKind()){
case IMessage.ABORT:
case IMessage.ERROR:
case IMessage.FAIL:
log.error msg.message, msg.thrown
break;
case IMessage.WARNING:
log.warn msg.message, msg.thrown
break;
case IMessage.INFO:
log.info msg.message,msg.thrown
break;
case IMessage.DEBUG:
log.debug msg.message,msg.thrown
break;
}
}
}
}
最后在app的module里添加对aspect module的依赖，同时添加上对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 = 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)
]
log.debug("ajc args: "+Arrays.toString(args))
MessageHandler handler = new MessageHandler(true);
new Main().run(args,handler);
for(IMessage msg: handler.getMessages(null,true)){
switch (msg.getKind()){
case IMessage.ABORT:
case IMessage.ERROR:
case IMessage.FAIL:
log.error msg.message,msg.thrown
break;
case IMessage.WARNING:
log.warn msg.message, msg.thrown
break;
case IMessage.INFO:
log.info msg.message,msg.thrown
break;
case IMessage.DEBUG:
log.debug msg.message,msg.thrown
break;
}
}
}
}
举个栗子
先通过Eclipse上创建AJ的工程来熟悉下AspectJ的相关语法。
首先，创建一个AspectJ的工程，在已经完成AJDT的插件的前提下，在新建工程的时候，就可以看到可以创建AspectJ Project这样的工程，如图：
创建工程
之后创建两个不同的包，来区分java文件和aj文件
创建Test1.java文件
public class Test1 {
public static void main(String[] args) {
test();
}
public static void test(){
System.out.println("this is test method!");
}
}
现在我们要在test()方法执行打印之前，插入我们的操作(这里也插入一句打印)
注意我们这里创建文件的时候，不再是java文件，而是.aj的文件
创建AspectJ.aj文件
public aspect AspectJ{
public pointcut aspect1(): execution(* test(..));
before():aspect1(){
System.out.println("this is before test method: execution");
}
}
完成这个文件之后，就会发现之前Test1.java中test()这个方法里上多了箭头的标志。这就表明插入成功了。
可以运行看下结果：
运行结果
AspectJ.aj中的注入的打印已经被打印出来了。那么被注入之后的
Test1.class是样的:
class file
可以看到在打印System.out.println("this is test method!");之前被插入了一段代码，而这段正是before():aspect1()方法中所执行的内容。
上面以execution和before的组合举了一个简单的例子，主要是阐述了下如何创建Aspecj的工程，以及相应的文件。下面的例子会包含call,execution和before,after的两两组合。
Test.java
public class Test1 {
public static void main(String[] args) {
testBeforeExecution();
testBeforeCall();
testAfterExecution();
testAfterCall();
testAfterReturn();
testAfterThrowable();
}
public static void testBeforeExecution(){
System.out.println("this is test before-execution!");
}
public static void testBeforeCall(){
System.out.println("this is test before-call");
}
public static void testAfterExecution(){
System.out.println("this is test after-execution");
}
public static void testAfterCall(){
System.out.println("this is test after-call");
}
public static String testAfterReturn(){
String a = "test parameter";
System.out.println("this is test after-return");
return a;
}
public static String testAfterThrowable(){
String a = null;
System.out.println("this is test after-throwable");
a.equals("test");
return a;
}
}
AspectJ.aj
public aspect AspectJ{
public pointcut aspect1(): execution(* testBeforeExecution(..));
public pointcut aspect2(): call(* testBeforeCall(..));
public pointcut aspect3(): execution(* testAfterExecution(..));
public pointcut aspect4(): call(* testAfterCall(..));
public pointcut aspect5(): execution(* testAfterReturn(..));
public pointcut aspect6(): execution(* testAfterThrowable(..));
before():aspect1(){
System.out.println("this is before test : execution");
}
before():aspect2(){
System.out.println("this is before test: call");
}
after():aspect3(){
System.out.println("this is after test:execution");
}
after():aspect4(){
System.out.println("this is after test: call");
}
after() returning(String s):aspect5(){
System.out.println("this is after test : return->"+s);
}
after() throwing(Exception e):aspect6(){
System.out.println("this is after test: throwable->"+e.getMessage());
}
}
可以看到运行结果：
运行结果
同时也可以看到编译后的class文件：
class file
接下来再举个关于Around的用法的例子：
Test2.java
public class Test2 {
public static void main(String[] args) {
testAroundCall();
testAroundExecution();
testAroundReplace();
System.out.println(testAroundRetrun());
}
public static void testAroundCall(){
System.out.println("this is testAroundCall method");
}
public static void testAroundExecution(){
System.out.println("this is testAroundExecution method");
}
public static void testAroundReplace(){
System.out.println("this is testAroundReplace");
}
public static String testAroundRetrun(){
String a = "the return value";
System.out.println("this is test around return");
return a;
}
}
AspectJ1.aj
public aspect AspectJ1{
public pointcut test1():execution(* testAroundCall(..));
public pointcut test2():call(* testAroundExecution(..));
public pointcut test3():call(* testAroundReplace(..));
public pointcut test4():call(* testAroundRetrun(..));
void around():test1(){
System.out.println("around-execution test before");
proceed();
System.out.println("around-execution test after");
}
void around():test2(){
System.out.println("around-call test before");
proceed();
System.out.println("around-call test after");
}
void around():test3(){
System.out.println("do replace ... ");
}
String around():test4(){
String a = "string in aspect";
System.out.println("replace return value");
proceed();
return a;
}
}
运行结果如下:
运行结果
class 文件
class file
以上都是AspectJ语言写的，那么如果使用纯Java的方式该如何来实现呢，看下面的例子：
Aspectj2.java
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class Aspectj2 {
@Pointcut("execution(* testBeforeExecution(..))")
public void test1(){
}
@Pointcut("call(* testBeforeCall(..))")
public void test2(){
}
@Pointcut("execution(* testAfterExecution(..))")
public void test3(){
}
@Pointcut("call(* testAfterCall(..))")
public void test4(){
}
@Pointcut("execution(* testAfterReturn(..))")
public void test5(){
}
@Pointcut("execution(* testAfterThrowable(..))")
public void test6(){
}
@Before("test1()")
public void execute1(){
System.out.println("before-execution aspectj");
}
@Before("test2()")
public void execute2(){
System.out.println("before-call aspectj");
}
@After("test3()")
public void execute3(){
System.out.println("after-execution aspectj");
}
@After("test4()")
public void execute4(){
System.out.println("after-call aspectj");
}
@AfterReturning("test5()")
public void execute5(){
System.out.println("after-return aspectj");
}
@AfterThrowing("test6()")
public void execute6(){
System.out.println("after-throw aspectj");
}
}
特别提醒下：类的注释@Aspect千万不能少，在这入坑了好几次
运行结果如下：
运行结果
再看下编译后的文件：
class file
栗子就先吃这么多~~~后面会再补一篇关于带参数，返回值处理的栗子。
AspectJ在Android中的应用
后续会在github上传一个关于权限检查的库，有时间也会写个文档介绍下这个库。
总结
AOP的知识接触得还不多，写了些demo和Android的库，总结下来，重点还是在JoinPoint的适配，如何才能精确得适配到自己想要的切入点，还需要将JoinPoint和Advice结合多加练习。
Eclipse上对的AJDT的插件对Aspect的语法还有错误检查，但是Android Studio上还没有，所以写的时候，要特别仔细。
TODO
- 带参数，返回值的栗子
- 权限检查的工程和分析文档
