CGLIB介绍与原理(通过继承的动态代理)

Wesley13
• 阅读 900

一、什么是CGLIB?

CGLIB是一个功能强大,高性能的代码生成包。它为没有实现接口的类提供代理,为JDK的动态代理提供了很好的补充。通常可以使用Java的动态代理创建代理,但当要代理的类没有实现接口或者为了更好的性能,CGLIB是一个好的选择。

二、CGLIB原理

CGLIB原理:动态生成一个要代理类的子类,子类重写要代理的类的所有不是final的方法。在子类中采用方法拦截的技术拦截所有父类方法的调用,顺势织入横切逻辑。它比使用java反射的JDK动态代理要快。

CGLIB底层:使用字节码处理框架ASM,来转换字节码并生成新的类。不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。

CGLIB缺点:对于final方法,无法进行代理。

三、CGLIB的应用

广泛的被许多AOP的框架使用,例如Spring AOP和dynaop。Hibernate使用CGLIB来代理单端single-ended(多对一和一对一)关联。

四、CGLIB的API

1、Jar包:

cglib-nodep-2.2.jar:使用nodep包不需要关联asm的jar包,jar包内部包含asm的类.

cglib-2.2.jar:使用此jar包需要关联asm的jar包,否则运行时报错.

2、CGLIB类库:

由于基本代码很少,学起来有一定的困难,主要是缺少文档和示例,这也是CGLIB的一个不足之处。

本系列使用的CGLIB版本是2.2。

net.sf.cglib.core:底层字节码处理类,他们大部分与ASM有关系。

net.sf.cglib.transform:编译期或运行期类和类文件的转换

net.sf.cglib.proxy:实现创建代理和方法拦截器的类

net.sf.cglib.reflect:实现快速反射和C#风格代理的类

net.sf.cglib.util:集合排序等工具类

net.sf.cglib.beans:JavaBean相关的工具类

本篇介绍通过MethodInterceptor和Enhancer实现一个动态代理。

一、首先说一下JDK中的动态代理:

JDK中的动态代理是通过反射类Proxy以及InvocationHandler回调接口实现的,

但是,JDK中所要进行动态代理的类必须要实现一个接口,也就是说只能对该类所实现接口中定义的方法进行代理,这在实际编程中具有一定的局限性,而且使用反射的效率也并不是很高。

二、使用CGLib实现:

使用CGLib实现动态代理,完全不受代理类必须实现接口的限制,而且CGLib底层采用ASM字节码生成框架,使用字节码技术生成代理类,比使用Java反射效率要高。唯一需要注意的是,CGLib不能对声明为final的方法进行代理,因为CGLib原理是动态生成被代理类的子类。

下面,将通过一个实例介绍使用CGLib实现动态代理。

1、被代理类:

首先,定义一个类,该类没有实现任何接口

 1 package com.zghw.cglib;  
 2   
 3 /** 
 4  * 没有实现接口,需要CGlib动态代理的目标类 
 5  *  
 6  * @author zghw 
 7  * 
 8  */  
 9 public class TargetObject {  
10     public String method1(String paramName) {  
11         return paramName;  
12     }  
13   
14     public int method2(int count) {  
15         return count;  
16     }  
17   
18     public int method3(int count) {  
19         return count;  
20     }  
21   
22     @Override  
23     public String toString() {  
24         return "TargetObject []"+ getClass();  
25     }  
26 }</span>

2、拦截器:

定义一个拦截器。在调用目标方法时,CGLib会回调MethodInterceptor接口方法拦截,来实现你自己的代理逻辑,类似于JDK中的InvocationHandler接口。

 1 package com.zghw.cglib;  
 2 
 3 import java.lang.reflect.Method;  
 4 import net.sf.cglib.proxy.MethodInterceptor;  
 5 import net.sf.cglib.proxy.MethodProxy;  
 6 /** 
 7  * 目标对象拦截器,实现MethodInterceptor 
 8  * @author zghw 
 9  * 
10  */  
11 public class TargetInterceptor implements MethodInterceptor{  
12 /** 
13      * 重写方法拦截在方法前和方法后加入业务 
14      * Object obj为目标对象 
15      * Method method为目标方法 
16      * Object[] params 为参数, 
17      * MethodProxy proxy CGlib方法代理对象 
18      */  
19 @Override  
20 public Object intercept(Object obj, Method method, Object[] params,  
21             MethodProxy proxy) throws Throwable {  
22         System.out.println("调用前");  
23         Object result = proxy.invokeSuper(obj, params);  
24         System.out.println(" 调用后"+result);  
25 return result;  
26     }  
27 }

