Java成神之路——CGLIB使用

什么是cglib

CGLIB（Code Generator Library）是一个强大的、高性能的代码生成库。其被广泛应用于AOP框架（Spring、dynaop）中，用以提供方法拦截操作。Hibernate作为一个比较受欢迎的ORM框架，同样使用CGLIB来代理单端（多对一和一对一）关联（延迟提取集合使用的另一种机制）。

为什么使用CGLIB

CGLIB代理主要通过对字节码的操作，为对象引入间接级别，以控制对象的访问。我们知道Java中有一个动态代理也是做这个事情的，那我们为什么不直接使用Java动态代理，而要使用CGLIB呢？答案是CGLIB相比于JDK动态代理更加强大，JDK动态代理虽然简单易用，但是其有一个致命缺陷是，只能对接口进行代理。如果要代理的类为一个普通类、没有接口，那么Java动态代理就没法使用了。

CGLIB组织结构

CGLIB底层使用了ASM（一个短小精悍的字节码操作框架）来操作字节码生成新的类。除了CGLIB库外，脚本语言（如Groovy何BeanShell）也使用ASM生成字节码。ASM使用类似SAX的解析器来实现高性能。我们不鼓励直接使用ASM，因为它需要对Java字节码的格式足够的了解。ASM的使用可以参考

使用实例

CGLIB创建代理类

maven 引入cglib包。

<dependency><groupId>cglib</groupId><artifactId>cglib</artifactId><version>2.2.2</version>
</dependency>

创建被代理类

public class OtherClass {private String name;public String getName() {return name;}public void setName(String name) {this.name = name;}public void test(){System.out.println("Other Class。。。");}
}

