2026年4月最新｜AI奇妙助手带你彻底吃透Java代理模式（静态代理vs动态代理）

// 订单服务接口
interface OrderService {
    String createOrder(String userId, String productId);
}

// 传统订单服务实现：业务逻辑与增强逻辑全部混在一起
class TraditionalOrderServiceImpl implements OrderService {
    @Override
    public String createOrder(String userId, String productId) {
        // 增强逻辑1：权限校验（写死在业务代码中）
        if (!"admin".equals(userId) && !"VIP".equals(userId)) {
            throw new RuntimeException("权限不足！");
        }
        // 增强逻辑2：调用前日志
        System.out.println("[日志] 开始创建订单，用户：" + userId);
        // 核心业务：创建订单（这才是真正要关心的）
        String orderId = "ORDER_" + System.currentTimeMillis();
        System.out.println("[核心业务] 订单创建成功：" + orderId);
        // 增强逻辑3：调用后日志
        System.out.println("[日志] 订单创建结束");
        return orderId;
    }
}

// 1. 业务接口（代理模式的“契约”）
interface UserService {
    void addUser(String username);
    void deleteUser(String username);
}

// 2. 目标类：专注核心业务，不掺杂任何附加功能
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. 静态代理类：为目标类附加日志功能
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. 客户端调用
public class Client {
    public static void main(String[] args) {
        UserService target = new UserServiceImpl();        // 真实对象
        UserService proxy = new UserServiceProxy(target);  // 代理对象
        proxy.addUser("张三");  // 客户端只和代理交互
    }
}

〖日志〗开始执行addUser，参数：张三
数据库新增用户：张三
〖日志〗addUser执行完毕

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
importjava.lang.reflect.Proxy;

// 1. 定义接口（JDK动态代理强制要求目标类有接口）
interface Service {
    void perform();
}

// 2. 目标实现类
class ServiceImpl implements Service {
    @Override
    public void perform() {
        System.out.println("执行核心业务");
    }
}

// 3. 实现InvocationHandler，在这里编写增强逻辑
class ServiceInvocationHandler implements InvocationHandler {
    private final Object target;  // 持有目标对象
    
    public ServiceInvocationHandler(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 前置增强
        System.out.println("Before method invoke");
        // 反射调用目标方法——这就是“动态”的本质
        Object result = method.invoke(target, args);
        // 后置增强
        System.out.println("After method invoke");
        return result;
    }
}

// 4. 动态生成代理对象
public class DynamicProxyDemo {
    public static void main(String[] args) {
        Service target = new ServiceImpl();
        // 关键一行：Proxy.newProxyInstance动态生成代理类
        Service proxy = (Service) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),  // 类加载器
            target.getClass().getInterfaces(),   // 要实现的接口列表
            new ServiceInvocationHandler(target) // 调用处理器
        );
        proxy.perform();  // 调用代理对象的方法
    }
}

Before method invoke
执行核心业务
After method invoke

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

// 1. 目标类：注意没有实现任何接口！
class NormalService {
    public void perform() {
        System.out.println("执行核心业务");
    }
}

// 2. 实现MethodInterceptor，类似JDK的InvocationHandler
class CglibInterceptor implements MethodInterceptor {
    private final Object target;
    
    public CglibInterceptor(Object target) {
        this.target = target;
    }
    
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before method invoke");
        Object result = method.invoke(target, args);
        System.out.println("After method invoke");
        return result;
    }
}

// 3. 使用Enhancer生成代理对象
public class CglibDemo {
    public static void main(String[] args) {
        NormalService target = new NormalService();
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(NormalService.class);  // 设置父类（目标类）
        enhancer.setCallback(new CglibInterceptor(target));  // 设置回调
        NormalService proxy = (NormalService) enhancer.create();  // 生成子类代理
        proxy.perform();
    }
}