参数:Object为由CGLib动态生成的代理类实例,Method为上文中实体类所调用的被代理的方法引用,Object[]为参数值列表,MethodProxy为生成的代理类对方法的代理引用。

返回:从代理实例的方法调用返回的值。

其中,proxy.invokeSuper(obj,arg):

调用代理类实例上的proxy方法的父类方法(即实体类TargetObject中对应的方法)

在这个示例中,只在调用被代理类方法前后各打印了一句话,当然实际编程中可以是其它复杂逻辑。

3、生成动态代理类:

 1 package com.zghw.cglib;  
 2   
 3 import net.sf.cglib.proxy.Callback;  
 4 import net.sf.cglib.proxy.CallbackFilter;  
 5 import net.sf.cglib.proxy.Enhancer;  
 6 import net.sf.cglib.proxy.NoOp;  
 7   
 8 public class TestCglib {  
 9     public static void main(String args[]) {  
10         Enhancer enhancer =new Enhancer();  
11         enhancer.setSuperclass(TargetObject.class);  
12         enhancer.setCallback(new TargetInterceptor());  
13         TargetObject targetObject2=(TargetObject)enhancer.create();  
14         System.out.println(targetObject2);  
15         System.out.println(targetObject2.method1("mmm1"));  
16         System.out.println(targetObject2.method2(100));  
17         System.out.println(targetObject2.method3(200));  
18     }  
19 }

这里Enhancer类是CGLib中的一个字节码增强器,它可以方便的对你想要处理的类进行扩展,以后会经常看到它。

首先将被代理类TargetObject设置成父类,然后设置拦截器TargetInterceptor,最后执行enhancer.create()动态生成一个代理类,并从Object强制转型成父类型TargetObject。

最后,在代理类上调用方法.

4、回调过滤器CallbackFilter

一、作用

在CGLib回调时可以设置对不同方法执行不同的回调逻辑,或者根本不执行回调。

在JDK动态代理中并没有类似的功能,对InvocationHandler接口方法的调用对代理类内的所以方法都有效。

定义实现过滤器CallbackFilter接口的类:

 1 package com.zghw.cglib;  
 2 
 3 import java.lang.reflect.Method;  
 4 import net.sf.cglib.proxy.CallbackFilter;  
 5 /** 
 6  * 回调方法过滤 
 7  * @author zghw 
 8  * 
 9  */  
10 public class TargetMethodCallbackFilter implements CallbackFilter {  
11 /** 
12      * 过滤方法 
13      * 返回的值为数字,代表了Callback数组中的索引位置,要到用的Callback 
14      */  
15 @Override  
16 public int accept(Method method) {  
17 if(method.getName().equals("method1")){  
18             System.out.println("filter method1 ==0");  
19 return 0;  
20         }  
21 if(method.getName().equals("method2")){  
22             System.out.println("filter method2 ==1");  
23 return 1;  
24         }  
25 if(method.getName().equals("method3")){  
26             System.out.println("filter method3 ==2");  
27 return 2;  
28         }  
29 return 0;  
30     }  
31 }

其中return值为被代理类的各个方法在回调数组Callback[]中的位置索引(见下文)。

 1 package com.zghw.cglib;  
 2   
 3 import net.sf.cglib.proxy.Callback;  
 4 import net.sf.cglib.proxy.CallbackFilter;  
 5 import net.sf.cglib.proxy.Enhancer;  
 6 import net.sf.cglib.proxy.NoOp;  
 7   
 8 public class TestCglib {  
 9     public static void main(String args[]) {  
10         Enhancer enhancer =new Enhancer();  
11         enhancer.setSuperclass(TargetObject.class);  
12         CallbackFilter callbackFilter = new TargetMethodCallbackFilter();  
13           
14         /** 
15          * (1)callback1:方法拦截器 
16            (2)NoOp.INSTANCE:这个NoOp表示no operator,即什么操作也不做,代理类直接调用被代理的方法不进行拦截。 
17            (3)FixedValue:表示锁定方法返回值,无论被代理类的方法返回什么值,回调方法都返回固定值。 
18          */  
19         Callback noopCb=NoOp.INSTANCE;  
20         Callback callback1=new TargetInterceptor();  
21         Callback fixedValue=new TargetResultFixed();  
22         Callback[] cbarray=new Callback[]{callback1,noopCb,fixedValue};  
23         //enhancer.setCallback(new TargetInterceptor());  
24         enhancer.setCallbacks(cbarray);  
25         enhancer.setCallbackFilter(callbackFilter);  
26         TargetObject targetObject2=(TargetObject)enhancer.create();  
27         System.out.println(targetObject2);  
28         System.out.println(targetObject2.method1("mmm1"));  
29         System.out.println(targetObject2.method2(100));  
30         System.out.println(targetObject2.method3(100));  
31         System.out.println(targetObject2.method3(200));  
32     }  
33 }

 1 package com.zghw.cglib;  
 2   
 3 import net.sf.cglib.proxy.FixedValue;  
 4 /**  
 5  * 表示锁定方法返回值,无论被代理类的方法返回什么值,回调方法都返回固定值。  
 6  * @author zghw  
 7  *  
 8  */  
 9 public class TargetResultFixed implements FixedValue{  
10   
11     /**  
12      * 该类实现FixedValue接口,同时锁定回调值为999  
13      * (整型,CallbackFilter中定义的使用FixedValue型回调的方法为getConcreteMethodFixedValue,该方法返回值为整型)。  
14      */  
15     @Override  
16     public Object loadObject() throws Exception {  
17         System.out.println("锁定结果");  
18         Object obj = 999;  
19         return obj;  
20     }  
21   
22 }

