@Service
public class OrderService {
    public void createOrder(Order order) {
        long start = System.currentTimeMillis();
        System.out.println("【日志】调用createOrder，参数：" + order);
        try {
            // 核心业务逻辑
            System.out.println("执行创建订单业务...");
        } finally {
            System.out.println("【耗时】createOrder执行耗时：" + 
                (System.currentTimeMillis() - start) + "ms");
        }
    }
    
    public void cancelOrder(Long orderId) {
        long start = System.currentTimeMillis();
        System.out.println("【日志】调用cancelOrder，参数：" + orderId);
        try {
            // 核心业务逻辑
            System.out.println("执行取消订单业务...");
        } finally {
            System.out.println("【耗时】cancelOrder执行耗时：" + 
                (System.currentTimeMillis() - start) + "ms");
        }
    }
    // 其他方法都要重复写这段代码...
}

@Service
public class OrderService {
    public void createOrder(Order order) {
        // 只写业务逻辑，日志和耗时统计交给切面处理
        System.out.println("执行创建订单业务...");
    }
    
    public void cancelOrder(Long orderId) {
        System.out.println("执行取消订单业务...");
    }
}

@Aspect
@Component
public class LogAndPerformanceAspect {
    
    @Around("execution( com.example.service..(..))")
    public Object aroundMethod(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        System.out.println("【日志】调用" + joinPoint.getSignature().getName() + 
            "，参数：" + Arrays.toString(joinPoint.getArgs()));
        try {
            Object result = joinPoint.proceed();  // 执行目标方法
            System.out.println("【耗时】执行耗时：" + 
                (System.currentTimeMillis() - start) + "ms");
            return result;
        } catch (Exception e) {
            System.out.println("【异常】方法执行失败：" + e.getMessage());
            throw e;
        }
    }
}

切面（Aspect）——横切关注点的封装容器
    │
    ├── 切点（Pointcut）——筛选规则，定义切入哪些方法
    │
    └── 通知（Advice）——增强逻辑，定义何时做什么

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

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {
    
    // 定义切点：匹配com.example.service包下所有类的所有方法
    @Pointcut("execution( com.example.service..(..))")
    public void serviceMethod() {}
    
    // 前置通知
    @Before("serviceMethod()")
    public void logBefore() {
        System.out.println("【前置通知】方法开始执行");
    }
    
    // 返回通知
    @AfterReturning(pointcut = "serviceMethod()", returning = "result")
    public void logAfterReturning(Object result) {
        System.out.println("【返回通知】方法执行完成，返回值：" + result);
    }
    
    // 异常通知
    @AfterThrowing(pointcut = "serviceMethod()", throwing = "ex")
    public void logAfterThrowing(Exception ex) {
        System.out.println("【异常通知】方法抛出异常：" + ex.getMessage());
    }
    
    // 环绕通知（功能最强，可以控制目标方法是否执行）
    @Around("serviceMethod()")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        System.out.println("【环绕通知-前】方法：" + joinPoint.getSignature().getName());
        
        try {
            Object result = joinPoint.proceed();  // ⚠️ 必须调用，否则目标方法不执行
            long duration = System.currentTimeMillis() - start;
            System.out.println("【环绕通知-后】执行耗时：" + duration + "ms");
            return result;
        } catch (Exception e) {
            System.out.println("【环绕通知-异常】捕获异常：" + e.getMessage());
            throw e;
        }
    }
}

@Service
public class UserService {
    public String getUserById(Long id) {
        System.out.println("【业务方法】正在查询用户，id=" + id);
        if (id <= 0) {
            throw new RuntimeException("无效的用户ID");
        }
        return "User-" + id;
    }
}

容器启动 → 扫描切面定义 → 根据切点匹配目标Bean → 判断代理方式（JDK/CGLIB）→ 生成代理对象 → 存入容器