Java中如何实现动态代理？CGLib与JDK Proxy对比

JDK Proxy基于接口，通过反射生成代理类，适用于有接口的目标对象；CGLib通过字节码生成子类，适用于无接口的类。1. JDK Proxy要求目标类实现接口，通过InvocationHandler拦截方法调用，适合接口编程场景。2. CGLib不依赖接口，使用MethodInterceptor拦截方法，通过继承目标类生成代理，适合无接口的类。3. 选择时优先考虑JDK Proxy，若目标类无接口则使用CGLib。两者性能差异在现代JVM中通常可忽略，实际应用中应根据是否具备接口及依赖管理进行决策。

Java中实现动态代理，核心在于运行时创建代理对象，拦截并增强目标对象的方法调用。JDK Proxy基于接口，通过反射机制在运行时生成代理类；而CGLib则不依赖接口，它通过修改字节码、生成目标类的子类来实现代理。选择哪种方式，往往取决于你的目标对象是否有接口，以及对性能、依赖的考量。

解决方案

1. JDK Proxy实现动态代理

JDK Proxy是Java标准库自带的动态代理机制，它要求被代理的类必须实现一个或多个接口。

// 1. 定义业务接口
public interface Subject {
    void request();
    String sayHello(String name);
}

// 2. 实现业务接口的真实对象
public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject: Executing request...");
    }

    @Override
    public String sayHello(String name) {
        return "RealSubject: Hello, " + name + "!";
    }
}

// 3. 定义一个InvocationHandler，用于处理代理实例上的方法调用
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class MyInvocationHandler implements InvocationHandler {
    private Object target; // 真实对象

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

    /**
     * proxy: 代理实例
     * method: 调用的方法
     * args: 方法参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("MyInvocationHandler: Before method " + method.getName());
        // 调用真实对象的方法
        Object result = method.invoke(target, args);
        System.out.println("MyInvocationHandler: After method " + method.getName());
        return result;
    }

    // 获取代理对象
    public Object getProxy() {
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(), // 类加载器
                target.getClass().getInterfaces(),   // 真实对象实现的接口
                this                                 // InvocationHandler实例
        );
    }
}

// 4. 使用示例
public class JdkProxyDemo {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        MyInvocationHandler handler = new MyInvocationHandler(realSubject);
        Subject proxySubject = (Subject) handler.getProxy(); // 获取代理对象

        proxySubject.request();
        System.out.println(proxySubject.sayHello("World"));

        // 验证代理对象类型
        System.out.println("Proxy class: " + proxySubject.getClass().getName());
        System.out.println("Is proxy an instance of Subject? " + (proxySubject instanceof Subject));
    }
}

2. CGLib实现动态代理

CGLib (Code Generation Library) 是一个强大的高性能字节码生成库，它可以在运行时扩展Java类和实现Java接口。它不需要被代理类实现接口，通过生成目标类的子类来实现代理。

// 1. 定义一个普通类，无需实现接口
public class TargetClass {
    public void doSomething() {
        System.out.println("TargetClass: Doing something...");
    }

    public String greet(String name) {
        return "TargetClass: Hello, " + name + "!";
    }
}

// 2. 定义一个MethodInterceptor，用于拦截方法调用
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 MyMethodInterceptor implements MethodInterceptor {
    /**
     * obj: CGLib生成的代理对象
     * method: 调用的方法
     * args: 方法参数
     * methodProxy: 用于调用父类方法（即目标类方法）的代理
     */
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("MyMethodInterceptor: Before method " + method.getName());
        // 调用目标对象的方法，这里通过methodProxy调用，性能更高
        Object result = methodProxy.invokeSuper(obj, args);
        System.out.println("MyMethodInterceptor: After method " + method.getName());
        return result;
    }

    // 获取代理对象
    public Object getProxy(Class targetClass) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(targetClass); // 设置目标类作为父类
        enhancer.setCallback(this);          // 设置回调
        return enhancer.create();            // 创建代理对象
    }
}

// 3. 使用示例
public class CglibProxyDemo {
    public static void main(String[] args) {
        MyMethodInterceptor interceptor = new MyMethodInterceptor();
        TargetClass proxyTarget = (TargetClass) interceptor.getProxy(TargetClass.class);

        proxyTarget.doSomething();
        System.out.println(proxyTarget.greet("CGLib User"));

        // 验证代理对象类型
        System.out.println("Proxy class: " + proxyTarget.getClass().getName());
        System.out.println("Is proxy an instance of TargetClass? " + (proxyTarget instanceof TargetClass));
    }
}

