@Service
public class OrderService {
    public void createOrder(Order order) {
        // 日志记录
        System.out.println("开始创建订单，订单号：" + order.getNo());
        long start = System.currentTimeMillis();
        
        // 权限校验
        if (!hasPermission(order.getUserId())) {
            throw new SecurityException("无权限");
        }
        
        // 核心业务逻辑
        orderDao.save(order);
        
        // 事务管理
        transaction.commit();
        
        // 性能监控
        System.out.println("订单创建耗时：" + (System.currentTimeMillis() - start) + "ms");
    }
}

@Aspect
@Component
@Slf4j
public class LogAspect {
    
    // 1. 前置通知：目标方法执行前执行
    @Before("execution( com.example.service..(..))")
    public void beforeMethod(JoinPoint joinPoint) {
        log.info("【@Before】即将执行方法：{}", joinPoint.getSignature().getName());
    }
    
    // 2. 后置通知：目标方法执行后执行（无论是否异常，类似finally）
    @After("execution( com.example.service..(..))")
    public void afterMethod(JoinPoint joinPoint) {
        log.info("【@After】方法执行结束，无论结果如何");
    }
    
    // 3. 返回通知：目标方法正常返回后执行（可访问返回值）
    @AfterReturning(pointcut = "execution( com.example.service..(..))", returning = "result")
    public void afterReturning(JoinPoint joinPoint, Object result) {
        log.info("【@AfterReturning】方法正常返回，结果：{}", result);
    }
    
    // 4. 异常通知：目标方法抛出异常时执行
    @AfterThrowing(pointcut = "execution( com.example.service..(..))", throwing = "ex")
    public void afterThrowing(JoinPoint joinPoint, Exception ex) {
        log.error("【@AfterThrowing】方法抛出异常：{}", ex.getMessage());
    }
    
    // 5. 环绕通知：包裹目标方法，可完全控制执行流程
    @Around("execution( com.example.service..(..))")
    public Object aroundMethod(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("【@Around】方法执行前...");
        long start = System.currentTimeMillis();
        
        Object result = joinPoint.proceed(); // 执行目标方法
        
        long duration = System.currentTimeMillis() - start;
        log.info("【@Around】方法执行完成，耗时：{}ms", duration);
        return result;
    }
}

@Before("execution( com.example.service..(..))")
public void logArgs(JoinPoint joinPoint) {
    // 获取方法参数
    Object[] args = joinPoint.getArgs();
    // 获取方法签名（可拿到方法名）
    Signature signature = joinPoint.getSignature();
    // 获取目标对象
    Object target = joinPoint.getTarget();
    
    log.info("方法名：{}，参数：{}", signature.getName(), Arrays.toString(args));
}

@Around前置部分 → @Before → 目标方法执行 → @AfterReturning/@AfterThrowing → @After → @Around后置部分

execution(<修饰符> <返回类型> <包名.类名.方法(参数)> <异常>)

// 匹配com.example.service包下所有类的所有方法
@Before("execution( com.example.service..(..))")

// 匹配com.example包及其子包下所有类的所有方法
@Before("execution( com.example...(..))")

// 匹配所有public方法
@Before("execution(public  (..))")

// 匹配UserService类及其子类的所有方法
@Before("execution( com.example.service.UserService+.(..))")

// 1. 定义自定义注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Loggable {
    String value() default "";
}

// 2. 在需要增强的方法上添加注解
@Service
public class UserService {
    @Loggable("用户登录")
    public void login(String username) {
        // 业务逻辑
    }
}

// 3. 使用@annotation匹配被该注解标记的方法
@Aspect
@Component
public class LogAspect {
    @Around("@annotation(loggable)")
    public Object logAround(ProceedingJoinPoint joinPoint, Loggable loggable) throws Throwable {
        log.info("开始执行：{}", loggable.value());
        return joinPoint.proceed();
    }
}

@Aspect
@Component
public class ServiceAspect {
    
    // 声明切点
    @Pointcut("execution( com.example.service..(..))")
    public void serviceLayer() {}
    
    @Before("serviceLayer()")
    public void beforeService() {
        log.info("Service层方法执行前...");
    }
    
    @After("serviceLayer()")
    public void afterService() {
        log.info("Service层方法执行后...");
    }
}

