CGLIB介绍与原理
一、什么是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原理是动态生成被代理类的子类。
下面,将通过一个实例介绍使用
1. CGLib实现动态代理。
被代理类:
首先,定义一个类,该类没有实现任何接口
public class TargetObject {
public String method1(String paramName) {
return paramName;
}
public int method2(int count) {
return count;
}
public int method3(int count) {
return count;
}
@Override
public String toString() {
return "TargetObject []" + getClass();
}
}
拦截器
定义一个拦截器。在调用目标方法时,CGLib会回调MethodInterceptor接口方法拦截,来实现你自己的代理逻辑,类似于JDK中的InvocationHandler接口。
public class TargetInterceptor implements MethodInterceptor {
/**
* 重写方法拦截在方法前和方法后加入业务
*
* @param o obj为目标对象
* @param method method为目标方法
* @param objects 参数,
* @param methodProxy CGlib方法代理对象
* @return 从代理实例的方法调用返回的值
*/
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("调用前");
//调用代理类实例上的proxy方法的父类方法(即实体类TargetObject中对应的方法)
Object result = methodProxy.invokeSuper(o, objects);
System.out.println("调用后");
return result;
}
}
参数:
Object为由CGLib动态生成的代理类实例
Method为上文中实体类所调用的被代理的方法引用
Object[]为参数值列表
MethodProxy为生成的代理类对方法的代理引用。
返回:从代理实例的方法调用返回的值。
其中,proxy.invokeSuper(obj,arg):
调用代理类实例上的proxy方法的父类方法(即实体类TargetObject中对应的方法)
生成动态代理类
public class TestCglib {
public static void main(String[] args) {
//Enhancer类是CGLib中的一个字节码增强器,它可以方便的对你想要处理的类进行扩展
Enhancer enhancer = new Enhancer();
//将被代理类TargetObject设置成父类
enhancer.setSuperclass(TargetObject.class);
//设置拦截器TargetInterceptor
enhancer.setCallback(new TargetInterceptor());
//enhancer.create()动态生成一个代理类,并从Object强制转型成父类型TargetObject。
TargetObject targetObject2=(TargetObject)enhancer.create();
//在代理类上调用方法.
System.out.println(targetObject2);
System.out.println(targetObject2.method1("mmm1"));
System.out.println(targetObject2.method2(100));
System.out.println(targetObject2.method3(200));
}
}
输出结果
调用前
调用后
TargetObject []class cglib.example.TargetObject$$EnhancerByCGLIB$$522981fa
调用前
调用后
mmm1
调用前
调用后
100
调用前
调用后
200
这里Enhancer类是CGLib中的一个字节码增强器,它可以方便的对你想要处理的类进行扩展,以后会经常看到它。
首先将被代理类TargetObject设置成父类,然后设置拦截器TargetInterceptor,最后执行enhancer.create()动态生成一个代理类,并从Object强制转型成父类型TargetObject。
最后,在代理类上调用方法
回调过滤器CallbackFilter
在CGLib回调时可以设置对不同方法执行不同的回调逻辑,或者根本不执行回调。
在JDK动态代理中并没有类似的功能,对InvocationHandler接口方法的调用对代理类内的所以方法都有效。
定义实现过滤器CallbackFilter接口的类:
public class TargetMethodCallbackFilter implements CallbackFilter {
/**
* 过滤方法
* 返回的值为数字,代表了Callback数组中的索引位置,要到用的Callback
*
* @param method 方法
* @return Callback数组中的索引位置
*/
@Override
public int accept(Method method) {
switch (method.getName()) {
case "method1":
System.out.println("filter method1 to 0");
return 0;
case "method2":
System.out.println("filter method2 to 1");
return 1;
case "method3":
System.out.println("filter method3 to 2");
return 2;
default:
return 0;
}
}
}
public class TargetResultFixed implements FixedValue {
/**
* 该类实现FixedValue接口,同时锁定回调值为999
* (整型,CallbackFilter中定义的使用FixedValue型回调的方法为getConcreteMethodFixedValue,该方法返回值为整型)。
*/
@Override
public Object loadObject() throws Exception {
System.out.println("锁定结果");
return 999;
}
}
public class TestCglib {
public static void main(String[] args) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(TargetObject.class);
TargetMethodCallbackFilter filter = new TargetMethodCallbackFilter();
//方法拦截器
Callback callback = new TargetInterceptor();
//这个NoOp表示no operator,即什么操作也不做,代理类直接调用被代理的方法不进行拦截。
Callback noop = NoOp.INSTANCE;
//表示锁定方法返回值,无论被代理类的方法返回什么值,回调方法都返回固定值。
Callback resultFixed = new TargetResultFixed();
Callback[] callbacks = new Callback[]{callback,noop,resultFixed};
enhancer.setCallbacks(callbacks);
enhancer.setCallbackFilter(filter);
TargetObject object = (TargetObject) enhancer.create();
System.out.println("TargetObject = "+object);
//调用TargetInterceptor
System.out.println("调用method1: "+object.method1("method 1"));
//NOops 什么都不处理 直接调用被代理的方法
System.out.println("调用method2: "+object.method2(1));
//resultFixed 回调方法返回固定的值
System.out.println("调用method3: "+object.method3(2));
}
}
输出:
filter method1 to 0
filter method2 to 1
filter method3 to 2
调用前
调用后
TargetObject = TargetObject []class cglib.example.TargetObject$$EnhancerByCGLIB$$5a4247af
调用前
调用后
调用method1: method 1
调用method2: 1
锁定结果
调用method3: 999
延迟加载对象
说到延迟加载,应该经常接触到,尤其是使用Hibernate的时候,本篇将通过一个实例分析延迟加载的实现方式。
LazyLoader接口继承了Callback,因此也算是CGLib中的一种Callback类型。
另一种延迟加载接口Dispatcher。
Dispatcher接口同样继承于Callback,也是一种回调类型。
但是Dispatcher和LazyLoader的区别在于:
LazyLoader只在第一次访问延迟加载属性时触发代理类回调方法
而Dispatcher在每次访问延迟加载属性时都会触发代理类回调方法。
定义PropertyBean
public class PropertyBean {
private String key;
private Object value;
public String getKey() {
return key;
}
public void setKey(String key) {
this.key = key;
}
public Object getValue() {
return value;
}
public void setValue(Object value) {
this.value = value;
}
@Override
public String toString() {
return "PropertyBean{" +
"key='" + key + '\'' +
", value=" + value +
'}';
}
}
分别定义两种不同的延迟加载模式的回调
public class ConcreteClassLazyLoader implements LazyLoader {
/**
* 对需要延迟加载的对象添加代理,在获取该对象属性时先通过代理类回调方法进行对象初始化。
* 在不需要加载该对象时,只要不去获取该对象内属性,该对象就不会被初始化了(在CGLib的实现中只要去访问该对象内属性的getter方法,
* 就会自动触发代理类回调)。
*/
@Override
public Object loadObject() throws Exception {
System.out.println("before lazyLoader...");
PropertyBean propertyBean = new PropertyBean();
propertyBean.setKey("lazyloader");
propertyBean.setValue(new TargetObject());
System.out.println("after lazyLoader...");
return propertyBean;
}
}
public class ConcreteClassDispatcher implements Dispatcher {
@Override
public Object loadObject() throws Exception {
System.out.println("before Dispatcher...");
PropertyBean propertyBean = new PropertyBean();
propertyBean.setKey("dispatcher");
propertyBean.setValue(new TargetObject());
System.out.println("after Dispatcher...");
return propertyBean;
}
}
定义一个实体类
public class LazyBean {
private String name;
private int age;
private PropertyBean propertyBean;
private PropertyBean propertyBeanDispatcher;
public LazyBean(String name, int age) {
System.out.println("Init LazyBean..");
this.name = name;
this.age = age;
propertyBean = createPropertyBean();
this.propertyBeanDispatcher = createPropertyBeanDispatcher();
}
/**
* 只第一次懒加载
*/
private PropertyBean createPropertyBean() {
/*
* 使用cglib进行懒加载 对需要延迟加载的对象添加代理,在获取该对象属性时先通过代理类回调方法进行对象初始化。
* 在不需要加载该对象时,只要不去获取该对象内属性,该对象就不会被初始化了(在CGLib的实现中只要去访问该对象内属性的getter方法,
* 就会自动触发代理类回调)。
*/
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(PropertyBean.class);
return (PropertyBean) Enhancer.create(PropertyBean.class, new ConcreteClassLazyLoader());
}
/**
* 每次都懒加载
*/
private PropertyBean createPropertyBeanDispatcher() {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(PropertyBean.class);
return (PropertyBean) Enhancer.create(PropertyBean.class, new ConcreteClassDispatcher());
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public PropertyBean getPropertyBean() {
return propertyBean;
}
public void setPropertyBean(PropertyBean propertyBean) {
this.propertyBean = propertyBean;
}
public PropertyBean getPropertyBeanDispatcher() {
return propertyBeanDispatcher;
}
public void setPropertyBeanDispatcher(PropertyBean propertyBeanDispatcher) {
this.propertyBeanDispatcher = propertyBeanDispatcher;
}
@Override
public String toString() {
return "LazyBean{" +
"name='" + name + '\'' +
", age=" + age +
", propertyBean=" + propertyBean +
", propertyBeanDispatcher=" + propertyBeanDispatcher +
'}';
}
}
测试
public class TestCglib {
public static void main(String[] args) {
LazyBean lazyBean = new LazyBean("heqianqian",22);
//LazyLoader 只在第一次访问时触发代理类回调方法
System.out.println("========LazyLoader Start=========");
PropertyBean propertyBean = lazyBean.getPropertyBean();
System.out.println(propertyBean);
propertyBean = lazyBean.getPropertyBean();
System.out.println(propertyBean);
System.out.println("========LazyLoader END=========");
System.out.println("========Dispatcher Start=========");
propertyBean = lazyBean.getPropertyBeanDispatcher();
System.out.println(propertyBean);
propertyBean = lazyBean.getPropertyBeanDispatcher();
System.out.println(propertyBean);
System.out.println("========Dispatcher END=========");
}
}
测试结果
Init LazyBean..
========LazyLoader Start=========
before lazyLoader...
after lazyLoader...
PropertyBean{key='lazyloader', value=TargetObject []class cglib.example.TargetObject}
PropertyBean{key='lazyloader', value=TargetObject []class cglib.example.TargetObject}
========LazyLoader END=========
========Dispatcher Start=========
before Dispatcher...
after Dispatcher...
PropertyBean{key='dispatcher', value=TargetObject []class cglib.example.TargetObject}
before Dispatcher...
after Dispatcher...
PropertyBean{key='dispatcher', value=TargetObject []class cglib.example.TargetObject}
========Dispatcher END=========
接口生成器InterfaceMaker
InterfaceMaker会动态生成一个接口,该接口包含指定类定义的所有方法。
public class TestInterfaceMaker {
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
InterfaceMaker interfaceMaker = new InterfaceMaker();
interfaceMaker.add(TargetObject.class);
//抽取某个类的方法生成接口方法
Class<?> targetInterface = interfaceMaker.create();
Method[] methods = targetInterface.getMethods();
for (Method method : methods) {
System.out.println(method.getName());
}
//接口代理并设置代理接口方法拦截
Object object = Enhancer.create(Object.class, new Class[]{targetInterface}, (MethodInterceptor) (o, method, params, methodProxy) -> {
switch (method.getName()) {
case "method1":
System.out.println("filter method1 ");
return "mmmmmmmmm";
case "method2":
System.out.println("filter method2 ");
return 1111111;
case "method3":
System.out.println("filter method3 ");
return 3333;
default:
return "default";
}
});
Method targetMethod1 = object.getClass().getMethod("method1", String.class);
System.out.println(targetMethod1.invoke(object, new Object[]{"sdfs"}));
Method targetMethod2 = object.getClass().getMethod("method2", int.class);
System.out.println(targetMethod2.invoke(object, new Object[]{100}));
Method targetMethod3 = object.getClass().getMethod("method3", int.class);
System.out.println(targetMethod3.invoke(object, new Object[]{33}));
}
}
输出
toString
method1
method3
method2
filter method1
mmmmmmmmm
filter method2
1111111
filter method3
3333