面向切面编程（AOP）术语

通知（Advice）

切面的工作被称为通知

通知定义了切面是什么以及何时使用。

Spring 切面可以应用 5 种类型的通知：

• 前置通知（Before）：在目标方法被调用之前调用通知功能
• 后置通知（After）：在目标方法完成之后调用通知，此时不会关心方法的输出是什么
• 返回通知（After-returning）：在目标方法成功执行之后调用通 知
• 异常通知（After-throwing）：在目标方法抛出异常后调用通知
• 环绕通知（Around）：通知包裹了被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为

连接点（Join point）

连接点是在应用执行过程中能够插入切面的一个点。这个点可以是调用方法时、抛出异常时、甚至修改一个字段时。切面代码可以利用这些点插入到应用的正常流程之中，并添加新的行为。

切点（Poincut）

切点是通知所要织入的一个或多个连接点。我们通常使用明确的类和方法名称，或是利用正则表达式定义所匹配的类和方法名称来指定这些切点。有些 AOP 框架允许我们创建动态的切点，可以根据运行时的决策（比如方法的参数值）来决定是否应用通知。

切面（Aspect）

切面是通知和切点的结合。通知和切点共同定义了切面的全部内容 —— 它是什么，在何时和何处完成其功能。

引入（Introduction）

引入允许我们向现有的类添加新方法或属性。

织入（Weaving）

织入是把切面应用到目标对象并创建新的代理对象的过程。切面在指定的连接点被织入到目标对象中。

在目标对象的生命周期里有多个点可以进行织入：

• 编译期：切面在目标类编译时被织入。这种方式需要特殊的编译器。AspectJ 的织入编译器就是以这种方式织入切面的。
• 类加载期：切面在目标类加载到 JVM 时被织入。这种方式需要特殊的类加载器（ClassLoader），它可以在目标类被引入应用之前增强该目标类的字节码。AspectJ 5 的加载时织入（load-time weaving，LTW）就支持以这种方式织入切面。
• 运行期：切面在应用运行的某个时刻被织入。一般情况下，在织入切面时，AOP 容器会为目标对象动态地创建一个代理对象。Spring AOP 就是以这种方式织入切面的。

Spring 提供的 AOP 支持

Spring 提供了 4 种类型的 AOP 支持：

• 基于代理的经典 Spring AOP；
• 纯 POJO 切面；
• @AspectJ 注解驱动的切面；
• 注入式 AspectJ 切面（适用于 Spring 各版本）

Spring 在运行时通知对象

通过在代理类中包裹切面，Spring 在运行期把切面织入到 Spring 管理的 bean 中。代理类封装了目标类，并拦截被通知方法的调用，再把调用转发给真正的目标 bean。当代理拦截到方法调用时，在调用目标 bean 方法之前，会执行切面逻辑。

直到应用需要被代理的 bean 时，Spring 才创建代理对象。如果使用的是 ApplicationContext 的话，在 ApplicationContext 从 BeanFactory 中加载所有 bean 的时候，Spring 才会创建被代理的对象。因为 Spring 运行时才创建代理对象，所以不需要特殊的编译器来织入 Spring AOP 的切面。

Spring 只支持方法级别的连接点

因为 Spring 基于动态代理，所以 Spring 只支持方法连接点。

其他的 AOP 框架例如 AspectJ 和 JBoss，除了方法切点，还提供了字段和构造器接入点。

Spring 缺少对字段连接点的支持，无法创建细粒度的通知，例如拦截对象字段的修改。而且它不支持构造器连接点，无法在 bean 创建时应用通知。

通过切点来选择连接点

Spring 仅支持 AspectJ 切点指示器（pointcut designator）的一个子集

只有execution()指示器是实际用来执行匹配的，而其他的指示器都是用来限制匹配的。execution()指示器是在编写切点定义时最主要使用的指示器。

编写切点

设置当perform()方法执行时触发通知的调用，如下图所示：

使用execution()指示器选择Performance的perform()方法。方法表达式以*号开始，表明任意方法返回值的类型。然后指定全限定类名和方法名。对于方法参数列表，使用两个点号(..)表明切点要选择任意的perform()方法，无论该方法的入参是什么。

假设我们需要配置的切点仅匹配concert包。在此场景下，可以使用within()指示器来限制匹配，如下图所示：

在切点中选择 bean

Spring 的bean()指示器允许在切点表达式中使用 bean 的 ID 来标识 bean。bean()使用 bean ID 或 bean 名称作为参数来限制切点只匹配特定的 bean。

execution(* concert.Performance.perform()) and bean('woodstock')

使用非操作为除了特定 ID 以外的其他 bean 应用通知。

execution(* concert.Performance.perform()) and !bean('woodstock')

定义切面

普通通知

使用@Aspect注解声明这是一个切面类。

使用@Pointcut注解定义切面内可重用的切点，这样之后的通知注解中可以直接使用定义的切点，不嫌麻烦可以使用重复的@Before("execution( concert.Performance.perform(..))")。

在该类添加@Component注解或者使用@bean将该类注册成 bean。

@Aspect
public class Audience {

  @Pointcut("execution(* concert.Performance.perform(..))")
  public void performance() { }

