Java 动态代理原理与实现

示例代码

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

// 1. 定义接口
public interface UserService {
    void addUser(String name);
}

// 2. 实现目标类
public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String name) {
        System.out.println("添加用户：" + name);
    }
}

// 3. 实现 InvocationHandler（增强逻辑）
public class LogInvocationHandler implements InvocationHandler {
    private Object target; // 目标类引用

    public LogInvocationHandler(Object target) {
        this.target = target;
    }

    // 代理类的所有方法调用都会触发 invoke
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 增强逻辑：前置日志
        System.out.println("方法" + method.getName() + "开始执行，参数：" + Arrays.toString(args));
        // 调用目标方法
        Object result = method.invoke(target, args);
        // 增强逻辑：后置日志
        System.out.println("方法" + method.getName() + "执行结束");
        return result;
    }
}

// 4. 生成代理类并测试
public class JdkProxyTest {
    public static void main(String[] args) {
        // 目标对象
        UserService target = new UserServiceImpl();
        // 生成代理对象（需传入类加载器、目标接口、InvocationHandler）
        UserService proxy = (UserService) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new LogInvocationHandler(target)
        );
        // 调用代理方法
        proxy.addUser("张三");
    }
}

优缺点

• 优点：基于 JDK 原生 API，无需依赖第三方库，轻量化；
• 缺点：目标类必须实现接口，无法代理无接口的类。

2. CGLIB 动态代理（基于子类）

原理

CGLIB（Code Generation Library）是一个第三方字节码生成库，通过生成目标类的子类作为代理类，无需目标类实现接口。其核心是 MethodInterceptor 接口，代理类的方法调用会被拦截到 intercept 方法中，在此处嵌入增强逻辑并调用目标方法。

示例代码（需引入 CGLIB 依赖）

<!-- Maven 依赖 -->
<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;
import java.util.Arrays;

// 1. 目标类（无需实现接口）
public class OrderService {
    public void createOrder(String orderId) {
        System.out.println("创建订单：" + orderId);
    }
}

// 2. 实现 MethodInterceptor（增强逻辑）
public class LogMethodInterceptor implements MethodInterceptor {
    // 拦截代理类方法调用
    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        // 增强逻辑：前置日志
        System.out.println("方法" + method.getName() + "开始执行，参数：" + Arrays.toString(args));
        // 调用目标方法（推荐用 methodProxy.invokeSuper，避免递归调用）
        Object result = methodProxy.invokeSuper(o, args);
        // 增强逻辑：后置日志
        System.out.println("方法" + method.getName() + "执行结束");
        return result;
    }
}

// 3. 生成代理类并测试
public class CglibProxyTest {
    public static void main(String[] args) {
        // CGLIB 核心类：Enhancer
        Enhancer enhancer = new Enhancer();
        // 设置父类（目标类）
        enhancer.setSuperclass(OrderService.class);
        // 设置方法拦截器
        enhancer.setCallback(new LogMethodInterceptor());
        // 生成代理对象（子类实例）
        OrderService proxy = (OrderService) enhancer.create();
        // 调用代理方法
        proxy.createOrder("ORDER_001");
    }
}

优缺点

• 优点：无需目标类实现接口，可代理任意类（除 final 类和 final 方法）；
• 缺点：依赖第三方库，生成代理类时需操作字节码，性能略低于 JDK 动态代理（JDK 8 后差距已缩小）。

三、JDK 与 CGLIB 动态代理对比

四、实际应用场景

1. Spring AOP：默认优先使用 JDK 动态代理（目标类有接口时），无接口时使用 CGLIB；
2. 日志记录：统一记录方法的入参、出参、执行时间；
3. 权限控制：方法调用前校验用户权限，无权限则抛出异常；
4. 事务管理：方法执行前开启事务，执行后提交/回滚事务。

五、总结

动态代理是 Java 中'解耦横切逻辑'的核心技术，JDK 动态代理和 CGLIB 各有适用场景：若目标类已实现接口，优先选择 JDK 动态代理（轻量化、无依赖）；若目标类无接口或需代理类的所有方法，选择 CGLIB。