5.延迟加载对象

一、作用:
说到延迟加载,应该经常接触到,尤其是使用Hibernate的时候,本篇将通过一个实例分析延迟加载的实现方式。
LazyLoader接口继承了Callback,因此也算是CGLib中的一种Callback类型。

另一种延迟加载接口Dispatcher。

Dispatcher接口同样继承于Callback,也是一种回调类型。

但是Dispatcher和LazyLoader的区别在于:LazyLoader只在第一次访问延迟加载属性时触发代理类回调方法,而Dispatcher在每次访问延迟加载属性时都会触发代理类回调方法。

二、示例:
首先定义一个实体类LoaderBean,该Bean内有一个需要延迟加载的属性PropertyBean。 

 1 package com.zghw.cglib;  
 2   
 3 import net.sf.cglib.proxy.Enhancer;  
 4   
 5 public class LazyBean {  
 6     private String name;  
 7     private int age;  
 8     private PropertyBean propertyBean;  
 9     private PropertyBean propertyBeanDispatcher;  
10   
11     public LazyBean(String name, int age) {  
12         System.out.println("lazy bean init");  
13         this.name = name;  
14         this.age = age;  
15         this.propertyBean = createPropertyBean();  
16         this.propertyBeanDispatcher = createPropertyBeanDispatcher();  
17     }  
18   
19       
20   
21     /** 
22      * 只第一次懒加载 
23      * @return 
24      */  
25     private PropertyBean createPropertyBean() {  
26         /** 
27          * 使用cglib进行懒加载 对需要延迟加载的对象添加代理,在获取该对象属性时先通过代理类回调方法进行对象初始化。 
28          * 在不需要加载该对象时,只要不去获取该对象内属性,该对象就不会被初始化了(在CGLib的实现中只要去访问该对象内属性的getter方法, 
29          * 就会自动触发代理类回调)。 
30          */  
31         Enhancer enhancer = new Enhancer();  
32         enhancer.setSuperclass(PropertyBean.class);  
33         PropertyBean pb = (PropertyBean) enhancer.create(PropertyBean.class,  
34                 new ConcreteClassLazyLoader());  
35         return pb;  
36     }  
37     /** 
38      * 每次都懒加载 
39      * @return 
40      */  
41     private PropertyBean createPropertyBeanDispatcher() {  
42         Enhancer enhancer = new Enhancer();  
43         enhancer.setSuperclass(PropertyBean.class);  
44         PropertyBean pb = (PropertyBean) enhancer.create(PropertyBean.class,  
45                 new ConcreteClassDispatcher());  
46         return pb;  
47     }  
48     public String getName() {  
49         return name;  
50     }  
51   
52     public void setName(String name) {  
53         this.name = name;  
54     }  
55   
56     public int getAge() {  
57         return age;  
58     }  
59   
60     public void setAge(int age) {  
61         this.age = age;  
62     }  
63   
64     public PropertyBean getPropertyBean() {  
65         return propertyBean;  
66     }  
67   
68     public void setPropertyBean(PropertyBean propertyBean) {  
69         this.propertyBean = propertyBean;  
70     }  
71   
72     public PropertyBean getPropertyBeanDispatcher() {  
73         return propertyBeanDispatcher;  
74     }  
75   
76     public void setPropertyBeanDispatcher(PropertyBean propertyBeanDispatcher) {  
77         this.propertyBeanDispatcher = propertyBeanDispatcher;  
78     }  
79   
80     @Override  
81     public String toString() {  
82         return "LazyBean [name=" + name + ", age=" + age + ", propertyBean="  
83                 + propertyBean + "]";  
84     }  
85 }

 1 package com.zghw.cglib;  
 2   
 3 public class PropertyBean {  
 4     private String key;  
 5     private Object value;  
 6     public String getKey() {  
 7         return key;  
 8     }  
 9     public void setKey(String key) {  
10         this.key = key;  
11     }  
12     public Object getValue() {  
13         return value;  
14     }  
15     public void setValue(Object value) {  
16         this.value = value;  
17     }  
18     @Override  
19     public String toString() {  
20         return "PropertyBean [key=" + key + ", value=" + value + "]" +getClass();  
21     }  
22       
23 }

 1 package com.zghw.cglib;  
 2   
 3 import net.sf.cglib.proxy.LazyLoader;  
 4   
 5 public class ConcreteClassLazyLoader implements LazyLoader {  
 6     /** 
 7      * 对需要延迟加载的对象添加代理,在获取该对象属性时先通过代理类回调方法进行对象初始化。 
 8      * 在不需要加载该对象时,只要不去获取该对象内属性,该对象就不会被初始化了(在CGLib的实现中只要去访问该对象内属性的getter方法, 
 9      * 就会自动触发代理类回调)。 
10      */  
11     @Override  
12     public Object loadObject() throws Exception {  
13         System.out.println("before lazyLoader...");  
14         PropertyBean propertyBean = new PropertyBean();  
15         propertyBean.setKey("zghw");  
16         propertyBean.setValue(new TargetObject());  
17         System.out.println("after lazyLoader...");  
18         return propertyBean;  
19     }  
20   
21 }

 1 package com.zghw.cglib;  
 2   
 3 import net.sf.cglib.proxy.Dispatcher;  
 4   
 5 public class ConcreteClassDispatcher implements Dispatcher{  
 6   
 7     @Override  
 8     public Object loadObject() throws Exception {  
 9         System.out.println("before Dispatcher...");  
10         PropertyBean propertyBean = new PropertyBean();  
11         propertyBean.setKey("xxx");  
12         propertyBean.setValue(new TargetObject());  
13         System.out.println("after Dispatcher...");  
14         return propertyBean;  
15     }  
16   
17 }

