CGLib与JDK的动态代理

浅浅的花香味﹌ 2022-08-05 04:29 206阅读 0赞

# 一、CGLib 简介 #

CGLib (Code Generation Library) 是一个强大的,高性能,高质量的Code生成类库。它可以在运行期扩展Java类与实现Java接口。Hibernate用它来实现PO字节码的动态生成。CGLib比 Java 的 java.lang.reflect.Proxy 类更强的在于它不仅可以接管接口类的方法，还可以接管普通类的方法。

CGLib 的底层是Java字节码操作框架 —— ASM。CGLib就是封装了ASM，简化了ASM的操作，实现了在运行期动态生成新的class。ASM是直接生成class类的方式，不会有性能问题（相对来说）

# 二、JDK的动态代理 (VS) CGLib #

## 1、实现原理 ##

JDK的动态代理——根据java的反射机制动态生成

利用反射，获取委托类的类加载器，委托类的所有接口，实例化代理类。通过反射类Proxy以及InvationHandler回调接口实现的。但是动态代理类只能对该类所实现的接口中的方法进行代理。具有一定的局限性，并且反射的效率也不是很高。

Proxy 毕竟是通过反射实现的，必须在效率上付出代价：有实验数据表明，调用反射比一般的函数开销至少要大 10 倍。从程序实现上可以看出，对 proxyclass 的所有方法调用都要通过使用反射的 invoke 方法。因此，对于性能关键的应用，使用 proxy class是需要精心考虑的，以避免反射成为整个应用的瓶颈。

CGLib ——利用ASM生成字节码原理，利用增强类，创建代理类

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

ASM能够通过改造既有类，直接生成需要的代码。增强的代码是硬编码在新生成的类文件内部的，没有反射带来性能上的付出。它是一个普通的 Java 类而不是 proxy类，甚至可以在应用程序的类框架中拥有自己的位置，派生自己的子类。

在调用目标方法的时候，CGLib会回调MethodInterceptor接口方法拦截，来实现你自己的代理逻辑，类似于JDK中的InvocationHandler接口

## 2、代码实现 ##

**JDK动态代理**

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **package** DynamicProxy2upgrade;  
2.    
3.  **import** java.lang.reflect.InvocationHandler;  
4.  **import** java.lang.reflect.Method;  
5.  **import** java.lang.reflect.Proxy;  
6.    
7.  /\*\*  
8.   \* @ClassName: DynamicProxy  
9.   \* @Description: 动态代理类，在这里做了一个升级，把代理绑定真实类的关系，Proxy生成实例的代码移到了动态代理这里  
10.  \* @author 张薄- huaxiangniaoyu0109@126.com 
11.  \* @date 2015年5月29日 下午9:21:19  
12.  \*/  
13. **public** **class** DynamicProxy **implements** InvocationHandler \{  
14.   
15.     **private** Object obj ;  //委托类，真实类  
16.       
17.     DynamicProxy(Object obj)\{  
18.         **this**.obj=obj;  
19.     \}  
20.       
21.     //绑定代理与委托类，生成新的代理类  
22.     **public** Object bindProxy(Object obj)\{  
23.           
24.         //返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序，如ProxyHandler  
25.         **return** Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), **this**);  
26.     \}  
27.       
28.       
29.     @Override  
30.     **public** Object invoke(Object proxy, Method method, Object\[\] args)  
31.             **throws** Throwable \{        
32.         **return** method.invoke(obj, args); //普通的java反射代码，通过反射执行某个类的方法（invoke方法内部实现预处理，对委托类方法调用，事后处理等逻辑。）  
33.     \}  
34.   
35. \}

JDK动态代理运行结果：‘

![Center][]

