Java动态代理性能对比：CGLIB vs JDK

在Java开发中，动态代理技术广泛应用于AOP（面向切面编程）、远程方法调用等领域。常见的动态代理实现方式主要有两种：基于JDK的动态代理和基于CGLIB的动态代理。本文将深入探讨这两种动态代理机制的原理及其性能差异，帮助开发者选择最适合项目的代理方式。

一、JDK动态代理

JDK动态代理是基于Java反射机制实现的。它要求被代理的类必须实现至少一个接口。以下是JDK动态代理的基本使用示例：

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

interface MyService {
    void performAction();
}

class MyServiceImpl implements MyService {
    public void performAction() {
        System.out.println("Action performed by MyServiceImpl");
    }
}

class MyInvocationHandler implements InvocationHandler {
    private Object target;

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

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method execution");
        Object result = method.invoke(target, args);
        System.out.println("After method execution");
        return result;
    }
}

public class JDKProxyExample {
    public static void main(String[] args) {
        MyService realService = new MyServiceImpl();
        MyService proxyService = (MyService) Proxy.newProxyInstance(
            MyService.class.getClassLoader(),
            new Class<?>[] {MyService.class},
            new MyInvocationHandler(realService)
        );
        proxyService.performAction();
    }
}

二、CGLIB动态代理

CGLIB（Code Generation Library）是一个强大的高性能代码生成库，它可以在运行时动态生成子类以实现代理。与JDK动态代理不同，CGLIB不要求被代理的类实现任何接口。

以下是CGLIB动态代理的基本使用示例：

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

class MyService {
    public void performAction() {
        System.out.println("Action performed by MyService");
    }
}

class MyMethodInterceptor implements MethodInterceptor {
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before method execution");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("After method execution");
        return result;
    }
}

public class CGLIBProxyExample {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(MyService.class);
        enhancer.setCallback(new MyMethodInterceptor());
        MyService proxyService = (MyService) enhancer.create();
        proxyService.performAction();
    }
}

三、性能对比

1. 创建代理对象的性能

JDK动态代理在创建代理对象时，主要依赖于Java的反射机制，其性能相对较低。而CGLIB通过生成子类的方式创建代理对象，性能较高。

2. 方法调用性能

在方法调用方面，JDK动态代理由于使用反射，每次方法调用都会有一定的性能开销。CGLIB则通过生成的子类直接调用父类方法，性能开销较小。

3. 内存消耗

JDK动态代理生成的代理类数量较少，内存消耗相对较低。CGLIB生成的子类较多，内存消耗较大。

4. 适用场景

• JDK动态代理：适用于被代理类有接口的情况，性能稍逊但足够应对大多数场景。
• CGLIB动态代理：适用于被代理类无接口或需要高性能代理的场景。

四、实际测试

为了更直观地对比性能，我们进行了一组简单的基准测试：

public class ProxyPerformanceTest {
    public static void main(String[] args) {
        MyService jdkProxyService = createJDKProxy();
        MyService cglibProxyService = createCGLIBProxy();

        long startTime = System.nanoTime();
        for (int i = 0; i < 1000000; i++) {
            jdkProxyService.performAction();
        }
        long endTime = System.nanoTime();
        System.out.println("JDK Proxy Time: " + (endTime - startTime) + " ns");

        startTime = System.nanoTime();
        for (int i = 0; i < 1000000; i++) {
            cglibProxyService.performAction();
        }
        endTime = System.nanoTime();
        System.out.println("CGLIB Proxy Time: " + (endTime - startTime) + " ns");
    }

    private static MyService createJDKProxy() {
        // JDK Proxy creation logic
    }

    private static MyService createCGLIBProxy() {
        // CGLIB Proxy creation logic