暴风AI助手｜2026年Java动态代理原理+面试题全解析

public class UserServiceImpl implements UserService {
    @Override
    public void saveUser(String username) {
        System.out.println("【日志】开始执行saveUser方法，参数：" + username);
        long start = System.currentTimeMillis();
        // 核心业务逻辑
        System.out.println("正在保存用户：" + username);
        long end = System.currentTimeMillis();
        System.out.println("【性能】saveUser执行耗时：" + (end - start) + "ms");
    }
}

// 静态代理类——为每个接口都要写一个
public class UserServiceProxy implements UserService {
    private UserService target;
    
    public UserServiceProxy(UserService target) {
        this.target = target;
    }
    
    @Override
    public void saveUser(String username) {
        System.out.println("【前置增强】开始执行saveUser");
        target.saveUser(username);  // 调用真实对象
        System.out.println("【后置增强】saveUser执行完成");
    }
}

// 1. 定义接口（被代理的类必须实现接口）
public interface UserService {
    void saveUser(String name);
    String getUser(int id);
}

// 2. 真实实现类
public class UserServiceImpl implements UserService {
    @Override
    public void saveUser(String name) {
        System.out.println("【业务】正在保存用户：" + name);
        try { Thread.sleep(100); } catch (InterruptedException e) {}  // 模拟耗时
    }
    
    @Override
    public String getUser(int id) {
        System.out.println("【业务】正在查询用户：" + id);
        return "用户" + id;
    }
}

// 3. 实现InvocationHandler——增强逻辑的核心
public class LoggingInvocationHandler implements InvocationHandler {
    private final Object target;  // 持有关真实对象的引用
    
    public LoggingInvocationHandler(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 前置增强：方法执行前
        String methodName = method.getName();
        System.out.println("【代理拦截】即将执行方法：" + methodName);
        long start = System.currentTimeMillis();
        
        // 核心：通过反射调用真实对象的方法
        Object result = method.invoke(target, args);
        
        // 后置增强：方法执行后
        long cost = System.currentTimeMillis() - start;
        System.out.println("【代理拦截】方法执行完成，耗时：" + cost + "ms");
        return result;
    }
}

// 4. 客户端使用
public class Client {
    public static void main(String[] args) {
        // 创建真实对象
        UserService realService = new UserServiceImpl();
        
        // 创建InvocationHandler
        InvocationHandler handler = new LoggingInvocationHandler(realService);
        
        // 动态生成代理对象
        UserService proxy = (UserService) Proxy.newProxyInstance(
            realService.getClass().getClassLoader(),  // 类加载器
            realService.getClass().getInterfaces(),   // 要代理的接口列表
            handler                                    // 调用处理器
        );
        
        // 调用代理对象的方法——自动触发invoke()
        proxy.saveUser("张三");
        // 输出：【代理拦截】即将执行方法：saveUser
        //      【业务】正在保存用户：张三
        //      【代理拦截】方法执行完成，耗时：101ms
    }
}

// 目标类——不需要实现任何接口
public class UserService {
    public void saveUser(String name) {
        System.out.println("保存用户：" + name);
    }
}

// 使用CGLIB创建代理
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(UserService.class);  // 设置要代理的目标类
enhancer.setCallback((MethodInterceptor) (obj, method, args, proxy) -> {
    System.out.println("CGLIB前置增强...");
    Object result = proxy.invokeSuper(obj, args);  // 调用父类方法
    System.out.println("CGLIB后置增强...");
    return result;
});
UserService proxy = (UserService) enhancer.create();
proxy.saveUser("李四");

                    代理模式（设计思想）
                           │
            ┌──────────────┴──────────────┐
            ↓                              ↓
        静态代理                       动态代理
     （编译期手写）                 （运行时生成）
                                          │
                          ┌───────────────┴───────────────┐
                          ↓                               ↓
                   JDK动态代理                        CGLIB动态代理
                  （基于接口）                        （基于继承）