AI信息助手深度解析：Java代理模式（静态代理vs动态代理）

public class PaymentService {
    public void pay() {
        // 监控、限流、审计...（占比80%）
        long start = System.nanoTime();
        System.out.println("〖日志〗开始执行支付...");
        
        realPay();  // 核心业务（占比20%）
        
        System.out.println("〖日志〗支付完成");
        System.out.println("耗时：" + (System.nanoTime() - start) + " ns");
        // 事务提交、日志回收...（占比80%）
    }
    private void realPay() { / 核心支付逻辑 / }
}

// 1. 定义业务接口（代理的契约）
public interface UserService {
    void addUser(String username);
    void deleteUser(String username);
}

// 2. 目标类：只负责核心业务
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);
    }
}

// 3. 静态代理类：增强逻辑 + 委派调用
public class UserServiceProxy implements UserService {
    private final UserService target;  // 持有目标对象引用
    
    public UserServiceProxy(UserService target) {
        this.target = target;
    }
    
    @Override
    public void addUser(String username) {
        // 前置增强：日志记录
        System.out.println("〖日志〗开始执行addUser，参数：" + username);
        // 调用目标对象的核心方法
        target.addUser(username);
        // 后置增强
        System.out.println("〖日志〗addUser执行完成");
    }
    
    @Override
    public void deleteUser(String username) {
        System.out.println("〖日志〗开始执行deleteUser，参数：" + username);
        target.deleteUser(username);
        System.out.println("〖日志〗deleteUser执行完成");
    }
}

// 4. 使用
UserService service = new UserServiceProxy(new UserServiceImpl());
service.addUser("张三");

// 业务接口（JDK代理强制要求）
public interface OrderService {
    void createOrder(String orderId);
    void payOrder(String orderId);
}

// 目标类：实现接口，专注核心业务
public class OrderServiceImpl implements OrderService {
    @Override
    public void createOrder(String orderId) {
        System.out.println("创建订单：" + orderId);
    }
    @Override
    public void payOrder(String orderId) {
        System.out.println("支付订单：" + orderId);
    }
}

// 动态代理的调用处理器
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class LogInvocationHandler implements InvocationHandler {
    private final 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() + "] 开始执行");
        long start = System.nanoTime();
        
        // 通过反射调用目标对象的真实方法
        Object result = method.invoke(target, args);
        
        // 后置增强：性能统计
        System.out.println("〖日志〗方法执行耗时：" + (System.nanoTime() - start) + " ns");
        return result;
    }
}

// 使用动态代理
public class Main {
    public static void main(String[] args) {
        OrderService target = new OrderServiceImpl();
        
        OrderService proxy = (OrderService) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),      // 类加载器
            target.getClass().getInterfaces(),       // 要实现的接口数组
            new LogInvocationHandler(target)         // 调用处理器
        );
        
        // 通过代理对象调用方法 → 自动触发invoke()
        proxy.createOrder("ORD-001");
        proxy.payOrder("ORD-001");
    }
}

// 目标类：无需实现任何接口（但不能是final类）
public class PaymentService {
    public void pay(double amount) {
        System.out.println("执行支付：" + amount + "元");
    }
}

// 方法拦截器
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

public class LogMethodInterceptor implements MethodInterceptor {
    
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) 
            throws Throwable {
        // 前置增强
        System.out.println("〖日志〗方法 [" + method.getName() + "] 开始执行");
        long start = System.nanoTime();
        
        // 调用父类的原始方法（注意：是invokeSuper，不是method.invoke）
        Object result = proxy.invokeSuper(obj, args);
        
        // 后置增强
        System.out.println("〖日志〗执行耗时：" + (System.nanoTime() - start) + " ns");
        return result;
    }
}

// 使用CGLIB代理
public class Main {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(PaymentService.class);      // 设置目标类作为父类
        enhancer.setCallback(new LogMethodInterceptor());  // 设置回调拦截器
        
        PaymentService proxy = (PaymentService) enhancer.create();  // 生成代理对象
        proxy.pay(100.0);
    }
}