Spring AOP 核心概念与实战应用详解

注解说明：

• @Aspect：标识这是一个切面类。
• @Component：交给 Spring 容器管理，支持自动扫描注入。
• @Around：定义环绕通知，包围目标方法。
• @Slf4j：自动生成日志对象，方便打印信息。

Spring AOP 的核心术语

理解这些术语是掌握 AOP 的关键：

1. Aspect（切面）：横切关注点的模块化。它是一个类，包含了需要织入到业务代码中的各种通知（Advice）。
2. Join Point（连接点）：程序执行过程中可以插入切面的点。在 Spring AOP 中，连接点总是代表执行的方法。
3. Pointcut（切点）：一个表达式，用于定义在哪些连接点上应用通知。它回答了'在哪里'执行切面代码的问题。
4. Advice（通知）：切面在特定连接点上执行的动作。指具体要做的操作，回答了'什么时候'和'做什么'的问题。

通知类型：

• @Before：在目标方法执行之前执行。
• @After：在目标方法执行之后执行（无论是否成功）。
• @AfterReturning：在目标方法成功执行并返回结果后执行。
• @AfterThrowing：在目标方法抛出异常后执行。
• @Around：最强大的通知，包围连接点，可决定是否继续执行、修改返回值或抛出异常。

通知类型注解实战

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

package com.example.demo.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.demo.aspect;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Slf4j
@Aspect
@Component
public class TestAspect {

    // 抽取公共切点
    @Pointcut("execution(* com.example.demo.controller.*.*(..))")
    public void pt() {}

    @Before("pt()")
    public void doBefore() {
        log.info("前置通知执行");
    }

    @After("pt()")
    public void doAfter() {
        log.info("后置通知执行");
    }

    @AfterReturning("pt()")
    public void doAfterReturning() {
        log.info("返回后通知执行");
    }

    @AfterThrowing("pt()")
    public void doAfterThrowing() {
        log.info("异常后通知执行");
    }

    @Around("pt()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("环绕通知开始");
        Object result = null;
        try {
            result = joinPoint.proceed();
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
        log.info("环绕通知结束");
        return result;
    }
}

@PointCut 与 @Order

复用切点表达式 当多个通知使用相同的切点时，可以使用 @PointCut 定义公共方法，避免重复编写表达式。

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

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

控制执行顺序 当存在多个切面时，可以通过 @Order 设置优先级。数字越小，优先级越高。

@Aspect
@Component
@Slf4j
@Order(1)
public class TestAspect3 {
    @Before("pt()")
    public void doBefore() {
        log.info("优先级最高的切面");
    }
}

默认情况下，Spring 会按照类名排序，但显式指定 @Order 能确保关键逻辑优先执行。

切点表达式

主要有两种匹配方式：

1. execution 表达式：基于方法签名匹配。 格式：execution(<访问修饰符><返回类型><包名。类名。方法名 (方法参数)><异常>) 其中 * 匹配任意字符，.. 匹配多层包路径。例如 com.example.service.*.*(..) 匹配该包下所有类的所有方法。

2. @annotation 自定义注解：针对没有规律的方法，可以通过自定义注解标记。

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface TimeRecord {}

在切面中使用 @annotation 进行匹配：

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

只需在目标方法上添加 @TimeRecord 即可生效。

代理模式

代理模式的核心目的是在不修改原始对象代码的前提下，通过代理对象增强或控制对目标对象的访问。Spring AOP 涉及两种动态代理机制：

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

Spring AOP 原理

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

工作流程：

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

配置项说明： ProxyFactory 有一个重要属性 proxyTargetClass。Spring Boot 默认为 true（优先使用 CGLIB），Spring 原生默认为 false（优先使用 JDK 代理）。可通过配置文件调整：

spring.aop.proxy-target-class=true

这样就能灵活控制代理策略，适应不同的业务场景。