spring——Java Proxy和Cglib两种方式方法嵌套调用时代理对象行为分析

spring——Java Proxy和Cglib两种方式方法嵌套调用代理失效分析

主要分析在方法嵌套调用的时候，两种代理方式的不同的反应，此文是上一篇 Spring——配置类解析过程 配置 衍生物。此文不是Java proxy和Cglib使用的说明文。

当然，文章的开始也是得从例子开始。

文章的开始建议先读

Jdk动态代理分析

例子

接口：

public interface Action {
	String run(String name);
}

实现类

public class TestBean implements Action{
	@Override
	public String run(String name) {
		System.out.println("TestBean.run");
		return this.getClass().getName() + ":" + name;
	}
}

下面就从这个例子来开始分析。

Java Proxy

关于java实现代理的方式之前已经说了。先展示demo

public class ProxyAnalysis {
    public static void main(String[] args) {
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true"); // 添加这个能保存生成的class对象，   
       // 生成代理对象
        Action action = (Action) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                new Class<?>[]{Action.class}, new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println(proxy.getClass().getName());
                        return null;
                    }
                });
        System.out.println(action.run("s"));
    }
}

结果是：

在看生成的代理类是一个什么样子

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.sun.proxy;

import com.lc.cglib.Action;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements Action {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String run(String var1) throws  {
        try {
            return (String)super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("com.lc.cglib.Action").getMethod("run", Class.forName("java.lang.String"));
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

可以看到，生成的代理类继承了Proxy，并且实现要实现的接口，所以，在上面的demo中，我们才能强转成功。并且，在调用接口的方法的时候会直接调用InvocationHandle，将this，和之前保存好的Method，还有调用这个方法传递的参数，传递过去。这就是Java Proxy的实现方式。

但是，上面的例子没有反应出来代理经典的形式，目标方法前和后都来做操作，看看下面的写法。

红色框为新增代码和结果。先确定代理的目标（TestBean），在调用的时候调用代理目标的方法（method.invoke(testBean,args)），在此基础上，在前和后做操作。这是标准的写法，这种写法没有问题。

但有一个疑问，invoke方法里面的proxy是干啥的？如果是下面的这种写法会是什么样子

直接栈溢出了，invoke方法里面的proxy就是代理对象，想想上面的代理对象的字节码。传递的就是this对象。这个方法调用，会一直嵌套下去，从而导致栈溢出。那如果直接是 System.out.println(proxy);呢？

也会栈溢出，为什么？因为代理类重写了Object的toString方法，于此同时他还重写了hashCode，equals方法。

也就是说，通过Java proxy生成的代理对象其实和被代理的对象的关系就如下面的类图所示

TestBean和Proxy0都是Action的实现类，两者是通过ProxyAnalysis关联起来的。如果不是ProxyAnalysis，这两者就没有啥直接的关系。

现在开始看方法嵌套调用

如果现接口添加了一个jump()方法，TestBean和Proxy0都会对应的实现。现在在TestBean里面。run方法调用了jump方法。然后现在按照上面说的正确的创建代理对象的方式，并且在invoke方法里面也调用了TestBean方法。这个时候会有两次调用到代理对象吗？

首先，run方法肯定是调用到了，这个在之前已经分析了，现在是run方法里面的jump方法会调用到吗？不会，肯定不会，因为自从调用了run方法之后，下面的执行就都是发生在TestBean里面的了，和代理对象没有一点点的关系。

Cglib Proxy

众所周知，cglib是通过继承的方式来实现的代理的效果的。因为是通过继承，所以才有后面的MethodProxy，可以调用父类的方法。那它能不能像上面那种方式来调用呢？intercept里面的o是干啥的？method就是方法，Objects就是参数，后面的MethodProxy是干啥的？

栈溢出，因为生成的代理类也是重写了那几个方法。System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "");指定生成的class保存的地址。看看生成的代理类,这代理类的代码比较多，这里只看一些关键的代码

 public final String run(String var1) {
        // 这就是Enhancer创建的时候设置的MethodInterceptor。
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }
       // 直接调用，这里的思想和java 的proxy是一样的。
        return var10000 != null ? (String)var10000.intercept(this, CGLIB$run$0$Method, new Object[]{var1}, CGLIB$run$0$Proxy) : super.run(var1);
    }

可以看到，intercept方法里面，第一个参数也是this对象。第二个为Method对象，第三个为方法的入参，第四个是CGLIB$run$0$Proxy，CGLIB$run$0$Proxy是在哪里设置进来的？

可以看到，每个method都有一个对应的MethodProxy。并且还是静态字段。

这里的代码逻辑详细的我就看不懂了。看不懂了。

回到主体，那么这里的代理对象和被代理对象的关系是什么？

那么在Cglib中，方法的嵌套会怎么样。

TestBean中方法嵌套调用，

结果可以看到，调用了两次begin，最后的null是因为我返回了一个null。

方法的嵌套调用不会让代理失效，两次都调用到了。为什么？

分析Cglib代理没有失效的原因

首先继承类和被继承的类之间是泛化关系，在调用run的时候，会调用到intercept方法里面，在intercept里面调用父类方法，会调用到TestBean里面，在TestBean的run方法里面调用jump，会调用到代理类的jump方法上面，（代理类是被代理类的子类，enhancer.create()返回的代理类，一开始调用test,run是从代理类开始的，也就是子类)。因为子类重写了父类的方法，这个时候，在run里面调用jump会调用到子类的jump里面。

只要到子类的jump，就会走到intercept里面，在这里面继续调用父类，就调用到了TestBean中的jump方法。这就是没有实现的原因。这种方式让我想到了里式替换。

结尾

基于上面的分析，我觉得这才是Java Proxy和Cglib Proxy的最大的不同，当然还有别的，比如可以使用MethodFilter来觉得到底用哪个MethodCallBack等等。但是我觉得最大的就是这个，cglib的代理不会使一个对象内，方法嵌套的调用。从而导致代理操作失效。利用了多态机制。

到此，结束了。

关于博客这件事，我是把它当做我的笔记，里面有很多的内容反映了我思考的过程，因为思维有限，不免有些内容有出入，如果有问题，欢迎指出。一同探讨。谢谢。