jdk 代理 和 cglib 代理深度分析

最新推荐文章于 2022-08-08 14:50:37 发布
最新推荐文章于 2022-08-08 14:50:37 发布
阅读量237 收藏
点赞数
分类专栏： java 文章标签：  jdk代理 cglib 深度分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wcch2308/article/details/79810103
版权 
参考 http://lrd.ele.me/2017/01/09/dynamic_proxy/
jdk 代理
rem  target 实例化的对象

--> Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
	--> Class<?> cl = getProxyClass0(loader, intfs);  // intfs 对象接口
	重点 :
		--> return proxyClassCache.get(loader, interfaces);  // proxyClassCache 缓存
			-->  Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter)); // 获取subkey   [KeyFactory类型] subKeyFactory
				--> Supplier<V> supplier = valuesMap.get(subKey); value 域  <ProxyClassFactory> 类型  supplier.apply() == ProxyClassFactory.apply()
				 		--> Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
				 			//Verify that the class loader resolves the name of this interface to the same Class object.
				 			//Verify that the Class object actually represents an interface.
				 			//Verify that this interface is not a duplicate.
				 		--> interfaceClass = Class.forName(intf.getName(), false, loader);  // 逐个遍历 interfaces  
				 		--> long num = nextUniqueNumber.getAndIncrement();
            			--> String proxyName = proxyPkg + proxyClassNamePrefix + num; //生成名称
            			--> byte[] proxyClassFile = ProxyGenerator.generateProxyClass( proxyName, interfaces, accessFlags); // 生成classbyte  [核心]
            			--> return defineClass0(loader, proxyName,  proxyClassFile, 0, proxyClassFile.length); //定义类
				--> factory = new Factory(key, parameter, subKey, valuesMap);// valueFactory 即 valuesMap 中 value 的封装          			
	--> final Constructor<?> cons = cl.getConstructor(constructorParams);
    --> final InvocationHandler ih = h;
    --> return cons.newInstance(new Object[]{h});



   --------------------------------------------
   生成$Proxy0 class 反编译

    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("BookFacade").getMethod("addBook");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
    生成的方法
      public final void addBook() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

   jdk proxy的调用是一个反射调用的过程
cglib 动态代理的实现分析



