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 0 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的代理不会使一个对象内，方法嵌套的调用。从而导致代理操作失效。利用了多态机制。
到此，结束了。
关于博客这件事，我是把它当做我的笔记，里面有很多的内容反映了我思考的过程，因为思维有限，不免有些内容有出入，如果有问题，欢迎指出。一同探讨。谢谢。
原文地址：
https://blog.csdn.net/daliucheng/article/details/121737934