6.接口生成器InterfaceMaker

一、作用:

InterfaceMaker会动态生成一个接口,该接口包含指定类定义的所有方法。

二、示例:

 1 package com.zghw.cglib;  
 2   
 3 import java.lang.reflect.InvocationTargetException;  
 4 import java.lang.reflect.Method;  
 5   
 6 import net.sf.cglib.proxy.Enhancer;  
 7 import net.sf.cglib.proxy.InterfaceMaker;  
 8 import net.sf.cglib.proxy.MethodInterceptor;  
 9 import net.sf.cglib.proxy.MethodProxy;  
10   
11 public class TestInterfaceMaker {  
12   
13     public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {  
14         InterfaceMaker interfaceMaker =new InterfaceMaker();  
15         //抽取某个类的方法生成接口方法  
16         interfaceMaker.add(TargetObject.class);  
17         Class<?> targetInterface=interfaceMaker.create();  
18         for(Method method : targetInterface.getMethods()){  
19             System.out.println(method.getName());  
20         }  
21         //接口代理并设置代理接口方法拦截  
22         Object object = Enhancer.create(Object.class, new Class[]{targetInterface}, new MethodInterceptor(){  
23             @Override  
24             public Object intercept(Object obj, Method method, Object[] args,  
25                     MethodProxy methodProxy) throws Throwable {  
26                 if(method.getName().equals("method1")){  
27                     System.out.println("filter method1 ");  
28                     return "mmmmmmmmm";  
29                 }  
30                 if(method.getName().equals("method2")){  
31                     System.out.println("filter method2 ");  
32                     return 1111111;  
33                 }  
34                 if(method.getName().equals("method3")){  
35                     System.out.println("filter method3 ");  
36                     return 3333;  
37                 }  
38                 return "default";  
39             }});  
40         Method targetMethod1=object.getClass().getMethod("method3",new Class[]{int.class});  
41         int i=(int)targetMethod1.invoke(object, new Object[]{33});  
42         Method targetMethod=object.getClass().getMethod("method1",new Class[]{String.class});  
43         System.out.println(targetMethod.invoke(object, new Object[]{"sdfs"}));  
44     }  
45   
46 }
点赞
收藏
评论区
推荐文章
Wesley13 Wesley13
3年前
jdk动态代理和cglib动态代理底层实现原理详细解析(cglib动态代理篇)
  代理模式是一种很常见的模式,本文主要分析cglib动态代理的过程1\.举例使用cglib代理需要引入两个包,maven的话包引入如下<!https://mvnrepository.com/artifact/cglib/cglib<dependency