代理类继承自org.springframework.cglib.proxy.MethodInterceptor  实现intercept方法
关键代码 :: 	
	Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(this.target.getClass()); // 将接口直接设置成BookFacadeProxyCglib 实现类
    // 回调方法 
    // enhancer.setCallbackType(this.getClass()); 
    enhancer.setCallback(this);     //设置回调
    // 创建代理对象
    return enhancer.create();  
    --> return this.createHelper(); 
    	-->  this.setNamePrefix(this.superclass.getName());设置NamePrefix 
    	--> return super.create(KEY_FACTORY.newInstance(this.superclass != null ? this.superclass.getName() : null, ReflectUtils.getNames(this.interfaces), this.filter, this.callbackTypes, this.useFactory, this.interceptDuringConstruction, this.serialVersionUID));


    // 代理产生的几个类

    fastclass        --> public class BookFacadeImpl$$EnhancerByCGLIB$$677aba98$$FastClassByCGLIB$$dcb5b9cc extends FastClass 
    class            --> public class BookFacadeImpl$$EnhancerByCGLIB$$677aba98 extends BookFacadeImpl implements Factory 
    keyFactory       --> public class Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8f extends KeyFactory implements EnhancerKey 
    methodwrapperkey --> public class MethodWrapper$MethodWrapperKey$$KeyFactoryByCGLIB$$552be97a extends KeyFactory implements MethodWrapperKey  

    调用路径
    //使用的是这个对象
    --> BookFacadeImpl$$EnhancerByCGLIB$$677aba98 
        |    private boolean CGLIB$BOUND;
        |    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;  //threadlocal 中存放callback
        |    private static final Callback[] CGLIB$STATIC_CALLBACKS;   // static callback
        |    private MethodInterceptor CGLIB$CALLBACK_0;               // 用户自己实现的MethodInterceptor
        |    private static final Method CGLIB$addBook$0$Method;       // 父类中的callback 方法
        |    private static final MethodProxy CGLIB$addBook$0$Proxy;   // 方法代理 MethodProxy 类
        |    private static final Object[] CGLIB$emptyArgs;            // 方法参数
        |    private static final Method CGLIB$finalize$1$Method;
        |    private static final MethodProxy CGLIB$finalize$1$Proxy;
        |    private static final Method CGLIB$equals$2$Method;
        |    private static final MethodProxy CGLIB$equals$2$Proxy;
        |    private static final Method CGLIB$toString$3$Method;
        |    private static final MethodProxy CGLIB$toString$3$Proxy;
        |    private static final Method CGLIB$hashCode$4$Method;
        |    private static final MethodProxy CGLIB$hashCode$4$Proxy;
        |    private static final Method CGLIB$clone$5$Method;
        |    private static final MethodProxy CGLIB$clone$5$Proxy;
        |    
        |    static void CGLIB$STATICHOOK1() {
        |        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        |        CGLIB$emptyArgs = new Object[0];
        |        Class var0 = Class.forName("BookFacadeImpl$$EnhancerByCGLIB$$677aba98"); //当前类的实例
        |        Class var1;
        |        Method[] var10000 = ReflectUtils.findMethods(new String[]{"finalize", "()V", "equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
        |        CGLIB$finalize$1$Method = var10000[0];
        |        CGLIB$finalize$1$Proxy = MethodProxy.create(var1, var0, "()V", "finalize", "CGLIB$finalize$1");
        |        CGLIB$equals$2$Method = var10000[1];
        |        CGLIB$equals$2$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$2");
        |        CGLIB$toString$3$Method = var10000[2];
        |        CGLIB$toString$3$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$3");
        |        CGLIB$hashCode$4$Method = var10000[3];
        |        CGLIB$hashCode$4$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$4");
        |        CGLIB$clone$5$Method = var10000[4];
        |        CGLIB$clone$5$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$5");
                 // var1 赋值
        |        CGLIB$addBook$0$Method = ReflectUtils.findMethods(new String[]{"addBook", "()V"}, (var1 = Class.forName("BookFacadeImpl")).getDeclaredMethods())[0];
        |        CGLIB$addBook$0$Proxy = MethodProxy.create(var1, var0, "()V", "addBook", "CGLIB$addBook$0");
        |    }
    --> addBook()
        --> 
            -->| public final void addBook() {
            -->|     MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;//获取当前类中的methodintercepter
            -->|     if (this.CGLIB$CALLBACK_0 == null) {
            -->|         CGLIB$BIND_CALLBACKS(this);                //如果为空
            -->|         var10000 = this.CGLIB$CALLBACK_0;
            -->|     }
            -->| 
            -->|     if (var10000 != null) {
                         // 执行MethodInterceptor 类中的方法 <实现了MethodInterceptor的类> -->  
            -->|         var10000.intercept(this, CGLIB$addBook$0$Method, CGLIB$emptyArgs, CGLIB$addBook$0$Proxy); 
            -->|     } else {
            -->|         super.addBook();
            -->|     }
            -->| }

            -->| private static final void CGLIB$BIND_CALLBACKS(Object var0) {
            -->|     BookFacadeImpl$$EnhancerByCGLIB$$677aba98 var1 = (BookFacadeImpl$$EnhancerByCGLIB$$677aba98)var0;
            -->|     if (!var1.CGLIB$BOUND) {
            -->|         var1.CGLIB$BOUND = true;
            -->|         Object var10000 = CGLIB$THREAD_CALLBACKS.get();
            -->|         if (var10000 == null) {
            -->|             var10000 = CGLIB$STATIC_CALLBACKS;
            -->|             if (CGLIB$STATIC_CALLBACKS == null) {
            -->|                 return;
            -->|             }
            -->|        }
            -->|        
            -->|         var1.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])var10000)[0];
            -->|     }
            -->|     
            -->| }

            实现了 MethodInterceptor的类
            -->|>|public class BookFacadeProxyCglib implements MethodInterceptor {
            -->|>|    private Object target;
            -->|>|
            -->|>|    public Object getInstance(Object target) {
            -->|>|        this.target = target;
            -->|>|        Enhancer enhancer = new Enhancer();
            -->|>|        enhancer.setSuperclass(this.target.getClass());
            -->|>|        // 回调方法
            -->|>|        // enhancer.setCallbackType(this.getClass());
            -->|>|        enhancer.setCallback(this);
            -->|>|        // 创建代理对象
            -->|>|        return enhancer.create();
            -->|>|    }
            -->|>|    
            -->|>|    @Override
            -->|>|    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
            -->|>|        System.out.println("before run!");
                          // 执行MethodProxy的invokeSuper
            -->|>|        proxy.invokeSuper(obj, args);
            -->|>|        System.out.println("after run!");
            -->|>|        return null;
            -->|>|    }
            -->|>|}

            MethodProxy的invokeSuper 方法
            -->| public Object invokeSuper(Object obj, Object[] args) throws Throwable {
            -->|     try {
            -->|         this.init();

                        ------> | private void init() {
                        ------> |     if (this.fastClassInfo == null) {
                        ------> |         Object var1 = this.initLock;
                        ------> |         synchronized(this.initLock) {
                        ------> |             if (this.fastClassInfo == null) {
                        ------> |                 MethodProxy.CreateInfo ci = this.createInfo;
                        ----------------------- 对应  --> CGLIB$addBook$0$Proxy = MethodProxy.create(var1, var0, "()V", "addBook", "CGLIB$addBook$0");
                        MethodProxy 中的变量赋值
                        [ c1 = var1 = BookFacadeImpl                            ]  
                        [ c2 = var0 = BookFacadeImpl$$EnhancerByCGLIB$$677aba98 ]
                        [ name1 = addBook         = new Signature(name1, desc); ]
                        [ name2 = CGLIB$addBook$0 = new Signature(name2, desc); ]
                                            --> | public static MethodProxy create(Class c1, Class c2, String desc, String name1, String name2) {
                                            --> |     MethodProxy proxy = new MethodProxy();
                                            --> |     proxy.sig1 = new Signature(name1, desc);
                                            --> |     proxy.sig2 = new Signature(name2, desc);
                                            --> |     proxy.createInfo = new MethodProxy.CreateInfo(c1, c2);
                                            --> |     return proxy;
                                            --> | }
                        -----------------------
                        ------> |                 MethodProxy.FastClassInfo fci = new MethodProxy.FastClassInfo(); //实例化FastClassInfo
                        ------> |                 fci.f1 = helper(ci, ci.c1);
                        ----------------------------------------------------------------------------------------------------------------------
                                                    ---->| 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();
                                                             >| org.springframework.cglib.core.AbstractClassGenerator#create //最终调用AbstractClassGenerator的create方法
                                                    ---->|   }
                        ----------------------------------------------------------------------------------------------------------------------
                        ------> |                 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;
                        ------> |             }
                        ------> |         }
                        ------> |     }
                        ------> | }
            -->|         MethodProxy.FastClassInfo fci = this.fastClassInfo;
            -->|         return fci.f2.invoke(fci.i2, obj, args);
            -->|     } catch (InvocationTargetException var4) {
            -->|         throw var4.getTargetException();
            -->|     }
            -->| }


