前篇文章动态代理（一）——JDK中的动态代理中详细介绍了JDK动态代理的Demo实现，api介绍，原理详解。这篇文章继续讨论Java中的动态代理，并提及了Java中动态代理的几种实现方式。这里继续介绍CGLIB代理方式。
CGLIB动态代理在AOP、RPC中都有所使用，是Java体系中至关重要的一块内容。本篇文章的主要目标：
- 掌握使用CGLIB生成代理类
- 深入理解CGLIB的代理原理
从以上目标出发，本篇文章主要从以下几个方面逐步深入探索CGLIB：
- CGLIB的使用Demo
- CGLIB重要API介绍
- CGLIB代理原理
- 总结
一.CGLIB的使用Demo
使用CGLIB的大致分为四步骤：
- 创建被代理对象
- 创建方法拦截器
- 创建代理对象
- 调用代理对象
1.创建被代理对象
public class EchoServiceImpl implements EchoService {
public void echo(String message) {
System.out.println(message);
}
public void print(String message) {
System.out.println(message);
}
public int test() {
return 1;
}
public final void finalTest() {
System.out.println("I am final method.");
}
}
2.创建方法拦截器
public class EchoServiceInterceptor implements MethodInterceptor {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("before invoking!");
Object object = methodProxy.invokeSuper(o, objects);
System.out.println("after invoking!");
return object;
}
}
接口MethodInterceptor是CGLIB库提供，用于应用开发者根据自己的业务逻辑进行扩展实现。
3.创建代理对象
//Enhancer是生成代理类的工厂
Enhancer enhancer = new Enhancer();
//设置代理的超类，即被代理对象
enhancer.setSuperclass(EchoServiceImpl.class);
//设置拦截方法
enhancer.setCallback(new EchoServiceInterceptor());
//生成代理对象
EchoService echoService = (EchoService) enhancer.create();
4.调用代理对象
echoService.echo("test");
执行结果：
before invoking!
test
after invoking!
二.CGLIB重要API介绍
CGLIB库的体积很小，但是学习难度确非常高，毕竟涉及到bytecode。所以该篇文章后续关于原理介绍，只涉及代理原理方面，关于如何生成代理对象的方面，由于个人能力所及，不敢妄加说明。
下面是CGLIB的包结构，每个包都是负责一个模块功能，定义非常明确，负责单一的功能职责:
-
net.sf.cglib.core
低级别的字节码操作的类，它们直接与ASM相关 -
net.sf.cglib.transform
在运行或者构建时转换类文件的一些类 -
net.sf.cglib.proxy
创建代理和方法拦截器定义的类 -
net.sf.cglib.reflect
实现快速反射的一些基础类 -
net.sf.cglib.util
用于集合排序的一些工具类 -
net.sf.cglib.beans
与JavaBean相关的类
虽然cglib包含了如此多的功能模块，但是对于使用者，我们并不需要关注如此多的细节，只需要掌握几个重要的接口：
在看完上面的Demo，应该对Enhancer有一定了解。Enhancer字面义即增强，也正如其表述，Enhancer就是用来创建代理对象的接口。其中create方法可以生成代理对象，实际就是工厂模式。
在生成对象前，需要做关于代理方面的配置：
- 配置被代理对象(目标)，即setSuperClass设置超类型，该superClass即Enhancer中持有的Class对象；
- 配置统一拦截方法(中间人)，即setCallBack设置回调接口，对应上图的CallBack。AOP的实现使用methodInterpretor型CallBack；
- 可选性的配置拦截过滤器(核验流程)，即setCallBackFilter，对应上图的CallBackFiler；
Enhancer的create api提供了生成代理对象的。以上即在编写cglib动态代理过程中使用的几个重要api。虽然字节码技术是非常晦涩深奥，但是cglib以简单易用的api使字节码增强技术变得非常容易上手。
通过以上的demo示例和几个重要api的介绍应该都能掌握使用cglib库生成代理类。下面依然通过反编译的方式继续深入cglib的动态代理的调用原理。
三.CGLIB代理原理
1.整体架构与调用过程概览
在详细查看被代理对象的原理之前，先了解下cglib的整体架构图：
从图中可以看出，cglib在字节码层面的操作技术主要依赖ASM提供的能力。在上节中提到的net.sf.cglib.core包，正是与ASM相关。CGLIB上层直接面向应用层，将深奥晦涩的字节码技术包装成应用易用能理解的api，为aop，dynaminc proxy等技术提供了实现基础。
在反编译看代理对象的源代码之前，先看下代理调用的过程图：
从图中可以看出：
- 客户端调用代理对象的被代理方法
- 代理对象将调用委派给方法拦截器统一接口intercept
- 方法拦截器中执行前置操作，然后调用方法代理的统一接口invokeSuper
- 方法代理的invokeSuper初始化代理对象的和被代理对象的fastClass
- 初始化后，再调用代理对象的fastClass
- 代理对象的fastClass能够fast的调用代理的代理对象
- 代理对象再调用被代理对象的被代理方法
- 调用栈弹出，到intercept中再执行后置操作，方法调用结束
通过以上的过程再来看下它们之间的UML:
在Enhancer中的配置的被代理对象、统一回调的最终都被聚合到生成的代理对象中。（工厂模式，零件组装成产品）
代理对象聚合同一方法回调、继承被代理对象，聚合方法代理的。
2.反编译代理类字节码
CGLIB提供生成代理类的class文件的配置项。在CGLIB中提供了DebuggingClassWriter类用于将字节码的byte字节写入class文件中。
public byte[] toByteArray() {
return (byte[]) java.security.AccessController.doPrivileged(
new java.security.PrivilegedAction() {
public Object run() {
// 获取代理类的字节内容
byte[] b = ((ClassWriter) DebuggingClassWriter.super.cv).toByteArray();
if (debugLocation != null) {
// 转换生成的class文件路径分隔符
String dirs = className.replace('.', File.separatorChar);
try {
// 创建class文件
new File(debugLocation + File.separatorChar + dirs).getParentFile().mkdirs();
File file = new File(new File(debugLocation), dirs + ".class");
OutputStream out = new BufferedOutputStream(new FileOutputStream(file));
try {
// 将字节内容写入class文件
out.write(b);
} finally {
out.close();
}
if (traceCtor != null) {
file = new File(new File(debugLocation), dirs + ".asm");
out = new BufferedOutputStream(new FileOutputStream(file));
try {
ClassReader cr = new ClassReader(b);
PrintWriter pw = new PrintWriter(new OutputStreamWriter(out));
ClassVisitor tcv = (ClassVisitor)traceCtor.newInstance(new Object[]{null, pw});
cr.accept(tcv, 0);
pw.flush();
} finally {
out.close();
}
}
} catch (Exception e) {
throw new CodeGenerationException(e);
}
}
return b;
}
});
}
从以上可以看出只要配置文件的生成路径变量debugLocation即可，再来看下该变量初始化赋值情况
static {
// 从System中取出属性DEBUG_LOCATION_PROPERTY赋值给文件class文件生成路径变量
debugLocation = System.getProperty(DEBUG_LOCATION_PROPERTY);
if (debugLocation != null) {
System.err.println("CGLIB debugging enabled, writing to '" + debugLocation + "'");
try {
Class clazz = Class.forName("org.objectweb.asm.util.TraceClassVisitor");
traceCtor = clazz.getConstructor(new Class[]{ClassVisitor.class, PrintWriter.class});
} catch (Throwable ignore) {
}
}
}
可以看出只要应用启动时
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,
"/Users/lixinyou/Documents/code-space/java/java-base/java-proxy/target/proxy/impl");
设置DebuggingClassWriter.DEBUG_LOCATION_PROPERTY属性，在运行时CGLIB便会生成代理类的class。
这种方式与JDK的动态代理中的class文件生成方式一致。这种用法，在日常应用开发中也可借鉴，利用应用启动参数的不同，可以在运行时改变行为，代码具有强扩展性。
3.fastClass机制
在看代理机制源码之前，做好一切准备。再来了解下CGLIB中关于实现快速调用的fastClass机制。
在JDK的动态代理中使用反射调用目标对象，在CGLIB中为了更好的提升性能，采用fastClass机制。
FastClass机制：将类的方法信息解析出来，然后为其建立索引。调用的时候，只要传索引，就能找到相应的方法进行调用。
- 为所有的方法建立索引
- 调用前先根据方法信息寻找到索引
- 调用时根据索匹配相应的方法进行直接调用
CGLIB在字节码层面将方法和索引的对应关系建立，避免了反射调用：
public int getIndex(Signature var1) {
String var10000 = var1.toString();
switch(var10000.hashCode()) {
case -2055565910:
if (var10000.equals("CGLIB$SET_THREAD_CALLBACKS([Lnet/sf/cglib/proxy/Callback;)V")) {
return 11;
}
break;
case -1980342926:
if (var10000.equals("print(Ljava/lang/String;)V")) {
return 6;
}
break;
case -1860420502:
if (var10000.equals("CGLIB$clone$7()Ljava/lang/Object;")) {
return 24;
}
break;
case -1725733088:
if (var10000.equals("getClass()Ljava/lang/Class;")) {
return 29;
}
break;
}
return -1;
}
上述获取方法的索引，下述代码再根据索引进行调用：
public Object invoke(int index, Object var2, Object[] var3) throws InvocationTargetException {
e77dd5ce var10000 = (e77dd5ce)var2;
try {
switch(index) {
case 0:
return new Boolean(var10000.equals(var3[0]));
case 1:
return var10000.toString();
} catch (Throwable var4) {
throw new InvocationTargetException(var4);
}
throw new IllegalArgumentException("Cannot find matching method/constructor");
}
4.运行时的代理类
CGLIB运行时，实际会生成三个class：
- 代理类
- 代理类对应的fastClass
- 被代理类的fastClass
如上述Demo中生成的代理类和相应的代理类：
- EchoServiceImpl$$EnhancerByCGLIB$$e77dd5ce$$FastClassByCGLIB$$1b37f797.class
- EchoServiceImpl$$EnhancerByCGLIB$$e77dd5ce.class
- EchoServiceImpl$$FastClassByCGLIB$$44f86581.class
下面就看下生成的类的代码片段，理解下CGLIB的运行时代理原理。
首先看下生成的代理类
public class EchoServiceImpl$$EnhancerByCGLIB$$e77dd5ce extends EchoServiceImpl implements Factory {
代理类是继承自被代理类，这里与JDK的不同是，JDK是实现了接口。
下面的即是对echo方法的代理方法：
public final void echo(String var1) {
// 获取方法拦截器
MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
if (this.CGLIB$CALLBACK_0 == null) {
CGLIB$BIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
}
if (var10000 != null) { // 如果不为空，则调用其统一拦截
var10000.intercept(this, CGLIB$echo$2$Method, new Object[]{var1}, CGLIB$echo$2$Proxy);
} else { // 如果为空，则直接调用父类即被代理类的方法
super.echo(var1);
}
}
最为让人关注的是intercept方法调用时的参数MethodProxy:CGLIB$echo$2$Proxy
static {
CGLIB$STATICHOOK1();
}
static void CGLIB$STATICHOOK1() {
CGLIB$echo$2$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/String;)V", "echo", "CGLIB$echo$2");
}
在代理类被加载时，执行静态方法CGLIB$STATICHOOK1()，创建了echo方法对应的方法代理。
public static MethodProxy create(Class c1, Class c2, String desc, String name1, String name2) {
MethodProxy proxy = new MethodProxy();
proxy.sig1 = new Signature(name1, desc);
proxy.sig2 = new Signature(name2, desc);
proxy.createInfo = new CreateInfo(c1, c2);
return proxy;
}
这里使用了工厂模式，在创建MethodProxy时，为期成员CreateInfo赋值。c1代表被代理类，c2代表代理类。desc代理方法和被代理方法的参数信息，name1是被代理方法名，name2是代理方法名。
下面再看来下intercepte方法中调用的methodProxy的invokeSuper方法：
public Object invokeSuper(Object obj, Object[] args) throws Throwable {
try {
// 先进行初始化
init();
// 获取fastClassInfo对象
FastClassInfo fci = fastClassInfo;
// 获取代理类对应的fastClass对象并按索引调用
return fci.f2.invoke(fci.i2, obj, args);
} catch (InvocationTargetException e) {
throw e.getTargetException();
}
}
先看下初始化中所执行的逻辑：
private void init()
{
/*
* Using a volatile invariant allows us to initialize the FastClass and
* method index pairs atomically.
*
* Double-checked locking is safe with volatile in Java 5. Before 1.5 this
* code could allow fastClassInfo to be instantiated more than once, which
* appears to be benign.
*/
if (fastClassInfo == null)
{
synchronized (initLock)
{
if (fastClassInfo == null)
{
CreateInfo ci = createInfo;
FastClassInfo fci = new FastClassInfo();
// 获取被代理类
fci.f1 = helper(ci, ci.c1);
// 获取代理类
fci.f2 = helper(ci, ci.c2);
// 获取被代理类的被代理方法的索引
fci.i1 = fci.f1.getIndex(sig1);
// 获取代理类的代理方法的索引
fci.i2 = fci.f2.getIndex(sig2);
fastClassInfo = fci;
createInfo = null;
}
}
}
}
这里使用了单例模式，fastClassInfo对象是单例。所以初始化方法只会在第一次调用代理方法的时候，才响应的进行对其初始化。
初始化后，就将代理类和代理方法的索引获取到了，然后再按照索引直接对代理方法进行调用：
public Object invoke(int var1, Object var2, Object[] var3) throws InvocationTargetException {
e77dd5ce var10000 = (e77dd5ce)var2;
int var10001 = var1;
try {
switch(var10001) {
case 19:
var10000.CGLIB$echo$2((String)var3[0]);
return null;
}
} catch (Throwable var4) {
throw new InvocationTargetException(var4);
}
throw new IllegalArgumentException("Cannot find matching method/constructor");
}
上述考虑到篇幅和简洁的原因，这里只摘取了case:19的代码片段。
通过索引直接调用代理类代理方法：CGLIB$echo$2：
final void CGLIB$echo$2(String var1) {
super.echo(var1);
}
在该方法中再调用被代理类（继承了被代理类）的被代理方法。
至此，CGLIB的代理调用原理就是以上的内容。
四.总结
CGLIB是一种字节码增强库，利用其提供的字节码技术可以实现动态代理。其底层依赖ASM字节码技术。
CGLIB的动态代理与JDK动态代理的不同点：
- JDK动态代理必须需要接口，JDK代理是基于接口进行动态代理。CGLIB中既支持对接口的代理，也支持对对象的代理。
- CGLIB动态代理使用fastClass机制实现快速调用被代理类，JDK中使用了反射方式调用被代理。所以CGLIB的动态代理的方式性能上更有优势。
- CGLIB额外对来源于Object中的finalize和clone方法也做了拦截代理，JDK只为了equals、hashCode、toString进行代理
注：JDK中生成的代理类已经静态解析了方法对象作为代理类的静态变量，类似做缓存，从而部分解决反射的性能问题。
CGLIB的动态代理与JDK动态代理的相同点：
- 都具有统一接口，JDK动态代理中中间统一接口是InvocationHandler，CGLIB中是MethodInteceptor。
- 生成的代理类和其中的方法都是final
参考
neoremind/dynamic-proxy
Are there alternatives to cglib
Spring AOP 实现原理与 CGLIB 应用
深入浅出CGlib-打造无入侵的类代理
CGLib: The Missing Manual
Create Proxies Dynamically Using CGLIB Library