前言

关于动态代理的一些知识，以及cglib与jdk动态代理的区别，在这一篇已经介绍过，不熟悉的可以先看下。
本篇我们来学习一下cglib的FastClass机制，这是cglib与jdk动态代理的一个主要区别，也是一个面试考点。
我们知道jdk动态代理是使用InvocationHandler接口，在invoke方法内，可以使用Method方法对象进行反射调用，反射的一个最大问题是性能较低，cglib就是通过使用FastClass来优化反射调用，提升性能，接下来我们就看下它是如何实现的。

示例

我们先写一个hello world，让代码跑起来。如下：

public class HelloWorld {

	public void print() {
		System.out.println("hello world");
	}
}

public class HelloWorldInterceptor implements MethodInterceptor {
	public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
		System.out.println("before hello world");
		methodProxy.invokeSuper(o, objects);
		System.out.println("after hello world");
		return null;
	}
}

非常简单，就是使用MethodInterceptor在HelloWorld类print方法前后打印一句话，模拟对一个方法前后织入自定义逻辑。
接着使用cglib Enhancer类，创建动态代理对象，设置MethodInterceptor，调用方法。
为了方便观察源码，我们将cglib生成的动态代理类保存下来。

//将生成的动态代理类保存下来
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\");

Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(HelloWorld.class);
enhancer.setCallback(new HelloWorldInterceptor());

HelloWorld target = (HelloWorld) enhancer.create();
target.print();

输出

before hello world
hello world
after hello world

FastClass机制

我们知道cglib是通过继承实现的，动态代理类会继承被代理类，并重写它的方法，所以它不需要像jdk动态代理一样要求被代理对象有实现接口，因此比较灵活。
既然是通过继承实现的，那应该生成一个类就可以了，但是通过上面的路径观察，可以看到生成了3个文件，其中两个带有FastClass关键字。
这三个类分别是：动态代理类，动态代理类的FastClass，被代理对象的FastClass，从名称上也可以看出它们的关系。

其中动态代理类继承了被代理类，并重写了父类的所有方法，包括父类的父类的方法，包括Object类的equals方法和toString方法等。

public class HelloWorld$$EnhancerByCGLIB$$49f9f9c8 extends HelloWorld implements Factory {
}

这里我们只关注print方法，如下：

第一个直接调用父类方法，也就是被代理对象的方法；第二个会先判断有没有拦截器，如果没有也是直接调用父类方法，否则调用MethodInterceptor的intercept方法，对于我们这里就是HelloWorldInterceptor。
看下intercept的几个参数分别是什么，这几个参数的初始化在动态代理类的静态代码块中都可以找到。
第1个表示动态代理对象。
第2个是被代理对象方法的Method，就是HelloWorld.print。
第3个表示方法参数。
第4个是MethodProxy对象，通过名字我们可以知道它是方法的代理，每一个方法都会有一个对应的MethodProxy，它包含被代理对象、代理对象、以及对应的方法元信息。

这里我们重点关注MethodProxy，它的初始化如下：

CGLIB$print$0$Proxy = MethodProxy.create(var1, var0, "()V", "print", "CGLIB$print$0");       

第1个参数表示被代理对象的Class。
第2个参数表示动态代理对象的Class。
第3个参数是方法的返回值。
第4个参数表示被代理对象的方法名称。
第5个参数表示对应动态代理对象的方法名称。

MethodProxy对象创建好后，我们上面就是通过它进行调用的

methodProxy.invokeSuper(o, objects);

invokeSuper主要源码如下：

public Object invokeSuper(Object obj, Object[] args) throws Throwable {
    init();
    FastClassInfo fci = fastClassInfo;
    return fci.f2.invoke(fci.i2, obj, args);
}

private void init()
{
    if (fastClassInfo == null)
    {
        synchronized (initLock)
        {
            if (fastClassInfo == null)
            {
                CreateInfo ci = createInfo;

                FastClassInfo fci = new FastClassInfo();
                fci.f1 = helper(ci, ci.c1); //被代理对象的FastClass
                fci.f2 = helper(ci, ci.c2); //动态代理对象的FastClass
                fci.i1 = fci.f1.getIndex(sig1); //被代理对象方法的索引下标
                fci.i2 = fci.f2.getIndex(sig2); //动态代理对象方法的索引下标，这里是：CGLIB$print$0 
                fastClassInfo = fci;
                createInfo = null;
            }
        }
    }
}

init方法使用加锁+双检查的方式，只会初始化一次fastClassInfo变量，它用volatile关键字进行修饰，这里涉及到java字节码重排问题，具体可以参考我们之前的分析：happend before原则

接着回到invokeSuper方法，fci.f2.invoke(fci.i2, obj, args); 实际就是调用动态代理对象的FastClass的invoke方法，并把要调用方法的索引下标i2传过去。
至于方法的索引下标是怎么找到的，可以看动态代理对象的FastClass的getIndex方法，其实就是通过方法的名称、参数个数、参数类型，完全匹配，点到源码文件可以看到有大量的switch分支判断。
这里我们可以看到print方法的索引下标就是18。

public int getIndex(String var1, Class[] var2) {
    switch (var1.hashCode()) {
        case -1295482945:
            if (var1.equals("equals")) {
                switch (var2.length) {
                    case 1:
                        if (var2[0].getName().equals("java.lang.Object")) {
                            return 0;
                        }
                }
            }
        break;
        case 770871766:
            if (var1.equals("CGLIB$print$0")) {
                switch (var2.length) {
                    case 0:
                        return 18;
                }
            }
        break;
    }
}

 public Object invoke(int var1, Object var2, Object[] var3) throws InvocationTargetException {
    HelloWorld..EnhancerByCGLIB..49f9f9c8 var10000 = (HelloWorld..EnhancerByCGLIB..49f9f9c8)var2;
    int var10001 = var1;

    //...
    switch (var10001) {                
        //...
        case 18:
            var10000.CGLIB$print$0();
            return null;
    }
 }    

可以看到最终调用到动态代理类的CGLIB$print$0方法，也就是：

    final void CGLIB$print$0() {
        super.print();
    }

最终调用的就是父类的方法。我们画张图总结一下，有兴趣的同学跟着图和代码逻辑应该可以快速理解。

总结

经过上面的分析，我们可以看到cglib在整个调用过程并没有用到反射，而是使用FastClass对每个方法进行索引，通过方法名称，参数长度，参数类型就可以找到具体的方法，因此性能较好。但也有缺点，首次调用需要生成3个类，会比较慢。在我们实际开发中，特别是一些框架开发，如果有类似的场景也可以借助FastClass对反射进行优化，如：

MyClass cs = new MyCase();
FastClass fastClass = FastClass.create(Case.class);
int index = fastClass.getIndex("test", new Class[]{Integer.class});
Object invoke = fastClass.invoke(index, cs, new Object[1]);

另外MethodProxy还有一个invoke方法，如果我们换一下调用这个方法会发生？留给大家自己尝试。

methodProxy.invokeSuper(o, objects);
//换成 methodProxy.invoke(o, objects);

更多分享，欢迎关注我的github：https://github.com/jmilktea/jtea