深入解析：Cglib与JDK动态代理的实现原理、区别及性能对比

AI码师

发布于 2024-05-29 14:23:59

5940

发布于 2024-05-29 14:23:59

文章被收录于专栏：分布式｜微服务｜性能优化｜并发编程｜源码分析分布式｜微服务｜性能优化｜并发编程｜源码分析

在Java开发中，动态代理是一种强大的技术，它允许在运行时创建代理对象以添加行为，而无需修改原始类的代码。JDK动态代理和Cglib是两种主要的动态代理实现方式。本文将深入探讨它们的实现原理、区别、劣势以及性能对比。

一、JDK动态代理

「1. 实现原理」

JDK动态代理依赖于Java反射机制，通过java.lang.reflect.Proxy类和InvocationHandler接口实现。它只能代理实现了接口的类。在运行时，JDK动态代理会生成一个代理类，该代理类实现了目标接口，并将方法调用委托给InvocationHandler的invoke方法。

「2. 使用示例」

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

interface Service {
    void perform();
}

class ServiceImpl implements Service {
    public void perform() {
        System.out.println("Service performed.");
    }
}

class ServiceInvocationHandler implements InvocationHandler {
    private Object target;

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

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

public class JDKProxyDemo {
    public static void main(String[] args) {
        Service service = new ServiceImpl();
        Service proxy = (Service) Proxy.newProxyInstance(
                service.getClass().getClassLoader(),
                service.getClass().getInterfaces(),
                new ServiceInvocationHandler(service)
        );
        proxy.perform();
    }
}

「3. 优缺点」

优点：

实现简单，使用Java内置API。
无需依赖第三方库。

缺点：

只能代理接口，不能代理普通类。
方法调用时使用反射，性能相对较低。

二、Cglib动态代理

「1. 实现原理」

Cglib（Code Generation Library）基于底层的字节码操作（使用ASM库），通过生成目标类的子类，并在子类中拦截方法调用来实现代理。因此，它可以代理没有接口的普通类。

「2. 使用示例」

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

class Service {
    public void perform() {
        System.out.println("Service performed.");
    }
}

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

public class CglibProxyDemo {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Service.class);
        enhancer.setCallback(new ServiceInterceptor());
        Service proxy = (Service) enhancer.create();
        proxy.perform();
    }
}

「3. 优缺点」

优点：

可以代理没有接口的类。
方法调用性能较高，避免了反射调用。

缺点：

创建代理类时需要进行字节码操作，性能开销较大。
需要依赖cglib和ASM库。

三、性能对比

为了对比两者的性能，我们进行一个简单的测试，对比创建代理实例和方法调用的时间。

public class ProxyPerformanceTest {
    interface Foo {
        void doSomething();
    }

    static class FooImpl implements Foo {
        public void doSomething() {
            // Simulate some work
        }
    }

    public static void main(String[] args) {
        int iterations = 1000000;

        // JDK Dynamic Proxy
        Foo jdkProxy = (Foo) Proxy.newProxyInstance(
                Foo.class.getClassLoader(),
                new Class[]{Foo.class},
                (proxy, method, args1) -> {
                    return method.invoke(new FooImpl(), args1);
                });

        long jdkStartTime = System.currentTimeMillis();
        for (int i = 0; i < iterations; i++) {
            jdkProxy.doSomething();
        }
        long jdkEndTime = System.currentTimeMillis();
        System.out.println("JDK Dynamic Proxy time: " + (jdkEndTime - jdkStartTime) + " ms");

        // CGLIB Proxy
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(FooImpl.class);
        enhancer.setCallback((MethodInterceptor) (obj, method, args1, proxy) -> {
            return proxy.invokeSuper(obj, args1);
        });
        Foo cglibProxy = (Foo) enhancer.create();

        long cglibStartTime = System.currentTimeMillis();
        for (int i = 0; i < iterations; i++) {
            cglibProxy.doSomething();
        }
        long cglibEndTime = System.currentTimeMillis();
        System.out.println("CGLIB Proxy time: " + (cglibEndTime - cglibStartTime) + " ms");
    }
}

「测试结果」

在实际测试中，JDK动态代理在创建代理实例时的性能优于Cglib，而在方法调用时，Cglib的性能则优于JDK动态代理。这是因为JDK动态代理在方法调用时依赖于反射，而Cglib直接调用生成的子类方法。