• 一OOP的困境
  • 1 OOP
  • 2 从打印日志来看AOP 和 OOP
• 二适用AOP的场景
• 三工具和库
• 四AspectJ简介
• 五AOP概念介绍
  • 1 Join Points 何处支持注入
  • 2 Pointcuts定位想要注入的具体连接点
    • 21 Pointcuts基本结构
    • 22 Joinpoint类型的直接选择
      • 221 Joinpoint类型一览
      • 222 定位正则
        • 2221 Method Signature
        • 2222 Constructor signature
        • 2223 Field Signature
        • 2224 Type Signature
    • 23 Joinpoint类型的间接选择
  • 3 advice 注入代码的执行时间点
  • 4 参数传递和JPoint信息
    • 41 参数传递
      • 411 先在pointcuts定义时候指定参数类型和名字
      • 412 修改advice
    • 42 JPoint信息
• 参考资料

一、OOP的困境

1.1 OOP

ObjectOriented Programming，面向对象编程

在OOP的世界中，问题或者功能都被划分到一个一个的模块里边。每个模块专心干自己的事情，模块之间通过设计好的接口交互.

是一种方法论，一种编程的思想。

1.2 从“打印日志”来看AOP 和 OOP

OOP的精髓是把功能或问题模块化，每个模块处理自己的家务事。但在现实世界中，并不是所有问题都能完美得划分到模块中

举个最简单而又常见的例子：
现在想为每个模块加上日志功能，要求模块运行时候能输出日志

• OOP的处理方式
  1. 先设计一个日志输出模块，这个模块提供日志输出API，比如Android中的Log类；
  2. 然后，其他模块需要输出日志的时候调用Log类的几个函数，比如e(TAG,…)，w(TAG,…)，d(TAG,…)，i(TAG,…)等。

/***
*代码很简单。但是从这个小例子中，你也会发现要是这个程序比较复杂的话，到处都加*Log，或者在某些特殊函数加权限检查的代码，真的是一件挺繁琐的事情。
*/
public class AopDemoActivity extends Activity {
   private static final String TAG = "AopDemoActivity";
//onCreate，onStart,onRestart,onPause,onResume,onStop,onDestory返回前，都输出一行日志
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.layout_main);
       Log.e(TAG,"onCreate");
    }
   protected void onStart() {
       super.onStart();
        Log.e(TAG, "onStart");
    }
   protected void onRestart() {
       super.onRestart();
        Log.e(TAG, "onRestart");
    }
    protectedvoid onResume() {
       super.onResume();
        Log.e(TAG, "onResume");
?  // checkPhoneState会检查app是否申明了android.permission.READ_PHONE_STATE权限
        checkPhoneState();
    }
   protected void onPause() {
       super.onPause();
        Log.e(TAG, "onPause");
    }
   protected void onStop() {
       super.onStop();
        Log.e(TAG, "onStop");
    }
   protected void onDestroy() {
       super.onDestroy();
        Log.e(TAG, "onDestroy");
    }
   private void checkPhoneState(){
       if(checkPermission("android.permission.READ_PHONE_STATE")== false){
           Log.e(TAG,"have no permission to read phone state");
           return;
        }
       Log.e(TAG,"Read Phone State succeed");
       return;
    }
   private boolean checkPermission(String permissionName){
       try{
           PackageManager pm = getPackageManager();
          //调用PackageMangaer的checkPermission函数，检查自己是否申明使用某权限
           int nret = pm.checkPermission(permissionName,getPackageName());
           return nret == PackageManager.PERMISSION_GRANTED;
        }......
    }
}

在没有接触AOP之前，能想到的解决方案基本就是上面的方法。但是，从OOP角度看，除了日志模块本身，其他模块的承载的业务功能都不包含“打印日志”，而仅仅需要这样一个调用。这个日志输出功能，从整体来看，都是一个面上的。而这个面的范围，就不局限在单个模块里了，而是横跨多个模块。

在没有AOP之前，各个模块要打印日志，就是自己处理。通过分散在各处的函数调用从而实现了“日志打印功能”，这有点类似于分权管理，那么AOP就是对应集权管理方式。

