JDK动态代理与CGLib动态代理相关问题

╰半夏微凉° 2022-04-18 01:48 252阅读 0赞

> 原文：[https://www.cnblogs.com/jobbible/p/9917208.html][https_www.cnblogs.com_jobbible_p_9917208.html]

>  导读：
> 
> 1、**JDK动态代理原理是什么？为什么不支持类的代理？**
> 
> **2、****JDK动态代理实例**
> 
> **3、****CGLib代理原理是什么？**
> 
> **4、****CGLib代理实例**
> 
> **5、****JDK动态代理与CGLib代理的区别是什么？**
> 
> **6、****总结**
> 
>

注：阅读本文之前可以先阅读：[什么是代理模式？ ][Link 1]

**1. JDK动态代理原理是什么？为什么不支持类的代理？**

jdk动态代理图：

**![640_wx_fmt_png_tp_webp_wxfrom_5_wx_lazy_1_wx_co_1_retryload_1][]**

利用拦截器(拦截器必须实现InvocationHanlder)加上反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。是在程序运行的过程中，根据被代理的接口来动态生成代理类的class文件，并加载运行的过程。

之所以只支持实现了接口的类的代理。从原理上讲是因为JVM动态生成的代理类有如下特性：

继承了Proxy类，实现了代理的接口，最终形式如下（HelloInterface为被代理类实现的接口）：

public final class $Proxy0 extends Proxy implements HelloInterface{  
     .......
    }

从使用上讲，创建代理类时必须传入被代理类实现的接口。  因为java不能多继承，这里已经继承了Proxy类了，不能再继承其他的类，所以JDK的动态代理不支持对实现类的代理，只支持接口的代理。

**1.1 详细介绍：**

在java的动态代理机制中，有两个重要的类或接口，一个是 InvocationHandler(Interface)、另一个则是 Proxy(Class)，这一个类和接口是实现我们动态代理所必须用到的。

**1.1.1 InvocationHandler**

每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。

InvocationHandler这个接口的唯一一个方法 invoke 方法：

Object invoke(Object proxy, Method method, Object[] args) throws Throwable

这个方法一共接受三个参数，那么这三个参数分别代表如下：

*  proxy:　　指代JDK动态生成的最终代理对象
 *  method:　指代的是我们所要调用真实对象的某个方法的Method对象
 *  args:　　 指代的是调用真实对象某个方法时接受的参数

**1.1.2 Proxy**

Proxy这个类的作用就是用来动态创建一个代理对象的类，它提供了许多的方法，但是我们用的最多的就是newProxyInstance 这个方法：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,  InvocationHandler handler)  throws IllegalArgumentException

这个方法的作用就是得到一个动态的代理对象，其接收三个参数，我们来看看这三个参数所代表的含义：

*  loader:　　ClassLoader对象，定义了由哪个ClassLoader来对生成的代理对象进行加载。
 *  interfaces:　　Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了。
 *  Handler：InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上。

所以我们所说的DynamicProxy（动态代理类）是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些 interface。这个DynamicProxy其实就是一个Proxy，它不会做实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。

**2. JDK动态代理实例**

**2.1 创建接口类**

public interface HelloInterface {
    void sayHello();
    }

**2.2 创建被代理类，实现接口 **

/**
     * 被代理类
     */
    public class HelloImpl implements HelloInterface{
        @Override
        public void sayHello() {
            System.out.println("hello");
        }
    }

**2.3****创建InvocationHandler实现类 **

/**
     * 每次生成动态代理类对象时都需要指定一个实现了InvocationHandler接口的调用处理器对象
     */
    public class ProxyHandler implements InvocationHandler{
        private Object subject; // 这个就是我们要代理的真实对象，也就是真正执行业务逻辑的类
        public ProxyHandler(Object subject) {// 通过构造方法传入这个被代理对象
            this.subject = subject;
        }
        /**
         *当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
         */
        @Override
        public Object invoke(Object obj, Method method, Object[] objs)
                throws Throwable {
            Object result = null;
            System.out.println("可以在调用实际方法前做一些事情");
            System.out.println("当前调用的方法是" + method.getName());
            result = method.invoke(subject, objs);// 需要指定被代理对象和传入参数
            System.out.println(method.getName() + "方法的返回值是" + result);
            System.out.println("可以在调用实际方法后做一些事情");
            System.out.println("------------------------");
            return result;// 返回method方法执行后的返回值
        }
    }

**2.4 测试 **

public class Mytest {
    
        public static void main(String[] args) {
            //第一步：创建被代理对象
            HelloImpl hello = new HelloImpl();
            //第二步：创建handler,传入真实对象
            ProxyHandler handler = new ProxyHandler(hello);
            //第三步：创建代理对象，传入类加载器、接口、handler
            HelloInterface helloProxy = (HelloInterface) Proxy.newProxyInstance(
                    HelloInterface.class.getClassLoader(), 
                    new Class[]{HelloInterface.class}, handler);
            //第四步：调用方法
            helloProxy.sayHello();
        }
    }

**2.5 结果**** **

可以在调用实际方法前做一些事情
    当前调用的方法是sayHello
    hello
    sayHello方法的返回值是null
    可以在调用实际方法后做一些事情
    ------------------------