**CGLib动态代理**

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **package** CGLibDynamicProxy;  
2.    
3.  **import** java.lang.reflect.Method;  
4.    
5.  **import** net.sf.cglib.proxy.Enhancer; //一个字节码增强类，它可以方便的对你想要处理的类进行扩展  
6.  **import** net.sf.cglib.proxy.MethodInterceptor; //方法拦截器  
7.  **import** net.sf.cglib.proxy.MethodProxy; //代理类，JDK的java.long.reflect.Method类的代理类，可以方便的实现对源对象方法的调用（如invokeSuper）  
8.  /\*\*  
9.   \* @ClassName: DynamicProxybyCGLib  
10.  \* @Description: 基于CGLib的动态代理 
11.  \* @author 张薄- huaxiangniaoyu0109@126.com 
12.  \* @date 2015年5月31日 上午8:44:19  
13.  \*/  
14. **public** **class** DynamicProxybyCGLib **implements** MethodInterceptor \{  
15.       
16.     **private** Object obj;  //委托类  
17.     **public** Object getInstance(Object obj)\{  
18.         **this**.obj = obj;  
19.         Enhancer enhancer = **new** Enhancer();  //增强类  
20.         //不同于JDK的动态代理，它不能在创建代理时传obj对 象，obj对象必须被CGLIB包来创建  
21.         enhancer.setSuperclass(**this**.obj.getClass()); //设置被代理类字节码（obj将被代理类设置成父类；作为产生的代理的父类传进来的），CGLIB根据字节码生成被代理类的子类        
22.         enhancer.setCallback(**this**); //设置回调函数，即一个方法拦截  
23.         **return** enhancer.create(); //创建代理类  
24.     \}  
25.   
26.     @Override  
27.     **public** Object intercept(Object obj, Method method, Object\[\] args,  
28.             MethodProxy methodProxy) **throws** Throwable \{  
29.         System.out.println("obj:" + obj.getClass().getName());  //由CGLib动态生成的代理类实例  
30.         System.out.println("method:" + method.getName());   //上文中实体类所调用的被代理的方法引用  
31.         System.out.println("methodProxy:" + methodProxy.getClass().getName()); //生成的代理类对方法的代理引用  
32.         System.out.println("args:"\+ args); //参数值列表  
33.           
34.         Object object = methodProxy.invokeSuper(obj, args);  //调用代理类实例上的methodProxy方法的父类方法（即实体类RealSubject中的对应方法）  
35.           
36.         **return** object;  
37.     \}  
38.   
39. \}

CGLib动态代理运行结果：

![Center 1][]

# 三、小结 #

CGLib实现的原理，很具体的原理可能我还是不太懂，但是，大概知道一个过程，首先根据Enhancer创建代理类，如何创建的呢？根据方法setSuperclass将被代理类作为父类引入，再根据CGLib生成被代理类的子类，根据方法setCallback，回调函数（这里我们的动态代理类实现MethodInterceptor拦截器，根据拦截器的方法intercept，调用代理类的父类方法，实现了代理被代理类的方法的目的），实现方法拦截。最后用create方法创建代理类。

既然口述了CGLib的实现原理，那就再来说说JDK的动态代理吧。根据Proxy的方法newProxyInstance方法创建代理类，该方法里面的参数，分别获取了被代理类的类加载器（用于动态加载），被代理类的所有接口类（以便于实现接口类的所有方法），再通过动态代理类实现InvationHandler，实现接口方法invoke，回调函数（通过反射执行被代理类的方法），这样在实例化动态代理类的时候，就真正的创建了动态代理。

啰里啰嗦的说了这么多，收获还是有的，说出我的心得，如果大家有不同的想法，欢迎拍砖哈。比如，CGLib的动态代理类，原理是继承，生成了被代理类的子类；而JDK的动态代理类，原理是反射，生成的代理类，实际不具备被代理类内部的方法，每一次调用都需要利用反射，调用被代理类的方法；再来看静态代理，代理类就是通过调用被代理类的方法进行执行的，而它自己本身并不具体被代理类的方法，JDK的动态代理的进步在于，利用反射，将类的加载延迟到程序运行中，解耦了代理类与被代理的关系。

[view plain]: http://blog.csdn.net/caozhangyingfei0109/article/details/46385907#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/686037
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/686037/fork
[Center]: /images/20220805/1d026f2cd411444aa8385048a200a198.png
[Center 1]: /images/20220805/caccc844befa49b187742e70f8dc2b12.png