• AOP的处理方式

第一，我们要认识到OOP世界中，有些功能是横跨并嵌入众多模块里的，比如打印日志，比如统计某个模块中某些函数的执行时间等。这些功能在各个模块里分散得很厉害，可能到处都能见到。

第二，AOP的目标是把这些功能集中起来，放到一个统一的地方来控制和管理。如果说，OOP如果是把问题划分到单个模块的话，那么AOP就是把涉及到众多模块的某一类问题进行统一管理。比如我们可以设计两个Aspects，一个是管理某个软件中所有模块的日志输出的功能，另外一个是管理该软件中一些特殊函数调用的权限检查

ps :

AspectJ需要编写aj文件，然后把AOP代码放到aj文件中。但是在Android开发中，我建议不要使用aj文件。因为aj文件只有AspectJ编译器才认识，而Android编译器不认识这种文件。所以当更新了aj文件后，编译器认为源码没有发生变化，所以不会编译它。

当然，这种问题在其他不认识aj文件的java编译环境中也存在。所以，AspectJ提供了一种基于注解的方法来把AOP实现到一个普通的Java文件中。这样我们就把AOP当做一个普通的Java文件来编写、编译就好。

/**
*
*
*/

package com.androidaop.demo;
import android.util.Log;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.JoinPoint;

@Aspect   //必须使用@AspectJ标注，这样class DemoAspect就等同于 aspect DemoAspect了
public class DemoAspect {
    staticfinal String TAG = "DemoAspect";
/*
@Pointcut：pointcut也变成了一个注解，这个注解是针对一个函数的，比如此处的logForActivity()
其实它代表了这个pointcut的名字。如果是带参数的pointcut，则把参数类型和名字放到
代表pointcut名字的logForActivity中，然后在@Pointcut注解中使用参数名。
基本和以前一样，只是写起来比较奇特一点。后面我们会介绍带参数的例子
*/
@Pointcut("execution(* com.androidaop.demo.AopDemoActivity.onCreate(..)) ||"
        +"execution(* com.androidaop.demo.AopDemoActivity.onStart(..))")
public void logForActivity(){};  //注意，这个函数必须要有实现，否则Java编译器会报错

/*
@Before：这就是Before的advice，对于after，after -returning，和after-throwing。对于的注解格式为
@After，@AfterReturning，@AfterThrowing。Before后面跟的是pointcut名字，然后其代码块由一个函数来实现。比如此处的log。
*/
    @Before("logForActivity()")
    public void log(JoinPoint joinPoint){
       //对于使用Annotation的AspectJ而言，JoinPoint就不能直接在代码里得到多了，而需要通过
      //参数传递进来。
       Log.e(TAG, joinPoint.toShortString());
    }
}

提示：如果开发者已经切到AndroidStudio的话，AspectJ注解是可以被识别并能自动补齐。

上面的例子仅仅是列出了onCreate和onStart两个函数的日志，如果想在所有的onXXX这样的函数里加上log，该怎么改呢？

@Pointcut("execution(* *..AopDemoActivity.on*(..))")

public void logForActivity(){};

二、适用AOP的场景

• 日志
• 持久化
• 性能监控
• 数据校验
• 缓存
• 其他更多

三、工具和库

有一些工具和库帮助我们使用 AOP:

- AspectJ: 一个 JavaTM 语言的面向切面编程的无缝扩展（适用Android）。

• Javassist for Android: 用于字节码操作的知名 java 类库 Javassist 的 Android 平台移植版。
• DexMaker: Dalvik 虚拟机上，在编译期或者运行时生成代码的 Java API。
• ASMDEX: 一个类似 ASM 的字节码操作库，运行在Android平台，操作Dex字节码。

四、AspectJ简介

我们下面的例子选用 AspectJ，有以下原因：

- 功能强大

- 支持编译期和加载时代码注入

- 易于使用

AspectJ会在编译期间增加一个新的步骤处理AspectJ注解，并在对应的切入点中生成和注入必要的样板代码

