// 目标类：专注核心业务
public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String username) {
        // 核心业务：新增用户
        System.out.println("数据库新增用户：" + username);
    }
    
    @Override
    public void deleteUser(String username) {
        System.out.println("数据库删除用户：" + username);
    }
}

public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String username) {
        System.out.println("【日志】开始执行addUser，参数：" + username);  // 日志逻辑入侵业务代码
        System.out.println("数据库新增用户：" + username);
        System.out.println("【日志】addUser执行完成");
    }
    // deleteUser同理...
}

// 1. 抽象主题接口（定义房东和中介都要做的事情）
public interface HouseSubject {
    void rentHouse();
}

// 2. 真实主题——房东（目标对象）
public class RealHouseSubject implements HouseSubject {
    @Override
    public void rentHouse() {
        System.out.println("我是房东，我出租房子！");
    }
}

// 3. 代理类——中介
public class HouseProxy implements HouseSubject {
    private HouseSubject houseSubject;  // 持有目标对象的引用
    
    public HouseProxy(HouseSubject houseSubject) {
        this.houseSubject = houseSubject;
    }
    
    @Override
    public void rentHouse() {
        System.out.println("【前置增强】中介开始筛选租客");
        houseSubject.rentHouse();  // 调用房东的真实方法
        System.out.println("【后置增强】中介完成合同签订");
    }
}

// 4. 客户端调用
public class Client {
    public static void main(String[] args) {
        HouseSubject landlord = new RealHouseSubject();
        HouseProxy proxy = new HouseProxy(landlord);
        proxy.rentHouse();  // 通过代理访问目标方法
    }
}

【前置增强】中介开始筛选租客
我是房东，我出租房子！
【后置增强】中介完成合同签订

客户端调用代理对象方法 → 代理类转发到InvocationHandler → InvocationHandler执行invoke方法 → 反射调用目标对象方法

// 1. 定义接口（必须有接口）
public interface StudentService {
    void study(String studentName);
    void eat();
}

// 2. 目标实现类
public class StudentServiceImpl implements StudentService {
    @Override
    public void study(String studentName) {
        System.out.println(studentName + " 正在学习...");
    }
    @Override
    public void eat() {
        System.out.println("正在吃饭...");
    }
}

// 3. 实现InvocationHandler，封装增强逻辑
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("【日志】方法 " + method.getName() + " 开始执行");
        
        // 通过反射调用目标对象的真实方法
        Object result = method.invoke(target, args);
        
        // 后置增强
        System.out.println("【日志】方法 " + method.getName() + " 执行完毕");
        return result;
    }
}

// 4. 生成代理对象并调用
public class JdkProxyDemo {
    public static void main(String[] args) {
        // 创建目标对象
        StudentService target = new StudentServiceImpl();
        
        // 创建InvocationHandler
        InvocationHandler handler = new LogInvocationHandler(target);
        
        // 生成代理对象（关键：三个参数）
        StudentService proxy = (StudentService) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),  // 类加载器
            target.getClass().getInterfaces(),   // 目标对象实现的接口数组
            handler                              // InvocationHandler处理器
        );
        
        // 通过代理对象调用方法
        proxy.study("张三");
    }
}

【日志】方法 study 开始执行
张三 正在学习...
【日志】方法 study 执行完毕

// 1. 目标类（无需实现任何接口）
public class OrderService {
    public void placeOrder() {
        System.out.println("正在创建订单...");
    }
}

// 2. 实现MethodInterceptor拦截器
public class LogInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("【CGLIB前置日志】方法 " + method.getName() + " 开始执行");
        
        // 调用父类（目标类）的原始方法（注意：使用invokeSuper而非反射）
        Object result = proxy.invokeSuper(obj, args);
        
        System.out.println("【CGLIB后置日志】方法 " + method.getName() + " 执行完毕");
        return result;
    }
}

// 3. 生成CGLIB代理对象
public class CglibProxyDemo {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(OrderService.class);      // 设置父类（目标类）
        enhancer.setCallback(new LogInterceptor());      // 设置拦截器
        
        OrderService proxy = (OrderService) enhancer.create();  // 生成代理对象
        proxy.placeOrder();
    }
}

【CGLIB前置日志】方法 placeOrder 开始执行
正在创建订单...
【CGLIB后置日志】方法 placeOrder 执行完毕

代理模式（思想）
    ├── 静态代理（编译期确定，需手动编写代理类）
    └── 动态代理（运行期生成，自动创建代理类）
            ├── JDK动态代理（基于接口 + 反射）
            └── CGLIB动态代理（基于继承 + 字节码增强）

// ============ JDK动态代理示例 ============
public class JdkComparison {
    public static void main(String[] args) {
        // 前提：目标类必须实现接口
        UserService target = new UserServiceImpl();
        
        UserService proxy = (UserService) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            (proxyObj, method, args1) -> {
                System.out.println("JDK代理前置");
                Object result = method.invoke(target, args1);
                System.out.println("JDK代理后置");
                return result;
            }
        );
        proxy.addUser("张三");
    }
}

// ============ CGLIB动态代理示例 ============
public class CglibComparison {
    public static void main(String[] args) {
        // 无需接口，可直接代理普通类
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(OrderService.class);
        enhancer.setCallback((MethodInterceptor) (obj, method, args, proxy) -> {
            System.out.println("CGLIB代理前置");
            Object result = proxy.invokeSuper(obj, args);
            System.out.println("CGLIB代理后置");
            return result;
        });
        OrderService proxy = (OrderService) enhancer.create();
        proxy.placeOrder();
    }
}

// JDK动态代理生成的代理类简化版
public class $Proxy0 extends Proxy implements UserService {
    private InvocationHandler h;
    
    public $Proxy0(InvocationHandler h) { super(h); }
    
    public void addUser(String name) {
        h.invoke(this, addUserMethod, new Object[]{name});
    }
}