AspectJ编程学习笔记

1. AspectJ编译器能识别任何普通的Java代码，可以使用ajc编译.java文件
2. 织入方式：
   

   源代码织入	织入器作为编译器的一部分，处理源代码，支持经典语法和注解语法。生成的字节码符合JVM规范，需要使用ajc代替javac
   字节码织入	传递给织入器的是字节码。使用这种方式时，包含编译普通Java类、编译切面，织入3个步骤。
   加载时织入	传递给织入器的是Java类字节码、切面类，以及aop.xml配置文件。

3. AspectJ暴露的连接点。只能在这些连接点上应用通知：
   

   	暴露的连接点	代码表现
   方法	执行 Execution	方法体：该连接点环绕整个方法体的执行过程。这也是Spring AOP唯一支持的接入点类型。通知被织入方法体 切入点语法：execution(方法签名)
   	调用 Call	方法调用：该接入点发生在方法被调用时。通知被织入调用者代码处 切入点语法：call(方法签名)
   构造器	执行 Execution	对象构造逻辑：该连接点环绕整个构造器的执行过程 切入点语法：execution(构造器签名)
   	调用 Call	对象构造调用 切入点语法：call(构造器签名)
   字段访问	读访问 Read access	读取类或对象的字段 切入点语法：get(字段签名)
   	写访问 Read access	写入类或对象的字段 切入点语法：set(字段签名)
   异常处理	处理器 Handler	处理异常的catch块 切入点语法：handler(类型签名)
   初始化	类初始化 Class initialization	类加载，包括静态成员初始化部分 切入点语法：staticinitialization(类型签名)
   	对象初始化 Object initialization	在构造器中的对象初始化。包含：从一个父构造器返回，到当前构造器执行完成的部分（不包括调用父构造器的部分） 切入点语法：initialization(构造器签名) Spring的@Configurable即为此例 。下面的例子解释了连接点的范围： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 public class SavingsAccount extends Account {     private boolean isOverdraft;     private int     minimumBalance;     //构造器1     public SavingsAccount( int accountNumber,                                  boolean isOverdraft )     {         super( accountNumber );         //对象初始化连接点：构造器1，2         this.isOverdraft = isOverdraft;     }     //构造器2     public SavingsAccount( int accountNumber )     {         //对象初始化连接点：构造器2         this( accountNumber, false );         //对象初始化连接点：构造器2         this.minimumBalance = 25;     } }
   	对象预初始化 pre-initialization	在构造器中的对象初始化之前：用的很少，从当前构造器调用，到父构造器调用结束为止 切入点语法：preinitialization(构造器签名)
   通知	执行 Execution	通知的执行：环绕某个通知的整个执行。可以对通知进行通知 切入点语法：adviceexecution()

4. AspectJ切入点声明语法
   
   Java

   1 2 3 4 5 6 7 8 9

   /** * 切入点声明语法，包含5个部分： * 访问标识符：例如 public * 关键字：pointcut * 切入点名称() * 切入点类型：例如execution、call，参考：第3点 * 切入点签名：根据切入点类型不同，可能是类型签名、方法签名、字段签名 */ public pointcut secureAccess(): execution(* MessageCommunicator.deliver(..));

   AspectJ支持仅有切入点名称，而没有类型和签名的切入点，通常使用在抽象切面中。
   AspectJ支持匿名切入点，作为通知签名的一部分存在。
   AspectJ支持使用 !、 && 、|| 来作为切入点的运算符

5. AspectJ通知定义语法：由通知声明、切入点定义、通知体三部分组成
   

   组成	说明
   整体语法形式： Java 1 2 3 4 [@AdviceName("通知的名称")] [返回值] 通知类型([上下文信息]) [returning|throwing] [throws 通知抛出的异常] : 切入点定义([上下文信息]) {     通知体 }
   通知声明	通知类型可以是：before, after 或 around，其中around需要声明返回值通知声明可以指定通知体可用的上下文信息，包括：执行对象通知声明可以指定通知体可能抛出的异常
   切入点定义	位于冒号之后，任何匹配切入点定义的连接点上都会执行本通知
   通知体	可以访问一系列特殊的变量或关键字，例如：proceed、thisJoinPoint、thisJoinPointStaticPart、 thisEnclosingJoinPointStaticPart

6. AspectJ支持的通知类型
   

   通知类型	说明
   Before advice	在连接点执行之前执行，如果抛出异常，那么连接点不被执行
   After advice	在连接点执行之后执行，根据连接点的执行结果，具有3个子类型：After (finally)：在连接点执行之后执行，不论其结果，通知声明语法：after()After returning：在连接点执行成功后执行，通知声明语法：after() returning(<ReturnType returnObject>)After throwing：在连接点执行失败后执行，通知声明语法：after() throwing(<ExceptionType exceptionObject>)
   Around advice	环绕连接点的执行过程，具有修改连接点执行上下文的能力，可以用来： 在连接点之前/之后添加额外的逻辑，例如性能分析 跳过原先逻辑还执行备选的逻辑，例如缓存。只要不调用proceed()，即跳过 使用try-catch包裹原先逻辑，提供异常处理策略，例如事务管理

通配符用于匹配一系列的连接点。

这里的类型泛指：类、接口、注解、切面、基本类型
基本类型签名示例：

基于注解的类型签名示例：
由于Java不支持注解的继承，所有注解名后不会出现加号。注意注解必须运行时可见（ RetentionPolicy.RUNTIME ）

基于泛型的类型签名示例：

联合类型签名示例：

构造器签名与方法类似，但是：

1. 由于构造器没有返回值，因此不得在签名中指定返回值
2. 由于构造器不能为静态，故不得添加static关键字
3. 由于构造器没有名称，必须使用new作为其名称部分

基本方法签名示例：

基于注解的方法签名示例：

注意注解必须运行时可见（ RetentionPolicy.RUNTIME ）

字段签名中，使用get表示读字段，set表示写字段：

字段签名示例：

注意注解必须运行时可见（ RetentionPolicy.RUNTIME ）

AspectJ提供几种切入点指示器（designators），配合上面所述的切入点签名，即组成切入点。
切入点通过两种方式与连接点进行匹配：

1. 类型限定的切入点：直接映射到某个类型的连接点，参考AspectJ暴露的连接点一节中的“切入点语法”部分
2. 无类型的切入点：根据指定的信息，来选择特定的连接点。这些信息可以是：连接点上下文的运行时类型、控制流，或者此法作用域（lexical scope）

匹配：指定类型和签名的连接点
Spring：仅支持execution类型
静态确定：是

不去限定连接点的类型，还是通过若干种规则去匹配多种连接点。

Spring虽然仅仅支持execution一种类型的连接点，但是却支持多种方式来选择它们

基于控制流的切入点
这一类的切入点匹配 处于其他切入点的控制流之中 的连接点。这句话比较难以理解，以贷款业务为例，假设Account.debit()方法调用Account.getBalance()进行余额查询，那么，可以说：getBalance在debit的控制流之中。类似的，字段访问、异常处理，也可以处于某个切入点的控制流之中。
Spring不支持这一类切入点，不能静态确定（需要运行时判断）
包含两种切入点类型：cflow、cflowbelow，后者不包括启动控制流的连接点本身

下面以事务管理的场景为例，来说明控制流切入点的用法：

基于词法结构的切入点
匹配：在指定类型、方法、构造器内的连接点
Spring：支持within()，不支持withincode()
可以静态确定
包含两种切入点类型：within(类型签名)、withincode(构造器签名|方法签名)

执行对象切入点
根据运行时对象类型来选择连接点。并且，可以收集执行对象——双重功能。

包含两种类型：this(<Type or ObjectIdentifier>)、target(<Type or ObjectIdentifier>)，前者匹配this引用为指定类型的连接点；后者匹配方法调用target为指定类型的连接点。

该类切入点不支持类型通配，也不支持泛型。该类切入点不会匹配任何静态方法的执行连接点。

注意区别：
execution(* Account.*(..)) 匹配Account类的任何静态、成员方法
execution(* *.*(..))  && this(Account)：匹配Account及其子类的任何成员方法
参数切入点
该类切入点根据连接点的参数对象的运行时类型来匹配。并且，可以收集匹配的参数对象。
Spring支持此类切入点。无法静态确定。
所谓参数对象，根据连接点不同，含义也不同：

1. 对于方法、构造器连接点，参数对象即方法参数
2. 对于异常处理连接点，参数对象即被处理的异常
3. 对于字段写入连接点，参数对象即被写入的值

该类切入点的形式为：args(Type or ObjectIdentifier, ..)

基于注解的切入点

注意：注解本身被标注的注解影响AOP行为：

1. @Retention(RetentionPolicy.RUNTIME)：只有设置为运行时保留，才能在运行时进行匹配性判断
2. @Inherited：只有标注了此注解，子编程元素（类、方法）才能继承父元素上标注的注解

AspectJ支持根据类型、方法、字段所标注的注解来匹配连接点

条件检查切入点
此类切入点在连接点上的一些条件检查。通常和其它切入点联合使用

本段代码示意经典的AspectJ语法：

本段代码示意基于注解的AspectJ语法：
基于注解的语法，可以作为普通Java类编译，并且使用LTW（加载时织入）机制，在类被加载到JVM中时进行织入。

环绕通知的简单例子，注意proceed()的使用：

上下文收集的简单例子：

上下文收集注解的例子：

上下文收集的另外一个例子，注意传递给目标的参数被收集，可被通知体使用：

在classpath的META-INF/aop.xml中，声明需要织入的切面：

通过指定JVM启动参数-javaagent来启用LTW：

如果使用Spring，可以通过配置，避免修改JVM启动参数

AspectJ支持连接点、切入点、切面等构造。

AspectJ的动态横切构造依赖于“通知”实现。通知包括Before、After、Around几种。

收集连接点上下文

连接点上下文包括两种类型：

通过反射访问连接点上下文

作为备选方式，AspectJ提供了基于反射机制的访问静态（不会随着连接点执行而变化的）、动态连接点上下文信息的方法。这种方式可以完全替换上一条进行动态上下文收集，但是具有以下缺点：

1. 性能较为低下
2. 缺少静态语法检查
3. 比较笨重

通过AspectJ提供的通知体可用的特殊变量来使用这种反射API：

两种访问连接点上下文的方式的对照表

静态横切总是在动态横切之前应用。

静态横切构造由：跨类型声明（inter-type declaration ，ITD，亦称“引入introduction)”）和织入时声明（weave-time declarations）组成
跨类型声明（引入）
可以修改类、接口、或者切面的静态结构，例如增加一个字段，添加一个接口。在一个切面中，声明其他类型的结构，故曰ITD。下面是一个例子：

