Spring AOP 核心原理与实战指南

这里的关键注解说明一下：

• @Aspect：标识这是一个切面类。
• @Component：交给 Spring 容器管理，支持自动扫描注入。
• @Around：指明环绕通知生效的范围。
• @Slf4j：自动生成日志对象。

核心术语解析

理解这些概念是掌握 AOP 的关键：

1. Aspect（切面）：横切关注点的模块化。它是一个类，包含了需要织入到业务代码中的各种通知（Advice）。
2. Join Point（连接点）：程序执行过程中可以插入切面的点。在 Spring AOP 中，连接点总是代表执行的方法。
3. Pointcut（切点）：一个表达式，用于定义在哪些连接点上应用通知。它回答了'在哪里'执行切面代码的问题。
4. Advice（通知）：切面在特定连接点上执行的动作。指具体要做的⼯作，回答了'什么时候'和'做什么'的问题。
   • @Before：目标方法执行之前。
   • @After：目标方法执行之后（无论是否成功）。
   • @AfterReturning：目标方法成功执行并返回结果后。
   • @AfterThrowing：目标方法抛出异常后。
   • @Around：最强大的通知，包围连接点，可决定是否继续执行、修改返回值或抛出异常。

下图展示了上述示例的执行流程：

通知类型注解实战

为了测试不同通知的效果，我们准备两个 Controller 方法。

package com.example.springaopdemo.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RestController
@RequestMapping("/test")
public class TestController {
    @RequestMapping("/t1")
    public String t1(){
        log.info("执行 t1");
        return "t1";
    }
    @RequestMapping("/t2")
    public boolean t2(){
        log.info("执行 t2");
        throw new RuntimeException("模拟异常");
    }
}

编写对应的切面类，覆盖所有通知类型：

package com.example.springaopdemo.aspect;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Aspect
@Component
@Slf4j
public class TestAspect {
    // 抽取切点，避免重复
    @Pointcut("execution(* com.example.springaopdemo.controller.*.*(..))")
    public void pt(){}

    @Before("pt()")
    public void doBefore() { log.info("执行 doBefore 方法"); }

    @After("pt()")
    public void doAfter() { log.info("执行 After 方法"); }

    @AfterReturning("pt()")
    public void doAfterReturning() { log.info("执行 AfterReturning 方法"); }

    @AfterThrowing("pt()")
    public void doAfterThrowing() { log.info("执行 doAfterThrowing 方法"); }

    @Around("pt()")
    public Object doAround(ProceedingJoinPoint joinPoint) {
        log.info("Around 方法开始执行");
        Object result = null;
        try {
            result = joinPoint.proceed();
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
        log.info("Around 方法结束执行");
        return result;
    }
}

访问 t1 接口（正常情况）：

访问 t2 接口（发生异常且不捕获）：

访问 t2 接口（发生异常且捕获不 throw）：

@PointCut 与 @Order

复用切点

如果多个通知使用相同的切点表达式，代码会显得冗余。使用 @PointCut 定义公共切点方法，可以在其他通知中通过方法名引用。

@Pointcut("execution(* com.example.service.*.*(..))")
public void serviceLayer() {}

// 在其他通知中直接调用
@Before("serviceLayer()")
public void beforeService() { /* ... */ }

控制优先级

当存在多个切面时，可以使用 @Order 设置优先级。数字越小，优先级越高。

@Component
@Aspect
@Slf4j
public class TestAspect2 {
    @Order(2)
    @Before("com.example.springaopdemo.aspect.TestAspect.pt()")
    public void doBefore() { log.info("执行 doBefore2 方法"); }
}

@Component
@Aspect
@Slf4j
public class TestAspect3 {
    @Order(1)
    @Before("com.example.springaopdemo.aspect.TestAspect.pt()")
    public void doBefore() { log.info("执行 doBefore3 方法"); }
}

默认情况下，切面按照类名字典序排序。添加 @Order 后可以人为干预执行顺序。

切点表达式

主要有两种匹配方式：

1. execution 表达式： 格式：execution(<访问修饰符><返回类型><包名。类名。方法名 (方法参数)><异常>) 其中 * 匹配任意字符，.. 匹配多个连续符号。访问修饰符和异常通常省略。

2. @annotation 自定义注解： 当目标方法没有规律可循时，可以通过自定义注解标记。

// 自定义注解
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface TimeRecord { }

在切面中使用该注解作为切点：

@Around("@annotation(com.example.springaopdemo.aspect.TimeRecord)")
public Object timeRecord(ProceedingJoinPoint joinPoint) throws Throwable {
    long start = System.currentTimeMillis();
    Object result = joinPoint.proceed();
    long end = System.currentTimeMillis();
    log.info(joinPoint.getSignature() + "耗时" + (end - start) + "ms");
    return result;
}

只要在对应方法上添加 @TimeRecord 注解即可实现计时功能。

代理模式

代理模式的核心目的是：在不修改原始对象（目标对象）代码的前提下，通过代理对象来增强或控制对目标对象的访问。

分为静态代理和动态代理，区别在于代理对象的 class 文件生成时机。

Spring AOP 主要涉及两种动态代理：

• JDK 动态代理：要求目标类必须实现至少一个接口。代理对象会实现与目标类相同的接口。
• CGLIB 字节码增强：当目标类没有实现接口时，Spring 会使用 CGLIB。它通过生成目标类的子类来创建代理，因此不能代理 final 类或方法。

Spring AOP 原理

Spring AOP 是通过动态代理将横切关注点（如日志、事务）模块化，并织入到目标方法的编程范式。

工作流程如下：

1. Spring 容器启动时，自动扫描被 @Aspect 注解的类。
2. 通过扫描切点表达式，找到所有匹配的 Bean（即目标对象）。
3. 通过 ProxyFactory 创建目标对象对应的代理对象（JDK/CGLIB），并将通知封装成拦截器链。
4. 在调用代理对象方法时，拦截器链被触发，按顺序执行通知逻辑，最终调用目标方法。

此外，ProxyFactory 有个重要属性 proxyTargetClass。

• SpringBoot 默认为 true（优先使用 CGLIB）。
• Spring 默认配置为 false（优先使用 JDK 动态代理）。

可通过配置文件调整：

spring.aop.proxy-target-class=true/false