cglib FastClass機制

jtea發表於2024-03-12
CGLibAST

前言

關於動態代理的一些知識，以及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

相關文章