JAVA 中的代码生成包 CGLIB （Code Generation Library）

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

CGLIB 作为一个开源项目，其代码托管在 Github，地址为：https://github.com/cglib/cglib

1. CGLIB 原理

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

2. 为什么使用 CGLIB?

CGLIB 代理主要通过对字节码的操作，为对象引入间接级别，以控制对象的访问。我们知道 Java 中有一个动态代理也是做这个事情的，那我们为什么不直接使用 Java 动态代理，而要使用 CGLIB 呢？

答案是 CGLIB 相比于 JDK动态代理 更加强大，JDK动态代理 虽然简单易用，但是其有一个致命缺陷是，只能对接口进行代理。如果要代理的类为一个普通类、没有接口，那么 Java动态代理 就没法使用了。

2.1 JAVA 动态代理分析

Java动态代理机制 的出现，使得 Java开发人员 不用手工编写代理类，只要简单地制定一组接口及委托类对象，便能动态地获得代理类。代理类会负责将所有的方法调用分配到委托对象上反射执行，配置执行过程中，开发人员还可以进行修改。

2.1.1 代理设计模式

代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息、过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。

1. 为了保持行为的一致性，代理类和委托类通常会实现相同的接口
2. 引入代理能够控制对委托对象的直接访问，可以很好的隐藏和保护委托对象，也更加具有灵活性

2.1.2 相关的类和接口

要了解 Java 动态代理的机制，首先需要了解以下相关的类或接口：

1. java.lang.reflect.Proxy ：这是 Java 动态代理机制的主类，它提供了一组静态方法来为一组接口动态地生成代理类及其对象
2. java.lang.reflect.InvocationHandler ：这是调用处理器接口，它自定义了一个 invoke 方法，用于几种处理在动态代理类对象上的方法调用。通常在该方法中实现对委托类的代理访问。
3. java.lang.ClassLoader ：Proxy 静态方法生成动态代理类同样需要通过类装载器来进行装载才能使用，它与普通类的唯一区别就是其字节码是由 JVM 在运行时动态生成的而非预存在于任何一个 .class 文件中。

2.1.3 代理机制及其特点

首先让我们来了解一下如何使用 Java 动态代理。具体有如下四步骤：

1. 通过实现 InvocationHandler 接口创建自己的调用处理器；
2. 通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类；
3. 通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型；
4. 通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入。

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
// 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用
InvocationHandler handler = new InvocationHandlerImpl(..); // 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象
Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... }); // 通过反射从生成的类对象获得构造函数对象
Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class }); // 通过构造函数对象创建动态代理类实例
Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });

实际使用过程更加简单，因为 Proxy 的静态方法 newProxyInstance 已经为我们封装了步骤 2 到步骤 4 的过程，所以简化后的过程如下：

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
InvocationHandler handler = new InvocationHandlerImpl(..); // 通过 Proxy 直接创建动态代理类实例
Interface proxy = (Interface)Proxy.newProxyInstance( classLoader, new Class[] { Interface.class }, handler );

动态生成的代理类本身的一些特点

1. 包：如果所代理的接口都是 public 的，那么它将被定义在顶层包（即包路径为空），如果所代理的接口中有 非 public 的接口（因为接口不能被定义为 protect 或 private ，所以除 public 之外就是默认的 package 访问级别，那么它将被定义在该接口所在包，这样设计的目的是为了最大程度的保证动态代理类不会因为包管理的问题而无法被成功定义并访问；
2. 类修饰符：该代理类具有 final 和 public 修饰符，意味着它可以被所有的类访问，但是不能被再度继承；
3. 类名：格式是 $ProxyN ，其中 N 是一个逐一递增的阿拉伯数字，代表 Proxy 类 第 N 次 生成的动态代理类，值得注意的一点是，并不是每次调用 Proxy 的静态方法创建动态代理类都会使得 N 值增加，原因是如果对同一组接口（包括接口排列的顺序相同）试图重复创建动态代理类，它会很聪明地返回先前已经创建好的代理类的类对象，而不会再尝试去创建一个全新的代理类，这样可以节省不必要的代码重复生成，提高了代理类的创建效率。
4. 类继承关系：Proxy 类是它的父类，这个规则适用于所有由 Proxy 创建的动态代理类。而且该类还实现了其所代理的一组接口。

代理类实例的一些特点：

1. 每个实例都会关联一个 InvocationHandler （调用处理器对象），在代理类实例上调用其代理接口中声明的方法时，最终都会由 InvocationHandler 的 invoke方法 执行；
2. java.lang.Object 中有三个方法也同样会被分派到调用处理器的 invoke 方法 执行，它们是 hashCode ，equals 和 toString；

