Spring AOP互动AI助手：2026年4月核心机制与面试全解析

public void createOrder(Order order) {
    // 记录日志
    log.info("create order start");
    // 权限校验
    checkPermission();
    // 事务开始
    beginTransaction();
    // 核心业务逻辑
    orderService.save(order);
    // 事务提交
    commitTransaction();
    log.info("create order end");
}

┌─────────────────────────────────────────────────────┐
│  AOP（思想/规范）                                      │
│  ├── 定义了：切面、通知、切点、连接点等概念             │
│  └── 指明了：如何抽离横切关注点                        │
└─────────────────────────────────────────────────────┘
                        │
                        ▼
┌─────────────────────────────────────────────────────┐
│  Spring AOP（实现，基于动态代理，运行时织入）            │
│  ├── 简化版AOP实现，功能局限于方法拦截                  │
│  └── 依赖Spring IoC容器                              │
└─────────────────────────────────────────────────────┘
                        │
                        ▼
┌─────────────────────────────────────────────────────┐
│  AspectJ（实现，编译时/加载时织入，功能完整）            │
│  ├── 最完整、最权威的AOP实现                           │
│  └── 可织入字段、构造器等，Spring AOP无法做到           │
└─────────────────────────────────────────────────────┘

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

@Aspect
@Component
public class LogAspect {
    
    // 定义切点：拦截service包下所有类的所有方法
    @Pointcut("execution( com.example.service..(..))")
    public void servicePointcut() {}
    
    // 前置通知：目标方法执行前触发
    @Before("servicePointcut()")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("[前置通知] 方法 " + joinPoint.getSignature().getName() + " 开始执行");
    }
    
    // 后置通知：目标方法执行后触发（正常或异常都会执行）
    @After("servicePointcut()")
    public void logAfter(JoinPoint joinPoint) {
        System.out.println("[后置通知] 方法 " + joinPoint.getSignature().getName() + " 执行结束");
    }
    
    // 环绕通知：完全控制方法执行流程（最常用）
    @Around("servicePointcut()")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        String methodName = joinPoint.getSignature().toShortString();
        
        System.out.println("[环绕-前置] " + methodName + " 开始");
        Object result = joinPoint.proceed();  // 执行目标方法
        long duration = System.currentTimeMillis() - start;
        
        System.out.println("[环绕-后置] " + methodName + " 执行耗时: " + duration + "ms");
        return result;
    }
}

@Service
public class OrderService {
    public void createOrder(String orderNo) {
        System.out.println("核心业务：创建订单 " + orderNo);
    }
}

@SpringBootTest
class AopTest {
    @Autowired
    private OrderService orderService;
    
    @Test
    void testAop() {
        orderService.createOrder("ORD-001");
    }
}

[环绕-前置] OrderService.createOrder(..) 开始
[前置通知] 方法 createOrder 开始执行
核心业务：创建订单 ORD-001
[后置通知] 方法 createOrder 执行结束
[环绕-后置] OrderService.createOrder(..) 执行耗时: 12ms

// Spring默认策略（简化版）
if (目标类实现了接口) {
    使用JDK动态代理（默认）
} else {
    使用CGLIB代理
}