设计模式（11）动态代理 JDK VS CGLIB面试必问

在上一篇文章我们介绍了代理模式，静态的，本期我们介绍动态代理，动态代理的应用也非常广泛，也是在很多面试场合中必问的一个点，希望读完本文，你将有所收获。
原创声明：未经授权，不得转载，侵权必究，转载前请与作者取得联系。

何谓动态代理

普通代理模式，代理类Proxy的Java代码在JVM运行时就已经确定了，也就是在编码编译阶段就确定了Proxy类的代码。而动态代理是指在JVM运行过程中，动态的创建一个类的代理类，并实例化代理对象。因为实际的代理类是在运行时创建的，所以我们称这个Java技术为：动态代理。

动态代理的应用场景

动态代理的应用场景有很多，例如久负盛名的RPC框架，在客户端都会利用动态代理生成一个服务端接口的代理类来代理接口的调用执行。同时Spring中的AOP就是一个动态代理的典型应用，有了动态代理，妈妈再也不用担心我的切面编程了。

实现动态代理的两种方式

Java中有两种生成动态代理的方式：

• 基于JDK实现的动态代理。
• 基于CGLIB类库实现的动态代理。

两者的区别将在后文介绍。

JDK动态代理

在java的类库中，java.util.reflect.Proxy类就是其用来实现动态代理的顶层类。可以通过Proxy类的静态方法Proxy.newProxyInstance()方法动态的创建一个类的代理类，并实例化。由它创建的代理类都是Proxy类的子类。

在看JDK动态代理的示例代码之前，让我们先来看看其UML类图，从全局上进行一个理解。

JDK动态代理UML类图

因为Proxy类是JDK为你创建的，所以你需要有办法告诉Proxy类你要做什么，让Proxy类代理你。但你不能像普通代理模式那样，将被代理类通过组合的方式放到Proxy类中，那么要放到哪呢？放到InvocationHandler的实现类中，让InvocationHandler的实现类来响应代理的方法调用。

JDK动态代理实现步骤
（1）创建被代理对象的接口类。
（2）创建具体被代理对象接口的实现类。
（3）创建一个InvocationHandler的实现类，并持有被代理对象的引用。然后在invoke方法中利用反射调用被代理对象的方法。
（4）利用Proxy.newProxyInstance方法创建代理对象，利用代理对象实现真实对象方法的调用。

JDK动态代理实现示例代码

创建被代理对象的接口类Subject

public interface Subject {
    void request();
}

创建Subject接口的实现类：简单打印一句输出

public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("request invoke");
    }
}

创建一个InvocationHandler的实现类

public class ConcreteInvocationHandler implements InvocationHandler {

    private Subject subject;

    public ConcreteInvocationHandler(Subject subject) {
        this.subject = subject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        return method.invoke(subject, args);
    }
}

客户端测试类

public class JDKDynamicProxyTest {
    public static void main(String[] args) {
        Subject subject = new RealSubject();
        InvocationHandler handler = new ConcreteInvocationHandler(subject);
        Subject proxy = (Subject)Proxy.newProxyInstance(RealSubject.class.getClassLoader(),
                RealSubject.class.getInterfaces(), handler);
        proxy.request();
    }
}

Proxy.newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)方法有三个入参：

• ClassLoader：用来创建并加载Proxy类的ClassLoader。
• interfaces：被代理对象的接口列表，这是JDK强制要求的，被代理的对象必须实现某一个接口。其目的是在生成Proxy类时也实现这些接口，做到能够替代被代理类。
• invoactionhandler对象：用来提供Proxy转发处理的帮助实现类，所有代理方法的调用都交由它调用，再由它内部实现对真正对象方法的调用。

输出结果：

proxy class name : com.sun.proxy.$Proxy0
request invoke

从输出结果可以看到，生成代理类的类名为$Proxy0

这是JDK在运行时生成的字节码类。JDK生成Proxy类的字节码是通过ProxyGenerator.generateProxyClass生成的，笔者写了个小工具生成字节码，并输出到文件，代码如下：

byte[] proxyBytes = ProxyGenerator.generateProxyClass("$Proxy0",
        RealSubject.class.getInterfaces());
InputStream inputStream = new ByteArrayInputStream(proxyBytes);
FileOutputStream outputStream = new FileOutputStream("C:/$Proxy0.class");
byte[] buff = new byte[1024];
int len = 0;
while((len=inputStream.read(buff))!=-1){
    outputStream.write(buff, 0, len);
}
inputStream.close();
outputStream.close();

生成的字节码文件，用反编译工具看下$Proxy0的实现：

public final class $Proxy0 extends Proxy implements Subject {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler paramInvocationHandler) {
        super(paramInvocationHandler);
    }

    public final boolean equals(Object paramObject) {
        try {
            return ((Boolean) this.h.invoke(this, m1, 
                    new Object[]{paramObject})).booleanValue();
        } catch (Error | RuntimeException localError) {
            throw localError;
        } catch (Throwable localThrowable) {
            throw new UndeclaredThrowableException(localThrowable);
        }
    }

    public final String toString() {
        try {
            return (String) this.h.invoke(this, m2, null);
        } catch (Error | RuntimeException localError) {
            throw localError;
        } catch (Throwable localThrowable) {
            throw new UndeclaredThrowableException(localThrowable);
        }
    }

    public final void request() {
        try {
            this.h.invoke(this, m3, null);
            return;
        } catch (Error | RuntimeException localError) {
            throw localError;
        } catch (Throwable localThrowable) {
            throw new UndeclaredThrowableException(localThrowable);
        }
    }

    public final int hashCode() {
        try {
            return ((Integer) this.h.invoke(this, m0, null)).intValue();
        } catch (Error | RuntimeException localError) {
            throw localError;
        } catch (Throwable localThrowable) {
            throw new UndeclaredThrowableException(localThrowable);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m3 = Class.forName("com.misout.designpattern.subject.Subject").getMethod("request", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        } catch (NoSuchMethodException localNoSuchMethodException) {
            throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
        } catch (ClassNotFoundException localClassNotFoundException) {
            throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
        }
    }
}