使用AspectJ有两种方法：

• 完全使用AspectJ的语言。这语言一点也不难，和Java几乎一样，也能在AspectJ中调用Java的任何类库。AspectJ只是多了一些关键词罢了。
• 或者使用纯Java语言开发，然后使用AspectJ注解，简称@AspectJ。

  Anyway，不论哪种方法，最后都需要AspectJ的编译工具ajc来编译。由于AspectJ实际上脱胎于Java，所以ajc工具也能编译java源码。

AspectJ现在托管于Eclipse项目中，官方网站是：

• http://www.eclipse.org/aspectj/ <=AspectJ官方网站
• http://www.eclipse.org/aspectj/doc/released/runtime-api/index.html <=AspectJ类库参考文档，内容非常少
• http://www.eclipse.org/aspectj/doc/released/aspectj5rt-api/index.html <[email protected]文档，以后我们用Annotation的方式最多。

五、AOP概念介绍

5.1 Join Points: 何处支持注入

Join Points（以后简称JPoints）是AspectJ中最关键的一个概念。什么是JPoints呢？JPoints就是程序运行时的一些执行点。那么，一个程序中，哪些执行点是JPoints呢？比如：

• 一个函数的调用可以是一个JPoint。比如Log.e()这个函数。e的执行可以是一个JPoint，而调用e的函数也可以认为是一个JPoint。
• 设置一个变量，或者读取一个变量，也可以是一个JPoint。比如Demo类中有一个debug的boolean变量。设置它的地方或者读取它的地方都可以看做是JPoints
• for循环可以看做是JPoint

理论上说，一个程序中很多地方都可以被看做是JPoint，但是AspectJ中，只有如表1所示的几种执行点被认为是JPoints：

下面我们来看个例子以直观体会一把，打印出其中所有的join points。

package test;
public class Test{
   static public class TestBase{
        static{
          int x = 0;
        }
        int base = 0;
        public TestBase(int index){
            base = index;
        }
   }
     static  public class TestDerived extends TestBase{
        public int derived = 0;
        public TestDerived(){
            super(0);
            this.derived = 1000;

        }
        public void testMethod() {
            try{
                byte[] test = null;
                test[1] = 0x33;
            }catch(Exception ex){
            }
        }
        static int getFixedIndex(){
           return 1000;
        }
    }
     public static void main(String args[]){
        System.out.println("Test begin...");
        TestDerived derived = new TestDerived();
        derived.testMethod();
        derived.base = 1;
        System.out.println("Test end...");
    }
}

• 左图的第一个红框：
  • staticinitialization(test.Test.)：表示当前是哪种类型的JPoint，括号中代表目标对象是谁（此处是指Test class的类初始化）。由于Test类没有指定static block，所以后面的at:Test.java:0 表示代码在第0行（其实就是没有找到源代码的意思）。
  • Test类初始化完后，就该执行main函数了。所以，下一个JPoint就是execution(voidtest.Test.main(String[]))。括号中表示此JPoint对应的是test.Test.main函数。at:Test.java:30表示这个JPoint在源代码的第30行。大家可以对比图2的源码，很准确！
  • main函数里首先是执行System.out.println。而这一行代码实际包括两个JPoint。一个是get(PrintStream java.lang.System.out)，get表示Field get，它表示从System中获取out对象。另外一个是call(void java.io.PrintStream.println(String))，这是一个call类型的JPoint，表示执行out.println函数。
• 左图第二个红框
  • 它表示TestBase的类的初始化，由于源码中为TestBase定义了static块，所以这个JPoint清晰指出了源码的位置是at:Test.java:5
• 左图第三个红框
  • 它和对象的初始化有关。在源码中，我们只是构造了一个TestDerived对象。它会先触发TestDerived Preinitialization JPoint，然后触发基类TestBase的PreInitialization JPoint。注意红框中的before和after 。在TestDerived和TestBase所对应的PreInitialization before和after中都没有包含其他JPoint。所以，Pre-Initialization应该是构造函数中一个比较基础的Phase。这个阶段不包括类中成员变量定义时就赋值的操作，也不包括构造函数中对某些成员变量进行的赋值操作。
  • 而成员变量的初始化（包括成员变量定义时就赋值的操作，比如源码中的int base = 0，以及在构造函数中所做的赋值操作，比如源码中的this.derived = 1000）都被囊括到initialization阶段。请读者对应图三第二个红框到第三个红框（包括第3个红框的内容）看看是不是这样的
