揭秘动态代理的幕后：JDK和CGLIB之间的博弈

动态代理设计模式：JDK和CGLIB的深度解析

代理模式是软件设计中广泛应用的一种设计模式，它允许我们为对象创建一个替代对象，以控制对其访问。在Java中，有两种流行的动态代理实现：JDK动态代理和CGLIB动态代理。本文将深入探讨这两者的异同，并分析它们在实际开发中的应用场景。

JDK动态代理

JDK动态代理是通过Java反射机制实现的。它使用java.lang.reflect.Proxy类来创建代理对象，该代理对象可以拦截对目标对象的调用并进行处理。

优点：

• 非侵入式： JDK动态代理不需要修改目标类，因此具有较好的灵活性。
• 简单易用： JDK动态代理的API简单易用，只需实现InvocationHandler接口即可。

缺点：

• 性能开销： JDK动态代理会有一定的性能开销，因为它需要在运行时创建代理对象并进行方法调用。
• 只能代理接口： JDK动态代理只能代理实现了接口的目标类，无法代理没有实现接口的类。

CGLIB动态代理

CGLIB（Code Generation Library）是一个开源库，它通过字节码增强技术实现动态代理。CGLIB会生成一个新的子类，该子类继承自目标类并重写其方法，从而实现对目标对象的代理。

优点：

• 高性能： CGLIB动态代理的性能开销较小，因为它直接修改了字节码。
• 可以代理任何类： CGLIB动态代理可以代理任何类，无论它是否实现了接口。

缺点：

• 侵入式： CGLIB动态代理需要修改目标类的字节码，因此可能会带来一些风险。
• 复杂性： CGLIB动态代理的实现原理较为复杂，需要对字节码技术有一定了解。

应用场景比较

特征	JDK动态代理	CGLIB动态代理
性能	较低	较高
侵入性	低	高
代理范围	仅接口	任意类
复杂性	低	高

JDK动态代理适合以下场景：

• 拦截接口方法的调用。
• 对现有类进行动态增强，不需要修改原有代码。

CGLIB动态代理适合以下场景：

• 代理没有实现接口的类。
• 需要高性能的动态代理。
• 需要对目标类进行更复杂的修改。

Spring框架中的选择

Spring框架内部主要使用JDK动态代理，因为它具有侵入性低、使用简单的优点。Spring框架提供了一个FactoryBean接口，允许用户轻松创建JDK动态代理对象。

对于需要代理没有实现接口的类的情况，Spring框架也提供了对CGLIB的支持。用户可以通过@EnableCGLIB注解启用CGLIB动态代理。

总结

JDK动态代理和CGLIB动态代理各有优缺点，在实际开发中应根据具体的场景进行选择。JDK动态代理适用于非侵入式、代理接口的场景；CGLIB动态代理适用于高性能、代理任意类的场景。Spring框架内部主要使用JDK动态代理，但也支持CGLIB动态代理。通过理解这两者的异同，我们可以更有效地利用动态代理技术。

参考示例

JDK动态代理示例：

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

public class JDKDynamicProxyExample {

    public static void main(String[] args) {
        // 目标对象
        Target target = new Target();

        // 创建代理处理程序
        InvocationHandler handler = new MyInvocationHandler(target);

        // 创建代理对象
        Target proxy = (Target) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                handler);

        // 通过代理对象调用目标对象的方法
        proxy.sayHello();
    }

    private static class MyInvocationHandler implements InvocationHandler {

        private final Target target;

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

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("代理对象调用方法前");
            Object result = method.invoke(target, args);
            System.out.println("代理对象调用方法后");
            return result;
        }
    }

    private static class Target {

        public void sayHello() {
            System.out.println("Hello world!");
        }
    }
}

CGLIB动态代理示例：

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

public class CGLIBDynamicProxyExample {

    public static void main(String[] args) {
        // 目标对象
        Target target = new Target();

        // 创建代理增强器
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(new MyMethodInterceptor());

        // 创建代理对象
        Target proxy = (Target) enhancer.create();

        // 通过代理对象调用目标对象的方法
        proxy.sayHello();
    }

    private static class MyMethodInterceptor implements MethodInterceptor {

        @Override
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
            System.out.println("代理对象调用方法前");
            Object result = proxy.invokeSuper(obj, args);
            System.out.println("代理对象调用方法后");
            return result;
        }
    }

    private static class Target {

        public void sayHello() {
            System.out.println("Hello world!");
        }
    }
}