  @Before("performance()")
  public void silenceCellPhones() {
    System.out.println("Silencing cell phones");
  }
  
  @Before("performance()")
  public void takeSeats() {
    System.out.println("Taking seats");
  }
  
  @AfterReturning("performance()")
  public void applause() {
    System.out.println("CLAP CLAP CLAP!!!");
  }
  
  @AfterThrowing("performance()")
  public void demandRefund() {
    System.out.println("Demanding a refund");
  }
}

此时这个类并不会被视为切面，要启用切面的代理需要使用 JavaConfig，在 config 上使用@EnableAspectJAutoProxy注解来启用自动代理功能。

@Configuration
@EnableAspectJAutoProxy
@Component
public class ConcertConfig {

  @Bean
  public Audience audience() {
    return new Audience();
  }
}

环绕通知

@Around("performance()")
public void watchPerformance(ProceedingJoinPoint jp) {
  try {
    System.out.println("Silencing cell phones");
    System.out.println("Taking seats");
    jp.procee();
    System.out.println("CLAP CLAP CLAP!!!");
  } catch (Throwable e) {
    System.out.println("Demanding a refund");
  }

环绕通知 = 前置通知 + 目标方法执行 + 后置通知

环绕通知接收ProceedingJoinPoint作为必需的参数，调用ProceedingJoinPoint的proceed()方法实现目标方法执行，在该方法前后的内容实现前置通知和后置通知。如果不调用proceed()方法会阻塞对被通知方法的调用，如果多次调用proceed()方法能实现对方法的多次调用。

处理通知中的参数

切面要访问和使用传递给被通知方法（目标方法）的参数的情况

@Aspect
public class TrackCounter {

  private Map<Integer, Integer> trackCounts = new HashMap<>();
  
  @Pointcut("execution(* soundsystem.CompactDisc.playTrack(int) && args(trackNumber))")
  public void trackPlayed(int trackNumber) { }

  @Before("trackPlayed(trackNumber)")
  public void countTrack(int trackNumber) {
    int currentCount = getPlayCount(trackNumber);
    trackCounts.put(trackNumber, currentCount + 1);
  }
}

下面具体分析：

playTrack括号中的int表示匹配到方法参数为int的方法。&&之后的args表示传递目标方法中的参数到通知方法中，参数名为trackNumber，对应的通知方法的形参中的参数名要相同。

当需要传递多个参数时，注解中不需要args，只需为通知方法添加一个参数作为第一个形参，类型为org.aspectj.lang.JoinPoint，它提供了getArgs()之类的方法可以获取所有参数和其他值。

通知方法参数相关详情请看官方文档Declaring Advice :: Spring Framework。

通过切面为 bean 添加新功能

实现

官方文档Introductions :: Spring Framework

在 Spring 中，切面实现了它们所包装 bean 的相同接口，如果除了实现这些接口，代理还暴露新的接口，这样看起来就像 bean 引入了新方法。当引入接口的方法被调用时，代理会把此调用委托给实现了新接口的某个实现类，因此一个 bean 的实现被拆分到了多个类中。如下图所示：

下面是示例代码：

public interface Encoreable {
  void performEncore();
}

@Aspect
public class EncodeableIntroducer {

  @DeclareParents(value="concert.Performance+",
                  defaultImpl=DefaultEncoreable.class)
  public static Encoreable encoreable;
}

Encoreable接口类为需要向 bean 添加的新接口，其中的performEncore()方法就是新接口方法。EncodeableIntroducer类为切面，实现引入功能，同样要将该类注册为 bean。

通过@DeclareParents注解，将Encoreable接口引入到Performance bean中。分为三部分：

• value属性指定了要将接口引入到哪个类型的 bean。在本例中，也就是所有Performance类型。（标记符后面的加号表示是Performance的所有子类型，而不是Performance本身。）
• defaultImpl属性指定了为引入功能提供实现的类，即引入接口的实现类。
• @DeclareParents注解所标注的静态属性指明了要引入的接口。

调用

有两种方法

强制转换

强制转换类型为新添加的接口类型。

public class SpringDeclareParentsTest {
    public static void main(String[] args) {
        //1.创建容器
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);
        //2.获取对象
        Performance performance = ac.getBean("performance",Performance.class);
        //3.自行强转
        Encoreable encoreable = (Encoreable)performance;
    //4.调用添加的方法
    encoreable.performEncore();
    //5.调用目标类中的方法。
        performance.perform();
    }
}

使用this关键字

在通知类中，使用this关键字，引入新目标类对象，调用方法。

@Component
@Aspect
public class EncodeableIntroducer {

    @DeclareParents(value="concert.Performance+",
                  defaultImpl=DefaultEncoreable.class)
    public static Encoreable encoreable;

    @Before("execution(* *.*.(..)) && this(encoreable)")
    public void printlog(Encoreable encoreable){
        encoreable.performEncore();
    }
}

public class SpringDeclareParentsTest {
    public static void main(String[] args) {
        //1.创建容器
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);
        //2.获取对象
        Performance performance = ac.getBean("performance",Performance.class);
        //3.调用目标类中的方法。
        performance.printlog();
      }
}