• 第5个红框。它包括三个JPoint
  • testMethod的call类型JPoint
  • testMethod的execution类型JPonint
  • 以及对异常捕获的Handler类型JPoint

5.2 Pointcuts：定位想要注入的具体连接点

一个程序会有很多的JPoints，即使是同一个函数（比如testMethod这个函数），还分为call类型和execution类型的JPoint。显然，不是所有的JPoint，也不是所有类型的JPoint都是我们关注的。再次以AopDemo为例，我们只要求在Activity的几个生命周期函数中打印日志，只有这几个生命周期函数才是我们业务需要的JPoint，而其他的什么JPoint我不需要关注。

怎么从一堆一堆的JPoints中选择自己想要的JPoints呢？恩，这就是Pointcuts的功能。一句话，Pointcuts的目标是提供一种方法使得开发者能够选择自己感兴趣的JoinPoints。 类似于一种正则规则

在5.1的例子中，怎么把Test.java中所有的Joinpoint选择出来呢？用到的pointcut格式为：
pointcuttestAll():within(Test)。

5.2.1 Pointcuts基本结构

1. 选择那些调用println（而且不考虑println函数的参数是什么）的Joinpoint。
2. 另外，调用者的类型不要是TestAspect的。 (TestAspect为当前类名)

//现在我想把5.1中的示例代码中，那些调用println的地方找到，该怎么弄？代码该这么写：
public pointcut  testAll(): call(public  *  *.println(..)) && !within(TestAspect) ;  

private static final String POINTCUT_METHOD =" call(public  *  *.println(..))";
@Pointcut(POINTCUT_METHOD )
public void testAll() {}

• 第一个public：表示这个pointcut是public访问。这主要和aspect的继承关系有关，属于AspectJ的高级玩法，本文不考虑。
• pointcut：关键词，表示这里定义的是一个pointcut。pointcut定义有点像函数定义。总之，在AspectJ中，你得定义一个pointcut。
• testAll()：pointcut的名字。在AspectJ中，定义Pointcut可分为有名和匿名两种办法。个人建议使用named方法。因为在后面，我们要使用一个pointcut的话，就可以直接使用它的名字就好。
• testAll后面有一个冒号，这是pointcut定义名字后，必须加上。冒号后面是这个pointcut怎么选择Joinpoint的条件。
• call(public * *.println(..))是一种选择条件
  • call：表示我们选择的Joinpoint类型为call类型
  • public ：由于我们这里选择的JoinPoint类型为call类型，它对应的目标JPoint一定是某个函数。所以我们要找到这个/些函数。public 表示目标JPoint的访问类型（public/private/protect）
  • 第一个*表示返回值的类型是任意类型
  • 第二个*用来指明包名。此处不限定包名
  • 紧接其后的println是函数名。这表明我们选择的函数是任何包中定义的名字叫println的函数
  • (..)函数参数指明了目标函数的参数应该是什么样子的。比如这里使用了通配符..，代表任意个数的参数，任意类型的参数
• &&：AspectJ 可以把几个条件组合起来，目前支持 &&，||，以及！这三个条件。这三个条件的意思不用我说了吧？和Java中的是一样的。
• !within(TestAspectJ)
  • 前面的!表示不满足某个条件
  • within是另外一种类型选择方法，特别注意，这种类型和前面讲到的joinpoint的那几种类型不同

5.2.2 Joinpoint类型的直接选择

5.2.1中示例定位了“调用println”的连接点，如果要改为函数的执行，也就是methodexecution的JPoint，那么pointcuts的写法就得包括execution(XXX)来限定。

5.2.2.1 Joinpoint类型一览

