标题：权威的AI助手：Spring AOP 全解析｜源码与面试题 (2026-04-10)

public class OrderService {
    
    public void createOrder(Order order) {
        // 日志记录
        System.out.println("[日志] 开始创建订单");
        // 权限校验
        System.out.println("[权限] 校验用户身份");
        // 性能监控
        long start = System.currentTimeMillis();
        // 核心业务逻辑
        System.out.println("订单创建成功");
        // 性能监控
        long end = System.currentTimeMillis();
        System.out.println("[监控] 耗时：" + (end - start) + "ms");
        // 事务管理（此处省略提交/回滚逻辑）
    }
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

@SpringBootApplication
@EnableAspectJAutoProxy  // 启用AOP，Spring Boot 通常已自动配置，但显式声明更安全
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@Service
public class OrderService {
    
    public String createOrder(String orderNo) {
        System.out.println("【业务】正在创建订单：" + orderNo);
        if (orderNo == null || orderNo.isEmpty()) {
            throw new IllegalArgumentException("订单号不能为空");
        }
        return "订单创建成功，订单号：" + orderNo;
    }
}

@Component
@Aspect  // 标记为切面类
@Slf4j
public class LoggingAspect {
    
    // 定义可复用的切点表达式
    @Pointcut("execution( com.example.service..(..))")
    public void serviceMethod() {}
    
    // 前置通知：方法执行前触发，常用于参数校验、权限检查
    @Before("serviceMethod()")
    public void logBefore(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        log.info("【前置】调用方法：{}，参数：{}", methodName, Arrays.toString(args));
    }
    
    // 后置返回通知：方法正常返回后触发，能拿到返回值但改不了
    @AfterReturning(pointcut = "serviceMethod()", returning = "result")
    public void logAfterReturning(JoinPoint joinPoint, Object result) {
        log.info("【返回】方法：{}，返回值：{}", joinPoint.getSignature().getName(), result);
    }
    
    // 后置异常通知：方法抛异常后触发，用于异常日志
    @AfterThrowing(pointcut = "serviceMethod()", throwing = "ex")
    public void logException(JoinPoint joinPoint, Exception ex) {
        log.error("【异常】方法：{}，异常信息：{}", joinPoint.getSignature().getName(), ex.getMessage());
    }
    
    // 最终通知：无论成功/异常都执行，类似finally，用于资源清理
    @After("serviceMethod()")
    public void logFinally(JoinPoint joinPoint) {
        log.info("【最终】方法：{} 执行完毕", joinPoint.getSignature().getName());
    }
    
    // 环绕通知：最强大，可控制执行、修改参数/返回值
    @Around("serviceMethod()")
    public Object logAround(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        log.info("【环绕-开始】{}", pjp.getSignature());
        try {
            Object result = pjp.proceed();  // 执行目标方法
            long cost = System.currentTimeMillis() - start;
            log.info("【环绕-结束】{}，耗时：{}ms，返回：{}", pjp.getSignature(), cost, result);
            return result;
        } catch (Exception e) {
            log.error("【环绕-异常】{}，异常：{}", pjp.getSignature(), e.getMessage());
            throw e;
        }
    }
}

@RestController
public class OrderController {
    @Autowired
    private OrderService orderService;
    
    @GetMapping("/order")
    public String createOrder(@RequestParam String orderNo) {
        return orderService.createOrder(orderNo);
    }
}

【环绕-开始】String com.example.service.OrderService.createOrder(String)
【前置】调用方法：createOrder，参数：[ORD123]
【业务】正在创建订单：ORD123
【返回】方法：createOrder，返回值：订单创建成功，订单号：ORD123
【最终】方法：createOrder 执行完毕
【环绕-结束】String com.example.service.OrderService.createOrder(String)，耗时：5ms，返回：订单创建成功，订单号：ORD123

┌─────────────────────────────────────────────────────────┐
│  环绕前代码 → @Before → 目标方法 → @AfterReturning →   │
│              → @After → 环绕后代码                      │
└─────────────────────────────────────────────────────────┘

if (hasUserSuppliedProxyInterfaces()) {
    return JDK dynamic proxy;  // 目标类有接口 → JDK代理
} else {
    return CGLIB proxy;        // 无接口 → CGLIB代理
}

@EnableAspectJAutoProxy(proxyTargetClass = true)

1. Spring容器启动，扫描@Aspect切面，生成Advisor（通知器）
2. 实例化目标Bean，完成依赖注入和初始化
3. BeanPostProcessor.postProcessAfterInitialization() 触发
   ↓
4. AbstractAutoProxyCreator.wrapIfNecessary()
   ↓
5. getAdvicesAndAdvisorsForBean() → 通过切点表达式匹配
   ↓
6. 匹配成功 → createProxy() 创建代理对象
   ↓
7. 代理对象替换原始Bean存入容器
   ↓
8. 调用代理方法 → 触发MethodInterceptor拦截链 → 按序执行通知

@Around("serviceMethod()")
public Object modifyParam(ProceedingJoinPoint pjp) throws Throwable {
    Object[] args = pjp.getArgs();
    if (args.length > 0 && args[0] instanceof String) {
        args[0] = "[预处理]" + args[0];
    }
    return pjp.proceed(args);  // 关键：传入修改后的参数
}