成员引入的规则

1. 只能引入private、public成员，前者只能被切面类访问，后者可以被系统中所有类访问
2. 如果是private的，多个切面可以引入同名的成员
3. 切面可以引入字段、函数、构造器到类或者接口。特别的，可以引入方法的实现到接口——缺省实现
4. 如果切面引入一个和类中同名的方法，那么，类中的那个方法被保留
5. 成员引入只能针对一个类型

接口缺省实现的例子

使用ITD来实现Java的Mixin机制

Mixin是一种程序构造，允许在已有类中混入特定的逻辑，Java语言没有语言级别的机制，下面的例子示意了如何使用AspectJ进行混入

通过下面的代码，即可为Customer或者任何实现了BeanSupport的类型混入属性变更的功能，而没有任何的侵入性。

修改类层次结构

AspectJ提供两种需要类层次的形式：

引入注解

AspectJ支持为字段、类、方法等添加注解

简化异常处理

允许不强制捕获受查异常，声明方式如下：

织入时声明——警告或者错误信息

可以在织入时，根据一定的模式来生成错误或者警告信息，举例：

这种场景下，本质上还是Spring基于JDK动态代理的AOP机制，只是借用AspectJ的语法。

可以基于AspectJ，而不是Spring AOP来实现：事务管理、缓存、任务调度等常用AOP场景，以避免Spring AOP的固有缺陷。
特别是使用@Configurable注解来支持非Spring Bean的依赖注入，必须基于AspectJ完成。