从生成的类可以看出，$Proxy0实现了Subject接口，这个接口正是我们传递进去的被代理对象的接口列表。同时还继承了Proxy类，这验证了前文所说生成的代理类是Proxy子类的说明。
从类的结构可以看出，JDK动态生成代理类，一定要被代理类实现了某个接口，否则就无法生成代理类，这也就是JDK动态代理的缺陷之一。
另外，被代理类可以实现多个接口。从代理类代码中可以看到，代理类是通过InvocationHandler的invoke方法去实现被代理接口方法调用的。所以被代理对象实现了多个接口并且希望对不同接口实施不同的代理行为时，应该在ConcreteInvocationHandler类的invoke方法中，通过判断方法名来实现不同的接口的代理行为。

CGLIB实现动态代理

CGLIB是一个高性能的代码生成类库，被Spring广泛应用。其底层是通过ASM字节码框架生成类的字节码，达到动态创建类的目的。

CGLIB实现的动态代理UML类图：

我们知道，实现代理有两种方式：

• 要么通过继承父类，并改写父类的方法，在父类方法逻辑前后增加控制逻辑实现代理。
• 要么实现同一接口，并利用组合的方式，持有被代理的引用，然后在代理方法前后增加控制逻辑实现代理。

那么从CGLIB实现的动态代理UML类图来看，显然是通过继承父类的方式进行实现的。这样在父类可以代替子类，代理子类可以直接调用父类的方法进行访问。巧妙的是，如果想对真实类增强业务逻辑，进行切面编程，则可以创建一个方法拦截器，在其中编写自己增强的业务逻辑代码或访问控制代码，然后交给代理类进行调用访问，达到AOP的效果。

下面，我们看看通过CGLIB实现动态代理的步骤：
（1）创建被代理的目标类。
（2）创建一个方法拦截器类，并实现CGLIB的MethodInterceptor接口的intercept()方法。
（3）通过Enhancer类增强工具，创建目标类的代理类。
（4）利用代理类进行方法调用，就像调用真实的目标类方法一样。

CGLIB动态代理实现示例代码

创建目标类：Target：方法简单输出一句话

public class Target {
    public void request() {
        System.out.println("执行目标类的方法");
    }
}

创建目标类的方法增强拦截器：TargetMethodInterceptor：在拦截器内部，调用目标方法前进行前置和后置增强处理。

public class TargetMethodInterceptor 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;
    }
}

生成代理类，并测试

public class CglibDynamicProxyTest {

    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();

        // 设置生成代理类的父类class对象
        enhancer.setSuperclass(Target.class);

        // 设置增强目标类的方法拦截器
        MethodInterceptor methodInterceptor = new TargetMethodInterceptor();
        enhancer.setCallback(methodInterceptor);

        // 生成代理类并实例化
        Target proxy = (Target) enhancer.create();

        // 用代理类调用方法
        proxy.request();
    }
}

测试输出：可以看到成功进行了业务增强的处理。

方法拦截增强逻辑-前置处理执行
执行目标类的方法
方法拦截增强逻辑-后置处理执行

JDK动态代理 VS CGLIB 对比

• 字节码创建方式：JDK动态代理通过JVM实现代理类字节码的创建，cglib通过ASM创建字节码。
• JDK动态代理强制要求目标类必须实现了某一接口，否则无法进行代理。而CGLIB则要求目标类和目标方法不能是final的，因为CGLIB通过继承的方式实现代理。
• CGLib不能对声明为final的方法进行代理，因为是通过继承父类的方式实现，如果父类是final的，那么无法继承父类。

性能对比

性能的对比，不是一个简单的答案，要区分JDK版本来区分，这里得出的答案是基于其他作者的测试结果得出的。

JDK1.6/1.7上的对比

• 类的创建速度：JDK快于CGLIB。
• 执行速度：JDK慢于CGLIB，大概慢2倍的关系。

JDK1.8上的对比

• 类的创建速度：JDK快于CGLIB。
• 执行速度：JDK快于CGLIB，经过努力，JDK1.8作了性能上的优化，速度明显比1.7提升了很多。1.8上JDK全面优于CGLIB，是不是说以后都不要用CGLIB，这还得看具体的类情况和场景，如果没有实现接口，就用CGLIB，使用的场景不同。

推荐阅读

设计模式（一）策略模式
设计模式（二）观察者模式
设计模式（三）装饰器模式
设计模式（四）简单工厂模式
设计模式（五）工厂方法模式
设计模式（六）抽象工厂模式
设计模式（七）单例模式你用对了吗
设计模式（八）适配器模式
设计模式（九）模板方法
设计模式（十）代理模式

参考

深入剖析动态代理--性能比较
Spring AOP中的JDK和CGLib动态代理哪个效率更高？