被代理接口的一组特点

1. 要注意不能有重复的接口
2. 接口对于类装载器必须可见，否则类装载器将无法链接它们
3. 被代理的所有非 public 的接口必须在同一个包中，接口的数目不能超过65535

2.1.4 美中不足

Proxy 只能对 interface 进行代理，无法实现对 class 的动态代理。观察动态生成的代理继承关系图可知原因，他们已经有一个固定的父类叫做 Proxy ，Java语法 限定其不能再继承其他的父类。

2.1.5 代码示例

最后以一个简单的动态代理例子结束

public class DynamicProxy {interface IHello{void sayHello();}static class Hello implements IHello{public void sayHello() {System.out.println("hello world");}}static class DynamicProxyTest implements InvocationHandler{Object originalObj;Object bind(Object originalObj){this.originalObj = originalObj;return Proxy.newProxyInstance(originalObj.getClass().getClassLoader(),originalObj.getClass().getInterfaces(), this);}public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("Welcome");return method.invoke(originalObj, args);}}public static void main(String[] args){//设置这个值，在程序运行完成后，可以生成代理类System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");IHello hello = (IHello) new DynamicProxyTest().bind(new Hello());hello.sayHello();}
}

程序输出为：

Welcome
hello world

3. CGLIB 组成结构

CGLIB 底层使用了ASM（一个短小精悍的字节码操作框架）来操作字节码生成新的类。除了 CGLIB库 外，脚本语言（如 Groovy 和 BeanShell ）也使用 ASM 生成字节码。ASM 使用类似 SAX 的解析器来实现高性能。

4. CGLIB 的 API

4.1 Jar包

• cglib-nodep-2.2.jar：使用 nodep 包不需要关联 asm 的 jar 包，jar 包内部包含 asm 的类。
• cglib-2.2.jar：使用此 jar 包需要关联 asm 的 jar 包,否则运行时报错。

4.2 CGLIB类库

4.3 例子

说了这么多，可能大家还是不知道 CGLIB 是干什么用的。下面我们将使用一个简单的例子来演示如何使用 CGLIB 对一个方法进行拦截。
首先，我们需要在工程的 POM 文件中引入 CGLIB 的 dependency，这里我们使用的是 2.2.2 版本。

cglibcglib2.2.2

依赖包下载后，我们就可以干活了，按照国际惯例，写个 hello world

public class SampleClass {public void test(){System.out.println("hello world");}public static void main(String[] args) {Enhancer enhancer = new Enhancer();enhancer.setSuperclass(SampleClass.class);enhancer.setCallback(new MethodInterceptor() {@Overridepublic Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {System.out.println("before method run...");Object result = proxy.invokeSuper(obj, args);System.out.println("after method run...");return result;}});SampleClass sample = (SampleClass) enhancer.create();sample.test();}
}

在 mian 函数中，我们通过一个 Enhancer 和一个 MethodInterceptor 来实现对方法的拦截，运行程序后输出为：

before method run...
hello world
after method run...

4.4 常见的 API

4.4.1 Enhancer

• Enhancer 可能是 CGLIB 中最常用的一个类，和 Java1.3动态代理 中引入的 Proxy 类差不多。
• 和Proxy 不同的是，Enhancer 既能够代理普通的 class ，也能够代理接口。
• Enhancer 创建一个被代理对象的子类并且拦截所有的方法调用（包括从 Object 中继承的 toString 和 hashCode 方法）。
  • Enhancer 不能够拦截 final 方法，例如 Object.getClass() 方法，这是由于 Java final 方法语义决定的。
  • 基于同样的道理，Enhancer 也不能对 fianl 类进行代理操作。这也是 Hibernate 为什么不能持久化 final class 的原因。

public class SampleClass {public String test(String input){return "hello world";}
}

下面我们将以这个类作为主要的测试类，来测试调用各种方法

@Test
public void testFixedValue(){Enhancer enhancer = new Enhancer();enhancer.setSuperclass(SampleClass.class);enhancer.setCallback(new FixedValue() {@Overridepublic Object loadObject() throws Exception {return "Hello cglib";}});SampleClass proxy = (SampleClass) enhancer.create();System.out.println(proxy.test(null)); //拦截test，输出Hello cglibSystem.out.println(proxy.toString()); System.out.println(proxy.getClass());System.out.println(proxy.hashCode());
}

输出：

Hello cglib
Hello cglib
class com.zeus.cglib.SampleClass$$EnhancerByCGLIB$$e3ea9b7java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Numberat com.zeus.cglib.SampleClass$$EnhancerByCGLIB$$e3ea9b7.hashCode()...

