Spring AOP 核心原理与实战指南

关键注解说明：

• @Aspect：标识这是一个切面类。
• @Component：交给 Spring 容器管理，自动扫描注入。
• @Around：指明环绕通知生效的位置。
• @Slf4j：Lombok 提供的日志注解，简化日志打印。

Spring AOP 的核心术语

理解这些概念是掌握 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.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.springaopdemo.controller.*.*(..))")
    public void pt() {}

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

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

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

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

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

切点复用与优先级

@PointCut 复用

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

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

在其他通知中直接引用方法名即可：

@Before("serviceLayer()")
public void beforeService() { /* ... */ }

@Order 控制顺序

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

@Aspect
@Component
@Slf4j
@Order(1)
public class TestAspect3 {
    @Before("pt()")
    public void doBefore() {
        log.info("TestAspect3 执行");
    }
}

默认情况下，若未指定 Order，Spring 会按照 Bean 名称排序。显式指定 @Order 可以更精确地控制执行流。

自定义注解切点

如果目标方法没有明显的命名规律，可以使用自定义注解配合 @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 注解即可生效。

代理模式详解

Spring AOP 的本质是通过动态代理增强对象。代理模式的核心是在不修改原始对象代码的前提下，通过代理对象控制访问。

主要分为两种动态代理：

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

底层原理

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

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