**3. CGLib代理原理是什么？**

![640_wx_fmt_png_tp_webp_wxfrom_5_wx_lazy_1_wx_co_1][]

CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。（利用ASM开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理）

**3.1 CGLib核心类：**

**1、 net.sf.cglib.proxy.Enhancer****：**主要增强类，通过字节码技术动态创建委托类的子类实例；

Enhancer可能是CGLIB中最常用的一个类，和Java1.3动态代理中引入的Proxy类差不多。和Proxy不同的是，Enhancer既能够代理普通的class，也能够代理接口。Enhancer创建一个被代理对象的子类并且拦截所有的方法调用（包括从Object中继承的toString和hashCode方法）。Enhancer不能够拦截final方法，例如Object.getClass()方法，这是由于Java final方法语义决定的。基于同样的道理，Enhancer也不能对fianl类进行代理操作。这也是Hibernate为什么不能持久化final class的原因。

**2、net.sf.cglib.proxy.MethodInterceptor****：**常用的方法拦截器接口，需要实现intercept方法，实现具体拦截处理；

public java.lang.Object intercept(java.lang.Object obj,
                                      java.lang.reflect.Method method,
                                      java.lang.Object[] args,
                                      MethodProxy proxy)
                               throws java.lang.Throwable{}

*  obj：动态生成的代理对象 
 *  method ： 实际调用的方法
 *  args：调用方法入参
 *  proxy：
 *  net.sf.cglib.proxy.MethodProxy：java Method类的代理类，可以实现委托类对象的方法的调用；常用方法：methodProxy.invokeSuper(proxy, args)；在拦截方法内可以调用多次

**4. CGLib代理实例**

**4.1 创建被代理类**

public class SayHello {
        public void say(){
            System.out.println("hello");
        }
    }

**4.2 创建代理类 **

/**
     *代理类 
     */
    public class ProxyCglib implements MethodInterceptor{
         private Enhancer enhancer = new Enhancer();  
         public Object getProxy(Class clazz){  
              //设置需要创建子类的类  
              enhancer.setSuperclass(clazz);  
              enhancer.setCallback(this);  
              //通过字节码技术动态创建子类实例  
              return enhancer.create();  
         }  
    
         //实现MethodInterceptor接口方法  
         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;  
         } 
    }

**4.3 测试 **

public class Mytest {
    
        public static void main(String[] args) {
              ProxyCglib proxy = new ProxyCglib();  
              //通过生成子类的方式创建代理类  
              SayHello proxyImp = (SayHello)proxy.getProxy(SayHello.class);  
              proxyImp.say();  
        }
    }

**4.4 结果 **

可以在调用实际方法前做一些事情
    hello
    可以在调用实际方法后做一些事情

**5. JDK动态代理与CGLib代理的区别是什么？**

**5.1 原理区别：**

java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。核心是实现InvocationHandler接口，使用invoke()方法进行面向切面的处理，调用相应的通知。

而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。核心是实现MethodInterceptor接口，使用intercept()方法进行面向切面的处理，调用相应的通知。

1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP

2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP

3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换

**5.2 性能区别：**

1、CGLib底层采用ASM字节码生成框架，使用字节码技术生成代理类，在jdk6之前比使用Java反射效率要高。唯一需要注意的是，CGLib不能对声明为final的方法进行代理，因为CGLib原理是动态生成被代理类的子类。

2、在jdk6、jdk7、jdk8逐步对JDK动态代理优化之后，在调用次数较少的情况下，JDK代理效率高于CGLIB代理效率，只有当进行大量调用的时候，jdk6和jdk7比CGLIB代理效率低一点，但是到jdk8的时候，jdk代理效率高于CGLIB代理。

**5.3 各自局限：**

1、JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理。

2、cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。

**6. 总结**

** ![640_wx_fmt_jpeg_tp_webp_wxfrom_5_wx_lazy_1_wx_co_1][]**

![640_wx_fmt_png_tp_webp_wxfrom_5_wx_lazy_1_wx_co_1 1][]

[https_www.cnblogs.com_jobbible_p_9917208.html]: https://www.cnblogs.com/jobbible/p/9917208.html
[Link 1]: https://mp.weixin.qq.com/s?__biz=MzIwMDk1NDk1Nw==&mid=2247484155&idx=2&sn=a14eac5fac0f548cd65d61858170a117&scene=21#wechat_redirect
[640_wx_fmt_png_tp_webp_wxfrom_5_wx_lazy_1_wx_co_1_retryload_1]: /images/20220418/2a431e4bb3954b58bff37688ac33ccd3.png
[640_wx_fmt_png_tp_webp_wxfrom_5_wx_lazy_1_wx_co_1]: /images/20220418/eac4a8f348a1445f889a5d18d2454626.png
[640_wx_fmt_jpeg_tp_webp_wxfrom_5_wx_lazy_1_wx_co_1]: /images/20220418/d728e03c4b9b4347b965a4490c73f056.png
[640_wx_fmt_png_tp_webp_wxfrom_5_wx_lazy_1_wx_co_1 1]: /images/20220418/078088dbaf2749f5bf3aac1487aa0e45.png