Cglib源码分析 invoke和invokeSuper的差别

小鱼儿 2021-06-22 15:38 398阅读 0赞

### 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，在代理类中就会有CGLIBwelcomewelcome0，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();
        }
    }

init()的过程就是生成FastClassInfo。  
对于FastClass可以看看这篇文章[https://www.cnblogs.com/cruze/p/3865180.html][https_www.cnblogs.com_cruze_p_3865180.html]

fci.f2.invoke(fci.i2, obj, args);fci存放了两个类的fastClass。  
其中f1是被代理的类对应的是`InfoDemo$$FastClassByCGLIB$$f4c7f3ac.class，`  
f2`InfoDemo$$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的问题。

[https_www.cnblogs.com_cruze_p_3865180.html]: https://www.cnblogs.com/cruze/p/3865180.html