@Service
public class OrderService {
    public void createOrder(Order order) {
        log.info("创建订单开始，订单号：{}", order.getNo());
        long start = System.currentTimeMillis();
        
        // 权限校验（重复）
        if (!SecurityContext.hasPermission("ORDER_CREATE")) {
            throw new SecurityException("无权限");
        }
        
        // 核心业务逻辑
        orderDao.save(order);
        
        // 事务提交（重复）
        transaction.commit();
        
        log.info("创建订单结束，耗时：{}ms", System.currentTimeMillis() - start);
    }
    
    public void updateOrder(Order order) {
        log.info("更新订单开始，订单号：{}", order.getNo());
        long start = System.currentTimeMillis();
        
        // 同样的权限校验代码重复出现
        if (!SecurityContext.hasPermission("ORDER_UPDATE")) {
            throw new SecurityException("无权限");
        }
        
        // 核心业务逻辑
        orderDao.update(order);
        
        transaction.commit();
        
        log.info("更新订单结束，耗时：{}ms", System.currentTimeMillis() - start);
    }
}

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

@Aspect
@Component
@Slf4j
public class ServiceAspect {
    
    // 权限校验切点
    @Pointcut("@annotation(RequirePermission)")
    public void permissionCheck() {}
    
    // 性能监控切点
    @Pointcut("execution( com.example.service..(..))")
    public void performanceMonitor() {}
    
    // 权限校验增强
    @Before("permissionCheck() && @annotation(requirePermission)")
    public void checkPermission(JoinPoint joinPoint, RequirePermission requirePermission) {
        String permission = requirePermission.value();
        if (!SecurityContext.hasPermission(permission)) {
            throw new SecurityException("缺少权限：" + permission);
        }
        log.info("权限校验通过：{}", permission);
    }
    
    // 性能监控增强
    @Around("performanceMonitor()")
    public Object monitorPerformance(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long duration = System.currentTimeMillis() - start;
        log.info("【性能】方法 {} 耗时：{}ms", joinPoint.getSignature().getName(), duration);
        return result;
    }
    
    // 统一异常处理
    @AfterThrowing(pointcut = "performanceMonitor()", throwing = "ex")
    public void handleException(JoinPoint joinPoint, Exception ex) {
        log.error("【异常】方法 {} 抛出异常：{}", joinPoint.getSignature().getName(), ex.getMessage());
    }
}

@Service
@Slf4j
public class OrderService {
    
    @RequirePermission("ORDER_CREATE")  // 权限校验
    public void createOrder(Order order) {
        // 只有核心业务逻辑，没有横切代码
        orderDao.save(order);
    }
    
    @RequirePermission("ORDER_UPDATE")
    public void updateOrder(Order order) {
        orderDao.update(order);
    }
}

// Spring内部选择逻辑（伪代码）
if (目标类实现了至少一个接口 && 未强制使用CGLIB) {
    使用 JDK 动态代理
} else {
    使用 CGLIB 动态代理
}

public interface UserService {
    void saveUser(String name);
}

public class UserServiceImpl implements UserService {
    @Override
    public void saveUser(String name) {
        System.out.println("保存用户：" + name);
    }
}

// 调用处理器
public class LogInvocationHandler implements InvocationHandler {
    private Object target;
    
    public LogInvocationHandler(Object target) { this.target = target; }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("【JDK代理】方法执行前：" + method.getName());
        Object result = method.invoke(target, args);  // 反射调用
        System.out.println("【JDK代理】方法执行后：" + method.getName());
        return result;
    }
}

// 创建代理
UserService target = new UserServiceImpl();
UserService proxy = (UserService) Proxy.newProxyInstance(
    UserService.class.getClassLoader(),
    new Class[]{UserService.class},
    new LogInvocationHandler(target)
);
proxy.saveUser("张三");

public class UserService {  // 无需实现接口
    public void saveUser(String name) {
        System.out.println("保存用户：" + name);
    }
}

// CGLIB代理（Spring内部封装，开发者通常无需手动编写）
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(UserService.class);
enhancer.setCallback(new MethodInterceptor() {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) 
            throws Throwable {
        System.out.println("【CGLIB代理】方法执行前：" + method.getName());
        Object result = proxy.invokeSuper(obj, args);  // 调用父类方法
        System.out.println("【CGLIB代理】方法执行后：" + method.getName());
        return result;
    }
});
UserService proxy = (UserService) enhancer.create();
proxy.saveUser("张三");

@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)  // 强制使用CGLIB
public class AopConfig { }