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 0 0Proxy是在哪里设置进来的?

在这里插入图片描述

可以看到,每个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的代理不会使一个对象内,方法嵌套的调用。从而导致代理操作失效。利用了多态机制。

到此,结束了。

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

  • 6
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值