• 上述代码中，FixedValue 用来对所有拦截的方法返回相同的值，从输出我们可以看出来：

  • Enhancer 对 非final方法test()、toString()、hashCode()进行了拦截，没有对getClass进行拦截。

  • 由于 hashCode() 方法需要返回一个 Number，但是我们返回的是一个 String，这解释了上面的程序中为什么会抛出异常。

• Enhancer.setSuperclass 用来设置父类型，从 toString() 可以看出，使用 CGLIB 生成的类为被代理类的一个子类，形如：SampleClass$$EnhancerByCGLIB$$e3ea9b7

• Enhancer.create(Object…) 方法是用来创建增强对象的，其提供了很多不同参数的方法用来匹配被增强类的不同构造方法。（虽然类的构造方法只是 Java字节码 层面的函数，但是 Enhancer 却不能对其进行操作。Enhancer 同样不能操作 static 或者 final 类）。

  • 我们也可以先使用Enhancer.createClass() 来创建字节码（ .class ），然后用字节码动态的生成增强后的对象。

可以使用一个 InvocationHandler 作为回调，使用 invoke 方法来替换直接访问类的方法，但是你必须注意死循环。因为 invoke 中调用的任何原代理类方法，均会重新代理到 invoke 方法中。

public void testInvocationHandler() throws Exception{Enhancer enhancer = new Enhancer();enhancer.setSuperclass(SampleClass.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 "hello cglib";}else{throw new RuntimeException("Do not know what to do");}}});SampleClass proxy = (SampleClass) enhancer.create();Assert.assertEquals("hello cglib", proxy.test(null));Assert.assertNotEquals("Hello cglib", proxy.toString());
}

为了避免这种死循环，我们可以使用 MethodInterceptor ，MethodInterceptor 的例子在前面的 hello world 中已经介绍过了，这里就不浪费时间了。

有些时候我们可能只想对特定的方法进行拦截，对其他的方法直接放行，不做任何操作，使用Enhancer处理这种需求同样很简单，只需要一个 CallbackFilter 即可：

@Test
public void testCallbackFilter() throws Exception{Enhancer enhancer = new Enhancer();CallbackHelper callbackHelper = new CallbackHelper(SampleClass.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{return NoOp.INSTANCE;}}};enhancer.setSuperclass(SampleClass.class);enhancer.setCallbackFilter(callbackHelper);enhancer.setCallbacks(callbackHelper.getCallbacks());SampleClass proxy = (SampleClass) enhancer.create();Assert.assertEquals("Hello cglib", proxy.test(null));Assert.assertNotEquals("Hello cglib",proxy.toString());System.out.println(proxy.hashCode());
}

4.4.1.1 Java回调函数详解

4.4.1.1.1 什么是回调函数（CallBack）

在编写程序时，有时候会调用许多 API 中实现实现的函数，但某些方法需要我们传入一个方法，以便在需要的时候调用我们传入进去的函数。这个被传入的函数称为回调函数（Callback function）。

打个比方，有一个餐馆，提供炒菜的服务，但是会让我们选择做菜的方式，我们去这家餐馆里面吃饭，想吃小龙虾，我们告诉他想吃小龙虾后，他询问我们要以何种方式去进行烹饪，是煎炒烹炸还是避风塘。

在上面的例子中，炒菜是我们需要调用的方法，也是 API 库中所提供的，而炒菜的方式，则是我们去选择的，可以我们自己去定义的。

这个就可以回调函数，有库函数（Librart function）来执行我们传入的回调函数（Callback function）

4.4.1.1.2 在Java中实现回调函数

Callable接口

Interface Callable

在 Java1.8 官方文档中给出的内容为

• 参数类型：V - 回调方法的返回值类型

• 已经实现的子接口：DocumentationTool.DocumentationTask，JavaCompiler.CompilationTask

• 这个接口位函数试接口

  • @FunctionalInterface
    public interface Callable
    

• 返回结果可能引发异常，这个接口与 Runnable 非常相似，这两个接口的设计可以在实例化后，开启新的线程，与 Runnable 的差别是，Runnable 不能返回参数也不能抛出异常。

例子：

import java.util.Random;
import java.util.concurrent.Callable;public class CallableExample  implements Callable {@Overridepublic Object call() throws Exception {Random generator = new Random();Integer randomNumber = generator.nextInt(5);Thread.sleep(randomNumber * 1000);return randomNumber;}
}

测试：

@Test
public void callabledTest(){ExecutorService executorService = Executors.newCachedThreadPool();CallableExample callableExample = new CallableExample();Future