wcch2308
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaEE简单示例——CGLib的动态代理的
hssjsh的博客
03-21 348
JavaEE简单示例——CGLib的动态代理的
Spring 框架的 MethodInterceptor 简介
winfield821的博客
09-18 1000
是CGLIB库（Code Generation Library）中的一个接口，用于拦截方法的调用。来创建一个代理对象，将该代理对象应用于目标对象，从而在目标对象的方法调用时触发拦截器中的逻辑。提供了强大的方法拦截和增强能力，常用于创建AOP代理，执行事务管理、性能监控、安全性检查等。接口来创建一个自定义的方法拦截器，并在其中定义希望在方法调用前后执行的逻辑。，该方法在代理对象的方法被调用时被触发。以下是一个简单的示例，演示了如何使用CGLIB的。方法中，可以在方法调用前后添加自定义逻辑。
2020-04-02 spring学习------CGLIB动态代理
hello_yajing的博客
04-10 359
一、CGLibProxy实现MethodInterceptor package test.spring.proxy; import org.springframework.cglib.proxy.Enhancer; import org.springframework.cglib.proxy.MethodInterceptor; import org.springframework.cgli...
CGLIB源码易懂解析
m0_48333563的博客
08-08 1286
博主亲身实践，细嚼慢咽，提供了赌代码方式读代码，通俗易懂。如有指教，敬请提出！！！
Java基础之《cglib动态代理》
csj50的专栏
09-03 347
1、介绍 1）cglib动态代理是一个第三方库 2）既可以代理接口，也可以代理类 3）因为它是动态生成被代理类的子类 4、cglib动态代理和JDK中的动态代理的区别 JDK中所要进行动态代理的类必须要实现一个接口，使用CGLib实现动态代理，完全不受代理类必须实现接口的限制，而且CGLib底层采用ASM字节码生成框架，使用字节码技术生成代理类，比使用Java反射效率要高。唯一需要注意的是，CGLib不能对声明为final的方法进行代理，因为CGLib原理是动态生成被代理类的子类。 5、步骤 第一步：被
Spring重温（八）— — Cglib的类代理
LuckyToMeet-Dian叶
06-05 479
前言：        上一篇文章我们学习了jdk的动态代理。我们知道jdk的动态代理还是很有缺陷的。比如：jdk动态代理如果缺少接口，就不能进行了。这时，就出现了Cglib。cglib的EnHancer字节码增强器。方便为类做增强。        spring底层在调用AOP时，会先判断这个类是否实现了接口，如果有接口就会调用jdk的动态代理，如果没有则用的是Cglib类代理。贴代码。用代码来入门...
动态代理cglibjar包和源码
05-21
动态代理在Java编程中是一种非常重要的技术，它允许我们在不修改...了解并熟练掌握CGLIB的使用和源码分析，有助于提升Java开发的深度和广度。通过深入研究CGLIB的源码，可以更好地理解Java字节码和动态代理的底层机制。
CGLib代理jar包
07-26
CGLib代理是Java中实现动态代理的一种方式，与另一种常用的JDK动态代理相比，CGLib在处理非接口类的代理时具有更高的性能优势。 CGLib的核心是通过ASM库来操作字节码生成新的类，这些新生成的类是对原始类的扩展，...
CGLib和ASM相关jar包
08-07
在Java中，有两种主要的动态代理实现：JDK的java.lang.reflect.Proxy和第三方库如CGLib。JDK的代理机制基于接口，而CGLib则通过继承实现，因此对于未实现接口的类，CGLib是更好的选择。 在实际项目中，CGLib常被...
Spring AOP源码深度解析：掌握Java高级编程核心技术
最新发布
12-13
**动态代理**是AOP的基础，Spring支持两种动态代理方式：JDK动态代理和CGLIB代理。JDK动态代理适用于目标对象实现了接口的情况，它通过反射机制创建代理对象；而CGLIB则是在目标对象没有接口的情况下，通过继承生成...
asm-cglib开发包
03-04
3. **Callback**: 定义了多种回调接口，如 MethodInterceptor，是CGLIB代理机制的基础。 **动态代理** 动态代理是一种在运行时创建代理对象的技术，它通常用于实现AOP或者为已有接口提供额外的功能。Java标准库...
CGLIB动态代理
缥缈
02-13 201
CGLIB(Code Generation Library)是一个开源项目！是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口。 package cn.cglib.proxy; import java.lang.reflect.Method; import org.springframework.cglib.proxy.Enhancer; imp...
cglib动态代理分析
ranxiaochuan1994的博客
04-06 465
cglib动态代理原理代理对象源码分析 #cglib动态代理使用流程 创建被代理对象 public class UserService { public void say(){ System.out.println("我是一位用户"); } } 实现MethodInterceptor接口，在接口方法中增强被代理方法的功能： public class My...
多种代码生成炫酷代码雨（推荐）
热门推荐
王大师企业官方博客
09-08 2万+
三种代码生成代码雨 本人主页 文章目录三种代码生成代码雨一、html代码雨效果图：代码块二、vb代码雨效果图：代码块三、bat代码雨效果图：代码块 一、html代码雨 效果图： 代码块 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Code</title> <style> body{
python 输出文件中返回码为200的接口的平均响应时间_将一个接口响应时间从2s优化到 200ms以内的一个案例...
weixin_39820185的博客
12-13 321
一、背景在开发联调阶段发现一个接口的响应时间特别长，经常超时，囧…本文讲讲是如何定位到性能瓶颈以及修改的思路，将该接口从 2 s 左右优化到 200ms 以内 。二、步骤2.1 定位定位性能瓶颈有两个思路，一个是通过工具去监控，一个是通过经验去猜想。2.1.1 工具监控就工具而言，推荐使用 arthas ，用到的是 trace 命令具体安装步骤很简单，大家自行研究。我的使用步骤是，先最终待研究的函...
阿里Arthas(阿尔赛斯)-trace查看方法内部调用路径及耗时
SimpleSimpleSimples的博客
05-15 4732
1.trace用法 2.方法内部调用路径，并输出方法路径上的每个节点上耗时 2.1追踪测试controller [arthas@243829]$ trace com.ztesoft.bss.smart.controller.smartview.InjectionLabelSvController selectInjectionLabelByQo Press Q or Ctrl+C to abort. Affect(class count: 1 , method count: 1) cost in 73
Spring之代理学习
wuqihawubito的博客
07-14 187
文章目录代理模式动态代理： 代理模式 要学习动态代理，那么必须要知道代理模式。 代理，现在的房地产中介就是一种代理，如果没有中介，那么房主和买主之间就是付房款，那么多了代理（中介），中介就多做了一些功能，比如收中介费。 代理最终要将请求（买房需要）转发给真正的被访问者（房主），它可以在转发请求之前或之后加入特定的逻辑（收中介费） 实例： public interface owner { public int sell_house(); } public class ownerimpl imp
cglib源码分析（四）：cglib 动态代理原理分析
z69183787的专栏
06-20 950
本文分下面三个部分来分析cglib动态代理的原理。 cglib动态代理示例 代理类分析 Fastclass 机制分析 一、cglib 动态代理示例 1 public class Target{ 2 public void f(){ 3 System.out.println("Target f()"); 4 } 5 public void g(){ 6 System.out.println("Target g()"); 7...
江神JAVA开发面经超级总结
08-28
"这是对JAVA开发面试经验的深度总结，涵盖了JDK代理、CGlib代理、数据库范式、网络协议、HTTP连接类型、JAVA内存模型、JVM垃圾回收、数据库优化等多个核心知识点。" 在JAVA开发中，JDK代理和CGlib代理是两种常见的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值