Cglib的例項

本文重在原始碼的分析，Cglib的使用不再複述。

//被代理類
public class InfoDemo {
    public void welcome (String person){
        System.out.println("welcome :" + person);
    }
}

public class CglibInfoProxy implements MethodInterceptor {
    private Object target;
    public Object newInstance(Object source){
        target = source;
        Enhancer enhancer = new
 
 Enhancer();
        enhancer.setSuperclass(this.target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("before method!!!"
 
);
        Object value = methodProxy.invokeSuper(o, objects);
        //Object value = methodProxy.invoke(o, objects);
        return value;
    }
    public static void main(String[] args) {
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\\\classes");
        InfoDemo instance = (InfoDemo) new
 
 CglibInfoProxy().newInstance(new InfoDemo());
        instance.welcome("zhangsan");
    }
}

代理類位元組碼分析

先來看main函式中new CglibInfoProxy().newInstance(new InfoDemo())，簡單來說這個方法是將infoDemo作為一個父類，通過asm位元組碼生成一個子類來繼承infoDemo。
InfoDemo$$EnhancerByCGLIB$$8b8da05b.class，就是生成的子類的位元組碼，稱這個子類為InfoDemo的代理類。擷取部分位元組碼顯示：

public class InfoDemo$$EnhancerByCGLIB$$8b8da05b extends InfoDemo implements Factory {
    private MethodInterceptor CGLIB$CALLBACK_0;
    private static final Method CGLIB$welcome$0$Method;
    private static final MethodProxy CGLIB$welcome$0$Proxy;
    //..........................................省略
     static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("CglibTest.InfoDemo$$EnhancerByCGLIB$$8b8da05b");
        Class var1;
        CGLIB$welcome$0$Method = ReflectUtils.findMethods(new String[]{"welcome", "(Ljava/lang/String;)V"}, (var1 = Class.forName("CglibTest.InfoDemo")).getDeclaredMethods())[0];
        CGLIB$welcome$0$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/String;)V", "welcome", "CGLIB$welcome$0");
        //..........................................省略
     }

     final void CGLIB$welcome$0(String var1) {
        super.welcome(var1);
    }
    //先來判斷這個代理類中是否設定了方法攔截。如果設定了就呼叫該攔截器的intercept方法。
    //在本程式中，我們是設定了攔截器的。enhancer.setCallback(this);
    public final void welcome(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$welcome$0$Method, new Object[]{var1}, CGLIB$welcome$0$Proxy);
        } else {
            super.welcome(var1);
        }
    }
    //..........................................省略
}

在這個代理類中，這裡有兩點需要注意。
1.它會將父類中的每一個方法，生成兩個與之對應。如父類中的welcome，在代理類中就會有CGLIBwelcome$welcome$0，welcome的兩個方法與之對應。
2.每一個方法都會靜態塊中，經過MethodProxy.create生成對應的方法代理。如
MethodProxy.create(var1, var0, "(Ljava/lang/String;)V", "welcome", "CGLIB$welcome$0");

當main函式執行到instance.welcome(“zhangsan”);這個語句時，會進入到代理類中的public final void welcome(String var1) 方法。進而執行了var10000.intercept（）方法。
根據CglibInfoProxy中的intercept，先是會輸出一句“before method!!!”，然後呼叫methodProxy.invokeSuper(o, objects);
這裡的methodProxy對應的是var10000.intercept(this, CGLIB$welcome$0$Method, new Object[]{var1}, CGLIB$welcome$0$Proxy)中的CGLIB$welcome$0$Proxy。

那麼就相當於執行CGLIB$welcome$0$Proxy.invokeSuper(o, objects)，那麼來看看invokeSuper在做什麼。

MethodProxy 原始碼分析

public class MethodProxy {
    //下面的前三個變數在create方法中，都已經得到了初始值了。
    private Signature sig1;
    private Signature sig2;
    private MethodProxy.CreateInfo createInfo;
    //FastClassInfo是在呼叫methodProxy.invoke或者methodProxy.invokeSuper中，init()會觸發，後面再來細看這個。
    private volatile MethodProxy.FastClassInfo fastClassInfo;

