CGLib 介绍与原理

左手的ㄟ右手 2022-06-15 08:58 212阅读 0赞

# 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

--------------------