Wesley13 Wesley13
3年前
@Transactional注解详细解读
@Transactional注解可以作用于接口、接口方法、类以及类方法上1\.当作用于类上时,该类的所有public方法将都具有该类型的事务属性2\.当作用在方法级别时会覆盖类级别的定义3\.当作用在接口和接口方法时则只有在使用基于接口的代理时它才会生效,也就是JDK动态代理,而不是Cglib代理4\.当在protect
Wesley13 Wesley13
3年前
JDK动态代理和Cglib的动态代理
最简单的是静态代理方法,即代理模式,这里就不多啰嗦了。。重点说一下JDK的动态代理和Cglib的动态代理吧先说JDK的,需要被代理的类需要有接口,否则无法实现package proxy.dynamic;public interface IBook {void add();}实现接口
Wesley13 Wesley13
3年前
CGLIB动态代理源码分析
CGLIB动态代理样例由于CGLIB是JDK之外的东西,因此在使用CGLIB的时候需要引入CGLIB的包(我这里是gradle项目):dependencies{implementation('cglib:cglib:3.3.0')}要被代理的类:packagecom.example.demo.p
Easter79 Easter79
3年前
Spring的两种代理JDK和CGLIB的区别浅谈
一、原理区别:java动态代理是利用反射机制生成一个实现代理接口的匿名类,在调用具体方法前调用InvokeHandler来处理。而cglib动态代理是利用asm开源包,对代理对象类的class文件加载进来,通过修改其字节码生成子类来处理。1、如果目标对象实现了接口,默认情况下会采用JDK的动态代理实现AOP 2、如果目标对象实现了接口,可以
Easter79 Easter79
3年前
Spring的Aop调用当前类的两种方法
我们知道Spring对于AOP实现有两种方法,如果类是接口实现类,则采用JDK动态代理实现AOP。如果类没有实现接口,则采用cglib生成子类做增强,以实现代理类的目的,其实运行时找到的是这个代理类,而不是原类。所以在一个代理类中调用内部的方法,是不是再走AOP逻辑的,那有什么好的方法可以解决这种问题吗?基于上面的思路有两种解决办法方法一:直接从
Stella981 Stella981
3年前
Spring AOP 两种代理 Cglib、JDK
概念AOP:AOP是OOP(面向对象编程)的一种延续,OOP中继承的思想主要是提高代码的重用率,但是继承不能同个类在多个方法的相同位置出现的相同代码的问题JDK动态代理:AOP的一种实现,仅支持实现了接口的类。性能较好Cglib:AOP的一种实现,支持实现了接口的类和没有实现接口的类。对比JDK动态代理性能较差SpringAOP:结
Wesley13 Wesley13
3年前
CGLIB代理基础
  本文意在讲解CGLIB的基础使用及基本原理。一、CGLIB的基本原理:  依赖ASM字节码工具,通过动态生成实现接口或继承类的类字节码,实现动态代理。  针对接口,生成实现接口的类,即implements方式;针对类,生成继承父类的类,即extends方式。二、为什么使用CGLIB?  JDK的动态代理只能基于接口,有时候我们想基于类
Easter79 Easter79
3年前
Spring的两种动态代理:Jdk和Cglib 的区别和实现
一、原理区别:java动态代理是利用反射机制生成一个实现代理接口的匿名类,在调用具体方法前调用InvokeHandler来处理。而cglib动态代理是利用asm开源包,对代理对象类的class文件加载进来,通过修改其字节码生成子类来处理。1、如果目标对象实现了接口,默认情况下会采用JDK的动态代理实现AOP 2、如果目标对象实现了接口,可以
Wesley13 Wesley13
3年前
Java动态代理机制解析
动态代理是指在运行时动态生成代理类。不需要我们像静态代理那个去手动写一个个的代理类。生成动态代理类有很多方式:Java动态代理,CGLIB,Javassist,ASM库等。这里主要说一下Java动态代理的实现。Java动态代理InvocationHandler接口Java动态代理中,每一个