Spring AOP 原理：JDK 动态代理 vs CGLIB

// 1. 定义接口
public interface UserService {
    void save(String name);
}

// 2. 目标实现类
public class UserServiceImpl implements UserService {
    public void save(String name) {
        System.out.println("保存用户: " + name);
    }
}

// 3. 自定义 InvocationHandler
public class LogHandler implements InvocationHandler {
    private Object target;

    public LogHandler(Object target) {
        this.target = target;
    }

    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("[日志] 方法开始: " + method.getName());
        Object result = method.invoke(target, args);  // 反射调用目标
        System.out.println("[日志] 方法结束: " + method.getName());
        return result;
    }
}

// 4. 生成代理对象
UserService real = new UserServiceImpl();
UserService proxy = (UserService) Proxy.newProxyInstance(
    real.getClass().getClassLoader(),   // 类加载器
    real.getClass().getInterfaces(),    // 接口列表
    new LogHandler(real)               // InvocationHandler
);
proxy.save("Alice");  // 输出日志 + 保存用户

// 目标类（不需要接口）
public class OrderService {
    public void createOrder(String orderId) {
        System.out.println("创建订单: " + orderId);
    }
    public final void cancelOrder(String id) {
        System.out.println("取消订单: " + id);  // final 方法无法被代理
    }
}

// 自定义 MethodInterceptor
public class LogInterceptor implements MethodInterceptor {
    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;
    }
}

// 生成代理对象
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(OrderService.class);
enhancer.setCallback(new LogInterceptor());
OrderService proxy = (OrderService) enhancer.create();
proxy.createOrder("ORD-001");  // 有日志增强
proxy.cancelOrder("ORD-001");   // 无日志增强（final 方法）

@Service
public class UserServiceImpl implements UserService { ... }

// JDK 代理下（proxyTargetClass=false）
@Autowired
private UserServiceImpl userService;  // ❌ BeanNotOfRequiredTypeException!

// 正确做法：面向接口编程
@Autowired
private UserService userService;  // ✅ 注入接口类型

// AbstractAutoProxyCreator 简化逻辑
if (proxyTargetClass == true) {
    if (targetClass 是 final || targetClass 是 interface) {
        throw 异常;  // 无法代理
    }
    return CGLIB代理;
} else {
    if (targetClass 实现了至少一个接口) {
        return JDK代理;
    } else {
        return CGLIB代理;  // 没接口也只能用 CGLIB
    }
}

@Service
public class OrderService {

    @Transactional  // 事务注解，依赖 AOP 代理
    public void createOrder() {
        // 业务逻辑...
        saveLog();  // ❌ 自调用，直接走 this，不经过代理
    }

    @Async  // 异步注解，同样依赖 AOP
    public void saveLog() {
        // 日志保存...
    }
}

// 方案 1：AopContext.currentProxy()（需开启 exposeProxy）
@EnableAspectJAutoProxy(exposeProxy = true)
public void createOrder() {
    ((OrderService) AopContext.currentProxy()).saveLog();  // ✅
}

// 方案 2：自注入（把自身注入进来）
@Autowired private OrderService self;
public void createOrder() {
    self.saveLog();  // ✅ 走代理
}

// 方案 3：把方法拆到不同类（推荐）
@Autowired private LogService logService;
public void createOrder() {
    logService.saveLog();  // ✅ 跨类调用，天然走代理
}

@Service
public class PayService {
    @Transactional
    private void deductBalance() {  // ❌ private 方法，AOP 无法生效
        // CGLIB 子类无法重写 private 方法
        // JDK 代理只能代理接口方法
    }
}

@Service
public final class ConfigService {  // ❌ final 类，CGLIB 无法继承
    @Cacheable("config")
    public String getConfig() { ... }  // 缓存注解失效
}

@Service
public class AuthService {
    @Cacheable("perm")
    public final boolean checkPermission() { ... }  // ❌ final 方法
}

// 手动 new 的对象不经过 Spring 容器，没有代理增强
UserService service = new UserServiceImpl();
service.save("Bob");  // ❌ 任何 @Transactional 等注解都不会生效

// 正确做法：从容器获取
UserService service = applicationContext.getBean(UserService.class);
service.save("Bob");  // ✅ 拿到的是代理对象