5.2.2.2 定位正则

5.2.2.2.1 Method Signature

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

• @注解 属于可选项
• 访问权限（public/private/protect，以及static/final）属于可选项

  如果不设置它们，则默认都会选择。以访问权限为例，如果没有设置访问权限作为条件，那么public，private，protect及static、final的函数都会进行搜索。

• 返回值类型就是普通的函数的返回值类型。如果不限定类型的话，就用*通配符表示
• 包名.函数名用于查找匹配的函数。可以使用通配符，包括和..以及+号。其中号用于匹配除.号之外的任意字符，而..则表示任意子package，+号表示子类
  • java.*.Date：可以表示java.sql.Date，也可以表示java.util.Date
  • Test*：可以表示TestBase，也可以表示TestDervied
  • java..*：表示java任意子类
  • java..*Model+：表示Java任意package中名字以Model结尾的子类，比如TabelModel，TreeModel
• 函数的参数,参数匹配比较简单，主要是参数类型..

  在参数匹配中，“..”代表任意参数个数和类型

  • (int, char)：表示参数只有两个，并且第一个参数类型是int，第二个参数类型是char
  • (String, ..)：表示至少有一个参数。并且第一个参数类型是String，后面参数类型不限
  • (Object …)：表示不定个数的参数，且类型都是Object，这里的…不是通配符，而是Java中代表不定参数的意思

5.2.2.2.2 Constructor signature

Constructorsignature和Method Signature类似，只不过构造函数没有返回值，而且函数名必须叫new

public *..TestDerived.new(..)

• public：选择public访问权限
• *..代表任意包名
• TestDerived.new：代表TestDerived的构造函数
• (..)：代表参数个数和类型都是任意

5.2.2.2.3 Field Signature

@注解 访问权限 类型 类名.成员变量名
set(int test..TestBase.base)：表示设置TestBase.base变量时的JPoint   

• @注解和访问权限是可选的
• 类型：成员变量类型，*代表任意类型
• 类名.成员变量名：成员变量名可以是*，代表任意成员变量

5.2.2.2.4 Type Signature

• staticinitialization(test..TestBase)：表示TestBase类的static block
• handler(NullPointerException)：表示catch到NullPointerException的JPoint。注意，图2的源码第23行截获的其实是Exception，其真实类型是NullPointerException。但是由于JPointer的查询匹配是静态的，即编译过程中进行的匹配，所以handler(NullPointerException)在运行时并不能真正被截获。只有改成handler(Exception)，或者把源码第23行改成NullPointerException才行

5.2.3 Joinpoint类型的间接选择

除了根据前面提到的Signature信息来匹配JPoint外，AspectJ还提供其他一些选择方法来选择JPoint。比如某个类中的所有JPoint，每一个函数执行流程中所包含的JPoint。

特别强调，不论什么选择方法，最终都是为了找到目标的JPoint。

注意：this()和target()匹配的时候不能使用通配符。

注意，不是所有的AOP实现都支持本节所说的查询条件。比如Spring就不支持withincode查询条件。

5.3 advice: 注入代码的执行时间点

//testAll()是前面定义的pointcuts
//而before()定义了在这个pointcuts选中的JPoint执行前我们要干的事情。
before():testAll(){
   System.out.println("before calling: " + thisJoinPoint);//打印这个JPoint的信息
  System.out.println("      at:" + thisJoinPoint.getSourceLocation());//打印这个JPoint对应的源代码位置
}  

恭喜，看到这个地方来，AspectJ的核心部分就掌握一大部分了。现在，我们知道如何通过pointcuts来选择合适的JPoint。那么，下一步工作就很明确了，选择这些JPoint后，我们肯定是需要干一些事情的。比如前面例子中的输出都有before，after之类的。这其实JPoint在执行前，执行后，都执行了一些我们设置的代码。在AspectJ中，这段代码叫advice。简单点说，advice就是一种Hook。

注意，after和before没有返回值，但是around的目标是替代原JPoint的，所以它一般会有返回值，而且返回值的类型需要匹配被选中的JPoint。