    public Object invokeSuper(Object obj, Object[] args) throws Throwable {
        try {
            this.init();
            MethodProxy.FastClassInfo fci = this.fastClassInfo;
            return fci.f2.invoke(fci.i2, obj, args);
        } catch (InvocationTargetException var4) {
            throw var4.getTargetException();
        }
    }
    public Object invoke(Object obj, Object[] args) throws Throwable {
        try {
            this.init();
            MethodProxy.FastClassInfo fci = this.fastClassInfo;
            return fci.f1.invoke(fci.i1, obj, args);
        } catch (InvocationTargetException var4) {
            throw var4.getTargetException();
        } catch (IllegalArgumentException var5) {
            if(this.fastClassInfo.i1 < 0) {
                throw new IllegalArgumentException("Protected method: " + this.sig1);
            } else {
                throw var5;
            }
        }
    }
    //本質就是要生成一個fastClassInfo,fastClassInfo裡面存放著兩個fastclass，f1,f2。
    //還有兩個方法索引的值i1,i2。
    private void init() {
        if(this.fastClassInfo == null) {
            Object var1 = this.initLock;
            synchronized(this.initLock) {
                if(this.fastClassInfo == null) {
                    MethodProxy.CreateInfo ci = this.createInfo;
                    MethodProxy.FastClassInfo fci = new MethodProxy.FastClassInfo();
                    //難道每一個方法，我們都去生成一個fastclass嗎？
                    //不是的，每一個方法的fastclass都是一樣的，只不過他們的i1,i2不一樣。如果快取中就取出，沒有就生成新的FastClass
                    fci.f1 = helper(ci, ci.c1);
                    fci.f2 = helper(ci, ci.c2);
                    fci.i1 = fci.f1.getIndex(this.sig1);
                    fci.i2 = fci.f2.getIndex(this.sig2);
                    this.fastClassInfo = fci;
                    this.createInfo = null;
                }
            }
        }
    }
//根據一個類的資訊，返回的該物件的一個Fastclass
    private static FastClass helper(MethodProxy.CreateInfo ci, Class type) {
        Generator g = new Generator();
        g.setType(type);
        g.setClassLoader(ci.c2.getClassLoader());
        g.setNamingPolicy(ci.namingPolicy);
        g.setStrategy(ci.strategy);
        g.setAttemptLoad(ci.attemptLoad);
        return g.create();
    }
}

fci.f2.invoke(fci.i2, obj, args);fci存放了兩個類的fastClass。
其中f1是被代理的類對應的是InfoDemo$$FastClassByCGLIB$$f4c7f3ac.class，
f2InfoDemo$$EnhancerByCGLIB$$8b8da05b$$FastClassByCGLIB$$9065a6c.class
這也就是為什麼，在classes檔案中會生成三個class檔案了，一個代理類，兩個fastclass.
f2.invoke，那就說明會呼叫InfoDemo$$EnhancerByCGLIB$$8b8da05b$$FastClassByCGLIB$$9065a6c這個類的方法。

代理類的FastClass

那再看看代理類的fastClass的位元組碼長啥樣
貼出InfoDemo$$EnhancerByCGLIB$$8b8da05b$$FastClassByCGLIB$$9065a6c的部分位元組碼：

public class InfoDemo$$EnhancerByCGLIB$$8b8da05b$$FastClassByCGLIB$$9065a6c extends FastClass {

        public InfoDemo$$EnhancerByCGLIB$$8b8da05b$$FastClassByCGLIB$$9065a6c(Class var1) {
            super(var1);
        }
        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 12;
                }
                break;
            case -1725733088:
                if(var10000.equals("getClass()Ljava/lang/Class;")) {
                    return 24;
                }
            case 1013143764:
                if(var10000.equals("CGLIB$welcome$0(Ljava/lang/String;)V")) {
                    return 17;
                }
            }
            //----省略
        }

        public Object invoke(int var1, Object var2, Object[] var3) throws InvocationTargetException {
            8b8da05b var10000 = (8b8da05b)var2;
            int var10001 = var1;

            try {
                switch(var10001) {
                case 0:
                    return var10000.toString();
                case 1:
                    return new Integer(var10000.hashCode());

                case 17:
                    var10000.CGLIB$welcome$0((String)var3[0]);
                }
                //----省略
            }
        }
    }

可以看到，會執行到voke方法中的
var10000.CGLIB$welcome$0((String)var3[0]);，而CGLIB$welcome$0其實就是直接呼叫了super.welcome(var1)的方法。輸出結束之後就會執行完畢。

那麼，如果現在呼叫的是methodProxy.invoke(o, objects);而不是invokeSuper會是怎麼樣的情況呢？
通過上面MethodProxy的原始碼，可以看到當執行invoke的時候會執行到fci.f1.invoke(fci.i1, obj, args);
即會呼叫被代理類的fastclass，InfoDemo$$FastClassByCGLIB$$f4c7f3ac.class中的invoke。
開啟該class檔案我們會發現，執行的的是welcome()。

public Object invoke(Object obj, Object[] args) throws Throwable {
        try {
                switch(var10001) {
                case 0:
                    var10000.welcome((String)var3[0]);
                    return null;
                case 1:
                }
        }

那不就是和在main函式中instance.welcome(“zhangsan”)一樣的步驟了嘛，就會又開始迴圈呼叫，一直到棧溢位報錯。所以，invoke會造成OOM的問題。