Java动态代理终极指南：JDK vs CGLIB，AOP底层原理一网打尽（2026年4月10日更新）

// 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);
    }
    @Override
    public String getUser(int id) {
        System.out.println("查询用户：" + id);
        return "用户" + id;
    }
}

// 3. 静态代理类：手动编写，一一绑定
public class UserServiceStaticProxy implements UserService {
    private UserService target;
    
    public UserServiceStaticProxy(UserService target) {
        this.target = target;
    }
    
    @Override
    public void saveUser(String name) {
        System.out.println("【日志】开始执行saveUser");
        long start = System.currentTimeMillis();
        target.saveUser(name);
        System.out.println("【日志】执行结束，耗时：" + (System.currentTimeMillis() - start) + "ms");
    }
    
    @Override
    public String getUser(int id) {
        System.out.println("【日志】开始执行getUser");
        long start = System.currentTimeMillis();
        String result = target.getUser(id);
        System.out.println("【日志】执行结束，耗时：" + (System.currentTimeMillis() - start) + "ms");
        return result;
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

// 步骤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);
    }
    @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 + "，参数：" + Arrays.toString(args));
        
        long start = System.currentTimeMillis();
        // 核心：通过反射调用真实对象的方法
        Object result = method.invoke(target, args);
        long cost = System.currentTimeMillis() - start;
        
        // 后置增强：方法执行后
        System.out.println("【代理拦截】方法 " + methodName + " 执行完成，耗时：" + cost + "ms");
        return result;
    }
}

// 步骤4：客户端使用
public class Client {
    public static void main(String[] args) {
        // 真实对象
        UserService realService = new UserServiceImpl();
        // 创建代理对象
        UserService proxy = (UserService) Proxy.newProxyInstance(
            realService.getClass().getClassLoader(),   // 类加载器
            realService.getClass().getInterfaces(),    // 代理的接口列表
            new LoggingInvocationHandler(realService)  // 调用处理器
        );
        // 调用代理方法——实际会进入InvocationHandler的invoke方法
        proxy.saveUser("张三");
        String user = proxy.getUser(1001);
        System.out.println("最终结果：" + user);
    }
}

【代理拦截】即将执行：saveUser，参数：[张三]
【核心业务】保存用户：张三
【代理拦截】方法 saveUser 执行完成，耗时：0ms
【代理拦截】即将执行：getUser，参数：[1001]
【核心业务】查询用户：1001
【代理拦截】方法 getUser 执行完成，耗时：0ms
最终结果：用户1001

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

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 OrderService {
    public void createOrder(String product) {
        System.out.println("【核心业务】创建订单：" + product);
    }
    public void payOrder(int orderId) {
        System.out.println("【核心业务】支付订单：" + orderId);
    }
}

// 步骤：实现MethodInterceptor——拦截所有方法调用
public class LoggingMethodInterceptor implements MethodInterceptor {
    private final Object target;
    
    public LoggingMethodInterceptor(Object target) {
        this.target = target;
    }
    
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        // 前置增强
        System.out.println("【CGLIB拦截】执行前：" + method.getName());
        long start = System.currentTimeMillis();
        
        // 调用原始方法（注意：用invokeSuper而非invoke）
        Object result = proxy.invokeSuper(obj, args);
        
        // 后置增强
        long cost = System.currentTimeMillis() - start;
        System.out.println("【CGLIB拦截】执行结束，耗时：" + cost + "ms");
        return result;
    }
}

// 客户端使用
public class CglibClient {
    public static void main(String[] args) {
        // 真实对象
        OrderService realService = new OrderService();
        
        // 创建Enhancer——CGLIB的核心入口类
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(OrderService.class);   // 设置父类（即目标类）
        enhancer.setCallback(new LoggingMethodInterceptor(realService));
        
        // 生成代理对象（目标类的子类实例）
        OrderService proxy = (OrderService) enhancer.create();
        
        // 调用代理方法
        proxy.createOrder("iPhone 15");
        proxy.payOrder(12345);
    }
}

【CGLIB拦截】执行前：createOrder
【核心业务】创建订单：iPhone 15
【CGLIB拦截】执行结束，耗时：1ms
【CGLIB拦截】执行前：payOrder
【核心业务】支付订单：12345
【CGLIB拦截】执行结束，耗时：0ms