• 第一个红框是修改后的testMethod，在这个testMethod中，肯定会抛出一个空指针异常。
• 第二个红框是我们配置的advice，除了before以外，还加了一个around。我们重点来看around，它的返回值是Object。虽然匹配的JPoint是testMethod，其定义的返回值是void。但是AspectJ考虑的很周到。在around里，可以设置返回值类型为Object来表示返回任意类型的返回值。AspectJ在真正返回参数的时候，会自动进行转换。比如，假设inttestMethod定义了int作为返回值类型，我们在around里可以返回一个Integer，AspectJ会自动转换成int作为返回值
• 再看around中的//proceed()这句话。这代表调用真正的JPoint函数，即testMethod。由于这里我们屏蔽了proceed，所以testMethod真正的内容并未执行，故运行的时候空指针异常就不会抛出来。也就是说，我们完全截获了testMethod的运行，甚至可以任意修改它，让它执行别的函数都没有问题。

注意：从技术上说，around是完全可以替代before和after的。图7中第二个红框还把after给注释掉了。如果不注释掉，编译时候报错，[error]circular advice precedence: can’t determine precedence between two or morepieces of advice that apply to the same join point: method-execution(voidtest.Test$TestDerived.testMethod())（大家可以自己试试）。我猜测其中的原因是around和after冲突了。around本质上代表了目标JPoint，比如此处的testMethod。而after是testMethod之后执行。那么这个testMethod到底是around还是原testMethod呢？真是傻傻分不清楚！

（我觉得再加一些限制条件给after是可以避免这个问题的，但是没搞成功…）

5.4 参数传递和JPoint信息

5.4.1 参数传递

• pointcuts修改：像定义函数一样定义pointcuts，然后在this,target或args中绑定参数名（注意，不再是参数类型，而是参数名）。
• advice修改：也像定义函数一样定义advice，然后在冒号后面的pointcuts中绑定参数名（注意是参数名）
• 在advice的代码中使用参数名。

前面介绍的advice都是没有参数信息的，而JPoint肯定是或多或少有参数的。而且advice既然是对JPoint的截获或者hook也好，肯定需要利用传入给JPoint的参数干点什么事情。比方所around advice，我可以对传入的参数进行检查，如果参数不合法，我就直接返回，根本就不需要调用proceed做处理。

往advice传参数比较简单，就是利用前面提到的this(),target(),args()等方法。另外，整个pointcuts和advice编写的语法也有一些区别。具体方法如下：

5.4.1.1 先在pointcuts定义时候指定参数类型和名字

pointcut testAll(Test.TestDerived derived,intx):call(*Test.TestDerived.testMethod(..))
             && target(derived)&& args(x)  

注意上述pointcuts的写法，首先在testAll中定义参数类型和参数名。这一点和定义一个函数完全一样.

接着看target和args。此处的target和args括号中用得是参数名。而参数名则是在前面pointcuts中定义好的。这属于target和args的另外一种用法。

? 注意，增加参数并不会影响pointcuts对JPoint的匹配，上面的pointcuts选择和

pointcut testAll():call(*Test.TestDerived.testMethod(..)) && target(Test.TestDerived) &&args(int)是一样的  

5.4.1.2 修改advice

Object around(Test.TestDerived derived,int x):testAll(derived,x){
     System.out.println("     arg1=" + derived);
     System.out.println("     arg2=" + x);
      return proceed(derived,x); //注意，proceed就必须把所有参数传进去。
}  

• advice的定义现在也和函数定义一样，把参数类型和参数名传进来。
• 接着把参数名传给pointcuts，此处是testAll。注意，advice必须和使用的pointcuts在参数类型和名字上保持一致。
• 然后在advice的代码中，你就可以引用参数了，比如derived和x，都可以打印出来。

5.4.2 JPoint信息

打印出了JPoint的信息，比如当前调用的是哪个函数，JPoint位于哪一行代码。这些都属于JPoint的信息。AspectJ为我们提供如下信息

参考资料

• 深入理解Android之AOP
• [译] Android 中的 AOP 编程