使用cglib创建代理

    Enhancer enhancer = new Enhancer();enhancer.setSuperclass(OtherClass.class);enhancer.setCallback(new MethodInterceptor() {@Overridepublic Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {System.out.println("调用之前");// 注意这里调用的是invokeSuper,还有一个方法invoke调用的代理本身的方法，会造成Stack OverflowObject result = methodProxy.invokeSuper(o, objects);System.out.println("调用之后");return result;}});OtherClass otherClass = (OtherClass) enhancer.create();System.out.println("代理类是：" + otherClass.getClass().getSimpleName());System.out.println("代理的父类是：" + otherClass.getClass().getSuperclass().getSimpleName());otherClass.test();

console 输出：

代理类是：OtherClass$$EnhancerByCGLIB$$ebef5aab
代理的父类是：OtherClass
调用之前
Other Class。。。
调用之后

固定返回值代理

代理目标类的方法放回固定值，会代理目标类所有非final方法，返回固定的值。

public class OtherClass {private String name;public String getName() {return name;}public void setName(String name) {this.name = name;}public void test(){System.out.println("Other Class。。。");}
}Enhancer enhancer = new Enhancer();enhancer.setSuperclass(OtherClass.class);enhancer.setCallback(new FixedValue() {@Overridepublic Object loadObject() throws Exception {return "fixed value";}});OtherClass otherClass = (OtherClass) enhancer.create();// 方法无返回值，有被fixedValue代理了，无效otherClass.test();// 代理getName返回固定值System.out.println(otherClass.getName());// getClass是final的不代理System.out.println(otherClass.getClass().getSimpleName());// 代理了hashCode但hashCode返回是int，代理返回的是str，抛出异常System.out.println(otherClass.hashCode());

console 输出：

fixed value
OtherClass$$EnhancerByCGLIB$$7ecc18d3
Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Number

CGLIB的InvocationHandler

看到InvocationHandler就有中亲切的感觉，用法和jdk的InvocationHandler差不多。注意到的包是cglib的

    final OtherClass o = new OtherClass();Enhancer enhancer = new Enhancer();enhancer.setSuperclass(OtherClass.class);enhancer.setCallback(new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {if(method.getDeclaringClass() != Object.class && method.getReturnType() == String.class){return "invocation Handler";}else{return method.invoke(o,args);}}});OtherClass otherClass = (OtherClass) enhancer.create();System.out.println(otherClass.getName());System.out.println(otherClass.getClass().getSimpleName());System.out.println(otherClass.hashCode());

console 输出：

invocation Handler
OtherClass$$EnhancerByCGLIB$$7ecc18d3
598446861

CallbackHelper

对特定的方法进行拦截

    Enhancer enhancer = new Enhancer();enhancer.setSuperclass(OtherClass.class);CallbackHelper callbackHelper = new CallbackHelper(OtherClass.class, new Class[0]) {@Overrideprotected Object getCallback(Method method) {// 过滤代理方法if(method.getDeclaringClass() != Object.class && method.getReturnType() == String.class){return new FixedValue() {@Overridepublic Object loadObject() throws Exception {return "Hello cglib";}};}else{// Methods using this Enhancer callback will delegate directly to the default (super) implementation in the base class.// 最直接调用被代理类return NoOp.INSTANCE;}}};enhancer.setCallbackFilter(callbackHelper);enhancer.setCallbacks(callbackHelper.getCallbacks());OtherClass otherClass = (OtherClass) enhancer.create();System.out.println(otherClass.getName());System.out.println(otherClass.getClass().getSimpleName());System.out.println(otherClass.hashCode());

console 输出：

Hello cglib
OtherClass$$EnhancerByCGLIB$$dd97cb24
2117255219

不可变对象

ImmutableBean允许创建一个原来对象的包装类，这个包装类是不可变的。不可以通过包装类来修改对象。

    OtherClass otherClass = new OtherClass();otherClass.setName("hahaha");OtherClass otherClass2 = (OtherClass) ImmutableBean.create(otherClass);System.out.println(otherClass2.getName());otherClass.setName("hehe");System.out.println(otherClass2.getName());otherClass2.setName("throw exception");

console 输出：

hahaha
hehe
Exception in thread "main" java.lang.IllegalStateException: Bean is immutable

动态创建bean

BeanGenerator 相当于一个小工具类，可以生成简单的bean

    BeanGenerator beanGenerator = new BeanGenerator();beanGenerator.addProperty("value",String.class);Object myBean = beanGenerator.create();// 自动生成setter，getter方法。Method setter = myBean.getClass().getMethod("setValue",String.class);setter.invoke(myBean,"Hello cglib");Method getter = myBean.getClass().getMethod("getValue");System.out.println(getter.invoke(myBean));

属性复制 Bean Copier

把两个类进行属性复制。属性名要一致。

    // 设置是否使用converterBeanCopier copier = BeanCopier.create(OtherClass.class, OtherClass2.class, false);OtherClass bean1 = new OtherClass();bean1.setName("Hello cglib");OtherClass2 otherBean = new OtherClass2();// 如果指定不使用转换器传null就好// 将bean1中的相同属性赋值到其他bean中copier.copy(bean1, otherBean, null);System.out.println(bean1.getName());System.out.println(otherBean.getName());

将bean1中的属性复制到了 otherBean中。

console 输出：

Hello cglib
Hello cglib

BulkBean 属性获取设置

public class OtherClass {private String name;private String address;... 省略setter，getter
}BulkBean bulkBean = BulkBean.create(OtherClass.class,new String[]{"getName","getAddress"},new String[]{"setName","setAddress"},new Class[]{String.class,String.class});OtherClass bean = new OtherClass();bean.setName("Hello world");Object[] propertyValues = bulkBean.getPropertyValues(bean);// 获取第一个属性值System.out.println(propertyValues[0]);// 设置属性值bulkBean.setPropertyValues(bean,new Object[]{"Hello cglib","address"});System.out.println(bean.getName());System.out.println(bean.getAddress());

console 输出：

Hello world
Hello cglib
address

BeanMap

将对象的属性转换位一个map<属性名，属性值>

// beanMap 是map的一直子类，直接通过set，get读取
BeanMap map = BeanMap.create(bean);

接口创建对象

keyFactory类用来动态生成接口的实例，接口需要只包含一个newInstance方法，返回一个Object。keyFactory为构造出来的实例动态生成了Object.equals和Object.hashCode方法，能够确保相同的参数构造出的实例为单例的。

interface SampleKeyFactory {Object newInstance(String first, int second);
}SampleKeyFactory keyFactory = (SampleKeyFactory) KeyFactory.create(SampleKeyFactory.class);Object key = keyFactory.newInstance("foo", 42);Object key1 = keyFactory.newInstance("foo", 42);System.out.println(key instanceof SampleKeyFactory);System.out.println(key .equals( key1));System.out.println(key.hashCode());System.out.println(key1.hashCode());

console 输出：

true
true
-1181409833
-1181409833

动态生成接口

    // 方法名；返回值；接受参数；Signature signature = new Signature("foo", Type.DOUBLE_TYPE, new Type[]{Type.INT_TYPE});Signature signature2 = new Signature("foo2", Type.getType(String.class),new Type[]{Type.INT_TYPE});InterfaceMaker interfaceMaker = new InterfaceMaker();// 添加方法；声明异常信息interfaceMaker.add(signature, new Type[]{Type.getType(Exception.class)});interfaceMaker.add(signature2, new Type[0]);Class iface = interfaceMaker.create();System.out.println(iface.getMethods().length);System.out.println(iface.getMethod("foo",int.class).getReturnType());System.out.println(iface.getMethod("foo",int.class).getExceptionTypes()[0]);System.out.println(iface.getMethod("foo2",int.class).getReturnType());

console 输出：

2
double
class java.lang.Exception
class java.lang.String

方法代理

接口要创建在一个单独的文件中

关于Method.create的参数说明：

第二个参数为即将被代理的方法
第一个参数必须是一个无参数构造的bean。因此MethodDelegate.create并不是你想象的那么有用
第三个参数为只含有一个方法的接口。当这个接口中的方法被调用的时候，将会调用第一个参数所指向bean的第二个参数方法

缺点：

为每一个代理类创建了一个新的类，这样可能会占用大量的永久代堆内存
你不能代理需要参数的方法
如果你定义的接口中的方法需要参数，那么代理将不会工作，并且也不会抛出异常；如果你的接口中方法需要其他的返回类型，那么将抛出IllegalArgumentException

// 单独文件中创建接口
public interface BeanDelegate {String getNameFromDelegate();
}OtherClass bean = new OtherClass();bean.setName("Hello cglib");BeanDelegate delegate = (BeanDelegate) MethodDelegate.create(bean,"getName", BeanDelegate.class);// 调用接口将会去调用指定了的指定方法System.out.println(delegate.getNameFromDelegate());

console 输出：

Hello cglib

多重方法代理

只用接口代理多个实现类的方法。

多重代理和方法代理差不多，都是将代理类方法的调用委托给被代理类。使用前提是需要一个接口，以及一个类实现了该接口
通过这种interface的继承关系，我们能够将接口上方法的调用分散给各个实现类上面去。
多重代理的缺点是接口只能含有一个方法，如果被代理的方法拥有返回值，那么调用代理类的返回值为最后一个添加的被代理类的方法返回值

public interface DelegatationProvider {void setValue(String value);
}
public class SimpleMulticastBean implements DelegatationProvider {private String value;@Overridepublic void setValue(String value) {this.value = value;}public String getValue() {return value;}
}MulticastDelegate multicastDelegate = MulticastDelegate.create(DelegatationProvider.class);SimpleMulticastBean first = new SimpleMulticastBean();SimpleMulticastBean second = new SimpleMulticastBean();multicastDelegate = multicastDelegate.add(first);multicastDelegate  = multicastDelegate.add(second);DelegatationProvider provider = (DelegatationProvider) multicastDelegate;provider.setValue("Hello world");System.out.println(first.getValue());System.out.println(second.getValue());

console 输出：

Hello world
Hello world

构造器代理

为了对构造函数进行代理，我们需要一个接口，这个接口只含有一个Object newInstance(…)方法，用来调用相应的构造函数

public interface SampleBeanConstructorDelegate {Object newInstance(String value);
}
public class OtherClass {private String name;public String getName() {return name;}public void setName(String name) {this.name = name;}public OtherClass(String name) {this.name = name;}
}SampleBeanConstructorDelegate constructorDelegate = (SampleBeanConstructorDelegate) ConstructorDelegate.create(OtherClass.class, SampleBeanConstructorDelegate.class);OtherClass bean = (OtherClass) constructorDelegate.newInstance("Hello world");System.out.println(bean.getName());

console 输出：

Hello world

FastClass

顾明思义，FastClass就是对Class对象进行特定的处理，比如通过数组保存method引用，因此FastClass引出了一个index下标的新概念，比如getIndex(String name, Class[] parameterTypes)就是以前的获取method的方法。通过数组存储method,constructor等class信息，从而将原先的反射调用，转化为class.index的直接调用，从而体现所谓的FastClass。

    FastClass fastClass = FastClass.create(OtherClass.class);FastMethod fastMethod = fastClass.getMethod("getName",new Class[0]);OtherClass bean = new OtherClass();bean.setName("Hello world");Object result = fastMethod.invoke(bean, new Object[0]);System.out.println(result.toString());

console 输出：

Hello world

参考链接

咸鱼IT技术交流群：89248062，在这里有一群和你一样有爱、有追求、会生活的朋友！大家在一起互相支持，共同陪伴，让自己每天都活在丰盛和喜乐中！同时还有庞大的小伙伴团体，在你遇到困扰时给予你及时的帮助，让你从自己的坑洞中快速爬出来，元气满满地重新投入到生活中！