JDK Proxy的工作原理与适用场景是什么？

JDK Proxy的工作原理，说白了就是Java在运行时，动态地为你生成一个实现了目标接口的“假”类。这个“假”类，也就是代理类，它会把所有对接口方法的调用，都转发给一个你提供的InvocationHandler实例去处理。InvocationHandler的invoke方法接收到这些调用后，就能在调用真实方法前后加入你的逻辑，比如日志记录、事务管理、权限校验等等。它底层依赖的是Java的反射机制，通过Proxy.newProxyInstance()方法，JVM会为你创建一个临时的、实现了指定接口的代理类字节码，并加载到内存中。

这种机制最典型的适用场景，就是那些基于接口编程的框架。比如Spring AOP，当你配置一个接口的Service进行事务管理时，Spring默认就会使用JDK Proxy。还有RPC框架，客户端 stub 通常就是通过JDK Proxy生成的，它把远程调用封装成一个本地接口方法。再比如一些单元测试的Mock框架，也能用它来模拟接口行为。简而言之，只要你的设计中大量使用了接口，并且希望在不修改原有代码的前提下，为接口方法添加统一的横切逻辑，JDK Proxy都是一个非常自然且强大的选择。它简洁、内置，用起来也相当顺手。

CGLib动态代理的核心机制与优势在哪里？

CGLib的核心机制与JDK Proxy大相径庭。它不依赖接口，而是通过字节码技术，直接生成目标类的子类。当你请求CGLib为一个类创建代理时，它会利用ASM库（一个字节码操作和分析框架）在运行时生成一个新的类，这个新类继承自你的目标类，并且会覆盖目标类中的所有非final方法。在这些被覆盖的方法中，CGLib会插入调用你提供的MethodInterceptor的逻辑。MethodInterceptor的intercept方法中，你就可以实现自己的增强逻辑，并通过MethodProxy来调用父类（即原始目标类）的方法。

CGLib的优势显而易见：它能代理那些没有实现接口的普通类。这在很多场景下非常有用，比如一些遗留系统，或者你就是不想为每个类都定义一个接口。另一个常常被提及的优势是性能。由于CGLib生成的是目标类的子类，直接调用子类方法，理论上比JDK Proxy通过反射调用invoke方法要快一些。不过，在现代JVM的优化下，这种性能差异在绝大多数应用中几乎可以忽略不计，除非你的应用对代理的调用是极其频繁且性能敏感的核心瓶颈。对我个人而言，CGLib更多的是解决“能否代理”的问题，而非“性能高低”的问题。

JDK Proxy与CGLib在实际应用中该如何选择？

在实际开发中，选择JDK Proxy还是CGLib，我通常会从几个维度去考量，而不是盲目地偏向某一方。

我个人在做选择时，通常会先看有没有接口。如果被代理的类已经实现了接口，并且我只需要代理接口定义的方法，那么JDK Proxy往往是我的首选。它内置于JDK，无需额外依赖，代码也相对简洁直观。这就像是，如果有一条现成的、平坦的公路能到目的地，我肯定不会去开辟一条新的山路。

另一边厢，如果目标类没有实现任何接口，或者我需要代理的是一个具体的类，而不仅仅是它的接口方法（比如，一个类中的某些方法并没有在任何接口中定义），那么CGLib就成了唯一的选择。很多框架，比如Spring AOP，在发现目标对象没有实现接口时，会自动切换到CGLib来创建代理。这种智能切换省去了开发者手动判断的麻烦。

再者说，性能差异在大多数业务场景下并不构成决定性因素。现代JVM的JIT编译器对反射调用的优化已经相当出色，两者之间的性能差距远没有想象中那么大。如果你真的遇到了性能瓶颈，通常需要从更宏观的架构设计或算法层面去优化，而不是纠结于代理方式的微小性能差异。

最后，考虑到外部依赖。JDK Proxy是JDK自带的，而CGLib需要引入第三方库。虽然这通常不是什么大问题，但在某些对依赖管理极其严格的环境中，内置方案可能会更受欢迎。

所以，我的经验是：优先考虑JDK Proxy，因为它更“原生”；当且仅当JDK Proxy无法满足需求（即需要代理没有接口的类）时，才转向使用CGLib。 这种选择策略既能利用JDK的内置能力，又能应对更复杂的代理场景。