@Service
public class OrderServiceImpl implements OrderService {
    private static final Logger logger = LoggerFactory.getLogger(OrderServiceImpl.class);
    
    @Override
    public void createOrder(OrderDTO order) {
        // 1. 日志记录——横切逻辑
        logger.info("开始创建订单，参数：{}", order);
        long startTime = System.currentTimeMillis();
        
        // 2. 业务核心逻辑
        // 验证参数、生成订单、扣减库存...
        
        // 3. 性能监控——横切逻辑
        long duration = System.currentTimeMillis() - startTime;
        logger.info("创建订单完成，耗时：{}ms", duration);
        
        // 4. 异常处理——横切逻辑
        // 遍布在各个方法中的try-catch...
    }
}

@Aspect
@Component
public class OrderAspect {
    
    // 定义切点：匹配OrderService下的所有方法
    @Pointcut("execution( com.example.service.OrderService.(..))")
    public void orderMethods() {}
    
    // 1. 前置通知：目标方法执行前运行
    @Before("orderMethods()")
    public void beforeMethod(JoinPoint joinPoint) {
        System.out.println("【Before】方法即将执行：" + joinPoint.getSignature().getName());
    }
    
    // 2. 返回通知：目标方法正常返回后运行
    @AfterReturning(pointcut = "orderMethods()", returning = "result")
    public void afterReturning(JoinPoint joinPoint, Object result) {
        System.out.println("【AfterReturning】方法返回：" + result);
    }
    
    // 3. 异常通知：目标方法抛出异常后运行
    @AfterThrowing(pointcut = "orderMethods()", throwing = "ex")
    public void afterThrowing(JoinPoint joinPoint, Exception ex) {
        System.out.println("【AfterThrowing】方法异常：" + ex.getMessage());
    }
    
    // 4. 后置通知：无论正常/异常，方法结束后都运行（类似finally）
    @After("orderMethods()")
    public void afterMethod(JoinPoint joinPoint) {
        System.out.println("【After】方法执行结束");
    }
    
    // 5. 环绕通知：功能最强大，可完全控制目标方法的执行
    @Around("orderMethods()")
    public Object aroundMethod(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        System.out.println("【Around】前置逻辑");
        
        Object result = joinPoint.proceed();  // 执行目标方法
        
        long duration = System.currentTimeMillis() - start;
        System.out.println("【Around】后置逻辑，耗时：" + duration + "ms");
        return result;
    }
}

切面（Aspect）= 切点（Pointcut）+ 通知（Advice）
                    ↓                    ↓
               在哪里执行？          何时/做什么？
                    ↓                    ↓
               连接点匹配          通知类型选择
                    ↓                    ↓
                   └──── 织入（Weaving）────┘
                              ↓
                        代理对象生成

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

@Target(ElementType.METHOD)      // 仅作用于方法
@Retention(RetentionPolicy.RUNTIME)
public @interface TimeMonitor {
    String value() default "";
}

@Aspect
@Component
@Slf4j
public class TimeMonitorAspect {
    
    // 切点：匹配所有标注了@TimeMonitor注解的方法
    @Pointcut("@annotation(com.example.annotation.TimeMonitor)")
    public void timeMonitorMethods() {}
    
    @Around("timeMonitorMethods()")
    public Object monitor(ProceedingJoinPoint joinPoint) throws Throwable {
        String methodName = joinPoint.getSignature().toShortString();
        long startTime = System.currentTimeMillis();
        
        try {
            Object result = joinPoint.proceed();
            long duration = System.currentTimeMillis() - startTime;
            log.info("【性能监控】方法 {} 执行耗时：{} ms", methodName, duration);
            return result;
        } catch (Exception e) {
            long duration = System.currentTimeMillis() - startTime;
            log.error("【性能监控】方法 {} 执行异常，耗时：{} ms，异常：{}", 
                      methodName, duration, e.getMessage());
            throw e;
        }
    }
}

@Service
public class OrderServiceImpl implements OrderService {
    
    @Override
    @TimeMonitor("订单创建")
    public void createOrder(OrderDTO order) {
        // 纯业务逻辑——AOP自动在前后织入性能监控
        // 此处无需任何监控相关代码
        // 模拟耗时操作
        Thread.sleep(100);
    }
}

【性能监控】方法 OrderServiceImpl.createOrder(..) 执行耗时：102 ms