爆款云主机2核4G限时秒杀,88元/年起!
查看详情

活动

天翼云最新优惠活动,涵盖免费试用,产品折扣等,助您降本增效!
热门活动
  • 618智算钜惠季 爆款云主机2核4G限时秒杀,88元/年起!
  • 免费体验DeepSeek,上天翼云息壤 NEW 新老用户均可免费体验2500万Tokens,限时两周
  • 云上钜惠 HOT 爆款云主机全场特惠,更有万元锦鲤券等你来领!
  • 算力套餐 HOT 让算力触手可及
  • 天翼云脑AOne NEW 连接、保护、办公,All-in-One!
  • 中小企业应用上云专场 产品组合下单即享折上9折起,助力企业快速上云
  • 息壤高校钜惠活动 NEW 天翼云息壤杯高校AI大赛,数款产品享受线上订购超值特惠
  • 天翼云电脑专场 HOT 移动办公新选择,爆款4核8G畅享1年3.5折起,快来抢购!
  • 天翼云奖励推广计划 加入成为云推官,推荐新用户注册下单得现金奖励
免费活动
  • 免费试用中心 HOT 多款云产品免费试用,快来开启云上之旅
  • 天翼云用户体验官 NEW 您的洞察,重塑科技边界

智算服务

打造统一的产品能力,实现算网调度、训练推理、技术架构、资源管理一体化智算服务
智算云(DeepSeek专区)
科研助手
  • 算力商城
  • 应用商城
  • 开发机
  • 并行计算
算力互联调度平台
  • 应用市场
  • 算力市场
  • 算力调度推荐
一站式智算服务平台
  • 模型广场
  • 体验中心
  • 服务接入
智算一体机
  • 智算一体机
大模型
  • DeepSeek-R1-昇腾版(671B)
  • DeepSeek-R1-英伟达版(671B)
  • DeepSeek-V3-昇腾版(671B)
  • DeepSeek-R1-Distill-Llama-70B
  • DeepSeek-R1-Distill-Qwen-32B
  • Qwen2-72B-Instruct
  • StableDiffusion-V2.1
  • TeleChat-12B

应用商城

天翼云精选行业优秀合作伙伴及千余款商品,提供一站式云上应用服务
进入甄选商城进入云市场创新解决方案
办公协同
  • WPS云文档
  • 安全邮箱
  • EMM手机管家
  • 智能商业平台
财务管理
  • 工资条
  • 税务风控云
企业应用
  • 翼信息化运维服务
  • 翼视频云归档解决方案
工业能源
  • 智慧工厂_生产流程管理解决方案
  • 智慧工地
建站工具
  • SSL证书
  • 新域名服务
网络工具
  • 翼云加速
灾备迁移
  • 云管家2.0
  • 翼备份
资源管理
  • 全栈混合云敏捷版(软件)
  • 全栈混合云敏捷版(一体机)
行业应用
  • 翼电子教室
  • 翼智慧显示一体化解决方案

合作伙伴

天翼云携手合作伙伴,共创云上生态,合作共赢
天翼云生态合作中心
  • 天翼云生态合作中心
天翼云渠道合作伙伴
  • 天翼云代理渠道合作伙伴
天翼云服务合作伙伴
  • 天翼云集成商交付能力认证
天翼云应用合作伙伴
  • 天翼云云市场合作伙伴
  • 天翼云甄选商城合作伙伴
天翼云技术合作伙伴
  • 天翼云OpenAPI中心
  • 天翼云EasyCoding平台
天翼云培训认证
  • 天翼云学堂
  • 天翼云市场商学院
天翼云合作计划
  • 云汇计划
天翼云东升计划
  • 适配中心
  • 东升计划
  • 适配互认证

开发者

开发者相关功能入口汇聚
技术社区
  • 专栏文章
  • 互动问答
  • 技术视频
资源与工具
  • OpenAPI中心
开放能力
  • EasyCoding敏捷开发平台
培训与认证
  • 天翼云学堂
  • 天翼云认证
魔乐社区
  • 魔乐社区

支持与服务

为您提供全方位支持与服务,全流程技术保障,助您轻松上云,安全无忧
文档与工具
  • 文档中心
  • 新手上云
  • 自助服务
  • OpenAPI中心
定价
  • 价格计算器
  • 定价策略
基础服务
  • 售前咨询
  • 在线支持
  • 在线支持
  • 工单服务
  • 建议与反馈
  • 用户体验官
  • 服务保障
  • 客户公告
  • 会员中心
增值服务
  • 红心服务
  • 首保服务
  • 客户支持计划
  • 专家技术服务
  • 备案管家

了解天翼云

天翼云秉承央企使命,致力于成为数字经济主力军,投身科技强国伟大事业,为用户提供安全、普惠云服务
品牌介绍
  • 关于天翼云
  • 智算云
  • 天翼云4.0
  • 新闻资讯
  • 天翼云APP
基础设施
  • 全球基础设施
  • 信任中心
最佳实践
  • 精选案例
  • 超级探访
  • 云杂志
  • 分析师和白皮书
  • 天翼云·创新直播间
市场活动
  • 2025智能云生态大会
  • 2024智算云生态大会
  • 2023云生态大会
  • 2022云生态大会
  • 天翼云中国行
天翼云
  • 活动
  • 智算服务
  • 产品
  • 解决方案
  • 应用商城
  • 合作伙伴
  • 开发者
  • 支持与服务
  • 了解天翼云
      • 文档
      • 控制中心
      • 备案
      • 管理中心

      Cglib动态代理

      首页 知识中心 其他 文章详情页

      Cglib动态代理

      2024-06-03 09:11:00 阅读次数:44

      CGLIB 通过动态生成一个需要被代理类的子类(即被代理类作为父类),该子类重写被代理类的所有不是 final 修饰的方法,并在子类中采用方法拦截的技术拦截父类所有的方法调用,进而织入横切逻辑。此外,因为 CGLIB 采用整型变量建立了方法索引,这比使用 JDK 动态代理更快(使用 Java 反射技术创建代理类的实例)。

      1、需要被代理的类

      package com.example.cglib.mapper.impl;
      
      public class CglibProxyUserMapperImpl {
      
          public void print() {
              System.out.println("com.example.mapper.impl.CglibProxyUserMapperImpl.print ---> ");
          }
      
      }
      
      /*
      	注意:
      		要被CGLIB动态代理的类不需要 加注解 或 实现接口
      */

      2、MethodInterceptor实现类

      package com.example.cglib.interceptors;
      
      import org.springframework.cglib.proxy.MethodInterceptor;
      import org.springframework.cglib.proxy.MethodProxy;
      
      import java.lang.reflect.Method;
      
      public class MyMethodInterceptor implements MethodInterceptor {
      
          @Override
          public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
              System.out.println("com.example.interceptors.MyMethodInterceptor.intercept");
              return methodProxy.invokeSuper(o, objects);
          }
      }
      
      /*
      	MethodInterceptor 是 org.springframework.cglib.proxy 包下的
      	
      	1)o:表示增强的对象,即实现这个接口类的一个对象;
      	2)method:表示要被拦截的方法;
      	3)objects:表示要被拦截方法的参数;
      	4)methodProxy:表示要触发父类的方法对象。
      */

      3、测试类

      package com.example.cglib.test;
      
      import com.example.cglib.interceptors.MyMethodInterceptor;
      import com.example.cglib.mapper.impl.CglibProxyUserMapperImpl;
      import org.springframework.cglib.core.DebuggingClassWriter;
      import org.springframework.cglib.proxy.Enhancer;
      
      public class Test {
          public static void main(String[] args) {
              // 代理类class文件存入本地磁盘方便我们反编译查看源码
              System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "E:/_temp/cglibCode");
              
              // 通过CGLIB动态代理获取代理对象的过程
              Enhancer enhancer = new Enhancer();
              // 设置enhancer对象的父类
              enhancer.setSuperclass(CglibProxyUserMapperImpl.class);
              // 设置enhancer对象的回调对象
              enhancer.setCallback(new MyMethodInterceptor());
              // 创建代理对象
              CglibProxyUserMapperImpl cglibProxyUserMapper = (CglibProxyUserMapperImpl) enhancer.create();
              // 通过代理对象调用目标方法
              cglibProxyUserMapper.print();
          }
      }

      4、控制台输出

      CGLIB debugging enabled, writing to 'E:/_temp/cglibCode'
      com.example.interceptors.MyMethodInterceptor.intercept
      com.example.mapper.impl.CglibProxyUserMapperImpl.print --->

      5、生成的代理类(扩展)

      当前代码为 org.springframework.cglib.proxy.MethodProxy#invokeSuper 中的代码
      // 某个方法
      public Object invokeSuper(Object obj, Object[] args) throws Throwable {
      		try {
      			init();
      			FastClassInfo fci = fastClassInfo;
      			return fci.f2.invoke(fci.i2, obj, args);
      		}
      		catch (InvocationTargetException e) {
      			throw e.getTargetException();
      		}
      }
      
      
          可断点调试 MethodProxy 类中的 fci.f2.invoke(fci.i2, obj, args);
      然后观察 fci.i2 的取值,通过该取值去下方的 CglibProxyUserMapperImpl$$EnhancerByCGLIB$$2a1a85db$$FastClassByCGLIB$$cac95a8 类
      中寻找对应的 case 分支。
      	若取值19(可在当前页面搜索"19:"),则调用 var10000.CGLIB$print$0(); 而 CGLIB$print$0() 该方法也可在下方的
      CglibProxyUserMapperImpl$$EnhancerByCGLIB$$2a1a85db 中找到,即会调用 super.print(); 也就是被代理类的 print() 方法
      //
      // Source code recreated from a .class file by IntelliJ IDEA
      // (powered by FernFlower decompiler)
      //
      
      package com.example.cglib.mapper.impl;
      
      import java.lang.reflect.Method;
      import org.springframework.cglib.core.ReflectUtils;
      import org.springframework.cglib.core.Signature;
      import org.springframework.cglib.proxy.Callback;
      import org.springframework.cglib.proxy.Factory;
      import org.springframework.cglib.proxy.MethodInterceptor;
      import org.springframework.cglib.proxy.MethodProxy;
      
      public class CglibProxyUserMapperImpl$$EnhancerByCGLIB$$2a1a85db extends CglibProxyUserMapperImpl implements Factory {
          private boolean CGLIB$BOUND;
          public static Object CGLIB$FACTORY_DATA;
          private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
          private static final Callback[] CGLIB$STATIC_CALLBACKS;
          private MethodInterceptor CGLIB$CALLBACK_0;
          private static Object CGLIB$CALLBACK_FILTER;
          private static final Method CGLIB$print$0$Method;
          private static final MethodProxy CGLIB$print$0$Proxy;
          private static final Object[] CGLIB$emptyArgs;
          private static final Method CGLIB$equals$1$Method;
          private static final MethodProxy CGLIB$equals$1$Proxy;
          private static final Method CGLIB$toString$2$Method;
          private static final MethodProxy CGLIB$toString$2$Proxy;
          private static final Method CGLIB$hashCode$3$Method;
          private static final MethodProxy CGLIB$hashCode$3$Proxy;
          private static final Method CGLIB$clone$4$Method;
          private static final MethodProxy CGLIB$clone$4$Proxy;
      
          static void CGLIB$STATICHOOK1() {
              CGLIB$THREAD_CALLBACKS = new ThreadLocal();
              CGLIB$emptyArgs = new Object[0];
              Class var0 = Class.forName("com.example.cglib.mapper.impl.CglibProxyUserMapperImpl$$EnhancerByCGLIB$$2a1a85db");
              Class var1;
              Method[] var10000 = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
              CGLIB$equals$1$Method = var10000[0];
              CGLIB$equals$1$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$1");
              CGLIB$toString$2$Method = var10000[1];
              CGLIB$toString$2$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$2");
              CGLIB$hashCode$3$Method = var10000[2];
              CGLIB$hashCode$3$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$3");
              CGLIB$clone$4$Method = var10000[3];
              CGLIB$clone$4$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$4");
              CGLIB$print$0$Method = ReflectUtils.findMethods(new String[]{"print", "()V"}, (var1 = Class.forName("com.example.cglib.mapper.impl.CglibProxyUserMapperImpl")).getDeclaredMethods())[0];
              CGLIB$print$0$Proxy = MethodProxy.create(var1, var0, "()V", "print", "CGLIB$print$0");
          }
      
          final void CGLIB$print$0() {
              super.print();
          }
      
          public final void print() {
              MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
              if (var10000 == null) {
                  CGLIB$BIND_CALLBACKS(this);
                  var10000 = this.CGLIB$CALLBACK_0;
              }
      
              // 若 var10000 不为空,则先调用 MethodInterceptor 方法拦截器
              if (var10000 != null) {
                  var10000.intercept(this, CGLIB$print$0$Method, CGLIB$emptyArgs, CGLIB$print$0$Proxy);
              } else {
                  super.print();
              }
          }
      
          final boolean CGLIB$equals$1(Object var1) {
              return super.equals(var1);
          }
      
          public final boolean equals(Object var1) {
              MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
              if (var10000 == null) {
                  CGLIB$BIND_CALLBACKS(this);
                  var10000 = this.CGLIB$CALLBACK_0;
              }
      
              if (var10000 != null) {
                  Object var2 = var10000.intercept(this, CGLIB$equals$1$Method, new Object[]{var1}, CGLIB$equals$1$Proxy);
                  return var2 == null ? false : (Boolean)var2;
              } else {
                  return super.equals(var1);
              }
          }
      
          final String CGLIB$toString$2() {
              return super.toString();
          }
      
          public final String toString() {
              MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
              if (var10000 == null) {
                  CGLIB$BIND_CALLBACKS(this);
                  var10000 = this.CGLIB$CALLBACK_0;
              }
      
              return var10000 != null ? (String)var10000.intercept(this, CGLIB$toString$2$Method, CGLIB$emptyArgs, CGLIB$toString$2$Proxy) : super.toString();
          }
      
          final int CGLIB$hashCode$3() {
              return super.hashCode();
          }
      
          public final int hashCode() {
              MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
              if (var10000 == null) {
                  CGLIB$BIND_CALLBACKS(this);
                  var10000 = this.CGLIB$CALLBACK_0;
              }
      
              if (var10000 != null) {
                  Object var1 = var10000.intercept(this, CGLIB$hashCode$3$Method, CGLIB$emptyArgs, CGLIB$hashCode$3$Proxy);
                  return var1 == null ? 0 : ((Number)var1).intValue();
              } else {
                  return super.hashCode();
              }
          }
      
          final Object CGLIB$clone$4() throws CloneNotSupportedException {
              return super.clone();
          }
      
          protected final Object clone() throws CloneNotSupportedException {
              MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
              if (var10000 == null) {
                  CGLIB$BIND_CALLBACKS(this);
                  var10000 = this.CGLIB$CALLBACK_0;
              }
      
              return var10000 != null ? var10000.intercept(this, CGLIB$clone$4$Method, CGLIB$emptyArgs, CGLIB$clone$4$Proxy) : super.clone();
          }
      
          public static MethodProxy CGLIB$findMethodProxy(Signature var0) {
              String var10000 = var0.toString();
              switch (var10000.hashCode()) {
                  case -1166389848:
                      if (var10000.equals("print()V")) {
                          return CGLIB$print$0$Proxy;
                      }
                      break;
                  case -508378822:
                      if (var10000.equals("clone()Ljava/lang/Object;")) {
                          return CGLIB$clone$4$Proxy;
                      }
                      break;
                  case 1826985398:
                      if (var10000.equals("equals(Ljava/lang/Object;)Z")) {
                          return CGLIB$equals$1$Proxy;
                      }
                      break;
                  case 1913648695:
                      if (var10000.equals("toString()Ljava/lang/String;")) {
                          return CGLIB$toString$2$Proxy;
                      }
                      break;
                  case 1984935277:
                      if (var10000.equals("hashCode()I")) {
                          return CGLIB$hashCode$3$Proxy;
                      }
              }
      
              return null;
          }
      
          public CglibProxyUserMapperImpl$$EnhancerByCGLIB$$2a1a85db() {
              CGLIB$BIND_CALLBACKS(this);
          }
      
          public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] var0) {
              CGLIB$THREAD_CALLBACKS.set(var0);
          }
      
          public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] var0) {
              CGLIB$STATIC_CALLBACKS = var0;
          }
      
          private static final void CGLIB$BIND_CALLBACKS(Object var0) {
              CglibProxyUserMapperImpl$$EnhancerByCGLIB$$2a1a85db var1 = (CglibProxyUserMapperImpl$$EnhancerByCGLIB$$2a1a85db)var0;
              if (!var1.CGLIB$BOUND) {
                  var1.CGLIB$BOUND = true;
                  Object var10000 = CGLIB$THREAD_CALLBACKS.get();
                  if (var10000 == null) {
                      var10000 = CGLIB$STATIC_CALLBACKS;
                      if (var10000 == null) {
                          return;
                      }
                  }
      
                  var1.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])var10000)[0];
              }
      
          }
      
          public Object newInstance(Callback[] var1) {
              CGLIB$SET_THREAD_CALLBACKS(var1);
              CglibProxyUserMapperImpl$$EnhancerByCGLIB$$2a1a85db var10000 = new CglibProxyUserMapperImpl$$EnhancerByCGLIB$$2a1a85db();
              CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
              return var10000;
          }
      
          public Object newInstance(Callback var1) {
              CGLIB$SET_THREAD_CALLBACKS(new Callback[]{var1});
              CglibProxyUserMapperImpl$$EnhancerByCGLIB$$2a1a85db var10000 = new CglibProxyUserMapperImpl$$EnhancerByCGLIB$$2a1a85db();
              CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
              return var10000;
          }
      
          public Object newInstance(Class[] var1, Object[] var2, Callback[] var3) {
              CGLIB$SET_THREAD_CALLBACKS(var3);
              CglibProxyUserMapperImpl$$EnhancerByCGLIB$$2a1a85db var10000 = new CglibProxyUserMapperImpl$$EnhancerByCGLIB$$2a1a85db;
              switch (var1.length) {
                  case 0:
                      var10000.<init>();
                      CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
                      return var10000;
                  default:
                      throw new IllegalArgumentException("Constructor not found");
              }
          }
      
          public Callback getCallback(int var1) {
              CGLIB$BIND_CALLBACKS(this);
              MethodInterceptor var10000;
              switch (var1) {
                  case 0:
                      var10000 = this.CGLIB$CALLBACK_0;
                      break;
                  default:
                      var10000 = null;
              }
      
              return var10000;
          }
      
          public void setCallback(int var1, Callback var2) {
              switch (var1) {
                  case 0:
                      this.CGLIB$CALLBACK_0 = (MethodInterceptor)var2;
                  default:
              }
          }
      
          public Callback[] getCallbacks() {
              CGLIB$BIND_CALLBACKS(this);
              return new Callback[]{this.CGLIB$CALLBACK_0};
          }
      
          public void setCallbacks(Callback[] var1) {
              this.CGLIB$CALLBACK_0 = (MethodInterceptor)var1[0];
          }
      
          static {
              CGLIB$STATICHOOK1();
          }
      }
      //
      // Source code recreated from a .class file by IntelliJ IDEA
      // (powered by FernFlower decompiler)
      //
      
      package com.example.cglib.mapper.impl;
      
      import com.example.cglib.mapper.impl.CglibProxyUserMapperImpl..EnhancerByCGLIB..2a1a85db;
      import java.lang.reflect.InvocationTargetException;
      import org.springframework.cglib.core.Signature;
      import org.springframework.cglib.proxy.Callback;
      import org.springframework.cglib.reflect.FastClass;
      
      public class CglibProxyUserMapperImpl$$EnhancerByCGLIB$$2a1a85db$$FastClassByCGLIB$$cac95a8 extends FastClass {
          public CglibProxyUserMapperImpl$$EnhancerByCGLIB$$2a1a85db$$FastClassByCGLIB$$cac95a8(Class var1) {
              super(var1);
          }
      
          public int getIndex(Signature var1) {
              String var10000 = var1.toString();
              switch (var10000.hashCode()) {
                  case -1882565338:
                      if (var10000.equals("CGLIB$equals$1(Ljava/lang/Object;)Z")) {
                          return 15;
                      }
                      break;
                  case -1870561232:
                      if (var10000.equals("CGLIB$findMethodProxy(Lorg/springframework/cglib/core/Signature;)Lorg/springframework/cglib/proxy/MethodProxy;")) {
                          return 20;
                      }
                      break;
                  case -1745842178:
                      if (var10000.equals("setCallbacks([Lorg/springframework/cglib/proxy/Callback;)V")) {
                          return 13;
                      }
                      break;
                  case -1641413109:
                      if (var10000.equals("newInstance([Lorg/springframework/cglib/proxy/Callback;)Ljava/lang/Object;")) {
                          return 6;
                      }
                      break;
                  case -1457535688:
                      if (var10000.equals("CGLIB$STATICHOOK1()V")) {
                          return 14;
                      }
                      break;
                  case -1411842725:
                      if (var10000.equals("CGLIB$hashCode$3()I")) {
                          return 18;
                      }
                      break;
                  case -1166389848:
                      if (var10000.equals("print()V")) {
                          return 7;
                      }
                      break;
                  case -1034266769:
                      if (var10000.equals("CGLIB$SET_STATIC_CALLBACKS([Lorg/springframework/cglib/proxy/Callback;)V")) {
                          return 12;
                      }
                      break;
                  case -1025895669:
                      if (var10000.equals("CGLIB$SET_THREAD_CALLBACKS([Lorg/springframework/cglib/proxy/Callback;)V")) {
                          return 11;
                      }
                      break;
                  case -988317324:
                      if (var10000.equals("newInstance([Ljava/lang/Class;[Ljava/lang/Object;[Lorg/springframework/cglib/proxy/Callback;)Ljava/lang/Object;")) {
                          return 4;
                      }
                      break;
                  case -508378822:
                      if (var10000.equals("clone()Ljava/lang/Object;")) {
                          return 3;
                      }
                      break;
                  case -149311009:
                      if (var10000.equals("CGLIB$print$0()V")) {
                          return 19;
                      }
                      break;
                  case 610042816:
                      if (var10000.equals("newInstance(Lorg/springframework/cglib/proxy/Callback;)Ljava/lang/Object;")) {
                          return 5;
                      }
                      break;
                  case 1132856532:
                      if (var10000.equals("getCallbacks()[Lorg/springframework/cglib/proxy/Callback;")) {
                          return 9;
                      }
                      break;
                  case 1246779367:
                      if (var10000.equals("setCallback(ILorg/springframework/cglib/proxy/Callback;)V")) {
                          return 8;
                      }
                      break;
                  case 1306468936:
                      if (var10000.equals("CGLIB$toString$2()Ljava/lang/String;")) {
                          return 16;
                      }
                      break;
                  case 1364367423:
                      if (var10000.equals("getCallback(I)Lorg/springframework/cglib/proxy/Callback;")) {
                          return 10;
                      }
                      break;
                  case 1800494055:
                      if (var10000.equals("CGLIB$clone$4()Ljava/lang/Object;")) {
                          return 17;
                      }
                      break;
                  case 1826985398:
                      if (var10000.equals("equals(Ljava/lang/Object;)Z")) {
                          return 0;
                      }
                      break;
                  case 1913648695:
                      if (var10000.equals("toString()Ljava/lang/String;")) {
                          return 1;
                      }
                      break;
                  case 1984935277:
                      if (var10000.equals("hashCode()I")) {
                          return 2;
                      }
              }
      
              return -1;
          }
      
          public int getIndex(String var1, Class[] var2) {
              switch (var1.hashCode()) {
                  case -1776922004:
                      if (var1.equals("toString")) {
                          switch (var2.length) {
                              case 0:
                                  return 1;
                          }
                      }
                      break;
                  case -1295482945:
                      if (var1.equals("equals")) {
                          switch (var2.length) {
                              case 1:
                                  if (var2[0].getName().equals("java.lang.Object")) {
                                      return 0;
                                  }
                          }
                      }
                      break;
                  case -1053468136:
                      if (var1.equals("getCallbacks")) {
                          switch (var2.length) {
                              case 0:
                                  return 9;
                          }
                      }
                      break;
                  case -124978609:
                      if (var1.equals("CGLIB$equals$1")) {
                          switch (var2.length) {
                              case 1:
                                  if (var2[0].getName().equals("java.lang.Object")) {
                                      return 15;
                                  }
                          }
                      }
                      break;
                  case -60403779:
                      if (var1.equals("CGLIB$SET_STATIC_CALLBACKS")) {
                          switch (var2.length) {
                              case 1:
                                  if (var2[0].getName().equals("[Lorg.springframework.cglib.proxy.Callback;")) {
                                      return 12;
                                  }
                          }
                      }
                      break;
                  case -29025555:
                      if (var1.equals("CGLIB$hashCode$3")) {
                          switch (var2.length) {
                              case 0:
                                  return 18;
                          }
                      }
                      break;
                  case 85179481:
                      if (var1.equals("CGLIB$SET_THREAD_CALLBACKS")) {
                          switch (var2.length) {
                              case 1:
                                  if (var2[0].getName().equals("[Lorg.springframework.cglib.proxy.Callback;")) {
                                      return 11;
                                  }
                          }
                      }
                      break;
                  case 94756189:
                      if (var1.equals("clone")) {
                          switch (var2.length) {
                              case 0:
                                  return 3;
                          }
                      }
                      break;
                  case 106934957:
                      if (var1.equals("print")) {
                          switch (var2.length) {
                              case 0:
                                  return 7;
                          }
                      }
                      break;
                  case 147696667:
                      if (var1.equals("hashCode")) {
                          switch (var2.length) {
                              case 0:
                                  return 2;
                          }
                      }
                      break;
                  case 161998109:
                      if (var1.equals("CGLIB$STATICHOOK1")) {
                          switch (var2.length) {
                              case 0:
                                  return 14;
                          }
                      }
                      break;
                  case 495524492:
                      if (var1.equals("setCallbacks")) {
                          switch (var2.length) {
                              case 1:
                                  if (var2[0].getName().equals("[Lorg.springframework.cglib.proxy.Callback;")) {
                                      return 13;
                                  }
                          }
                      }
                      break;
                  case 770871766:
                      if (var1.equals("CGLIB$print$0")) {
                          switch (var2.length) {
                              case 0:
                                  return 19;
                          }
                      }
                      break;
                  case 1154623345:
                      if (var1.equals("CGLIB$findMethodProxy")) {
                          switch (var2.length) {
                              case 1:
                                  if (var2[0].getName().equals("org.springframework.cglib.core.Signature")) {
                                      return 20;
                                  }
                          }
                      }
                      break;
                  case 1543336189:
                      if (var1.equals("CGLIB$toString$2")) {
                          switch (var2.length) {
                              case 0:
                                  return 16;
                          }
                      }
                      break;
                  case 1811874389:
                      if (var1.equals("newInstance")) {
                          switch (var2.length) {
                              case 1:
                                  String var10001 = var2[0].getName();
                                  switch (var10001.hashCode()) {
                                      case -1997738671:
                                          if (var10001.equals("[Lorg.springframework.cglib.proxy.Callback;")) {
                                              return 6;
                                          }
                                          break;
                                      case 1364160985:
                                          if (var10001.equals("org.springframework.cglib.proxy.Callback")) {
                                              return 5;
                                          }
                                  }
                              case 2:
                              default:
                                  break;
                              case 3:
                                  if (var2[0].getName().equals("[Ljava.lang.Class;") && var2[1].getName().equals("[Ljava.lang.Object;") && var2[2].getName().equals("[Lorg.springframework.cglib.proxy.Callback;")) {
                                      return 4;
                                  }
                          }
                      }
                      break;
                  case 1817099975:
                      if (var1.equals("setCallback")) {
                          switch (var2.length) {
                              case 2:
                                  if (var2[0].getName().equals("int") && var2[1].getName().equals("org.springframework.cglib.proxy.Callback")) {
                                      return 8;
                                  }
                          }
                      }
                      break;
                  case 1905679803:
                      if (var1.equals("getCallback")) {
                          switch (var2.length) {
                              case 1:
                                  if (var2[0].getName().equals("int")) {
                                      return 10;
                                  }
                          }
                      }
                      break;
                  case 1951977610:
                      if (var1.equals("CGLIB$clone$4")) {
                          switch (var2.length) {
                              case 0:
                                  return 17;
                          }
                      }
              }
      
              return -1;
          }
      
          public int getIndex(Class[] var1) {
              switch (var1.length) {
                  case 0:
                      return 0;
                  default:
                      return -1;
              }
          }
      
          public Object invoke(int var1, Object var2, Object[] var3) throws InvocationTargetException {
              CglibProxyUserMapperImpl..EnhancerByCGLIB..2a1a85db var10000 = (CglibProxyUserMapperImpl..EnhancerByCGLIB..2a1a85db)var2;
              int var10001 = var1;
      
              try {
                  switch (var10001) {
                      case 0:
                          return new Boolean(var10000.equals(var3[0]));
                      case 1:
                          return var10000.toString();
                      case 2:
                          return new Integer(var10000.hashCode());
                      case 3:
                          return var10000.clone();
                      case 4:
                          return var10000.newInstance((Class[])var3[0], (Object[])var3[1], (Callback[])var3[2]);
                      case 5:
                          return var10000.newInstance((Callback)var3[0]);
                      case 6:
                          return var10000.newInstance((Callback[])var3[0]);
                      case 7:
                          var10000.print();
                          return null;
                      case 8:
                          var10000.setCallback(((Number)var3[0]).intValue(), (Callback)var3[1]);
                          return null;
                      case 9:
                          return var10000.getCallbacks();
                      case 10:
                          return var10000.getCallback(((Number)var3[0]).intValue());
                      case 11:
                          2a1a85db.CGLIB$SET_THREAD_CALLBACKS((Callback[])var3[0]);
                          return null;
                      case 12:
                          2a1a85db.CGLIB$SET_STATIC_CALLBACKS((Callback[])var3[0]);
                          return null;
                      case 13:
                          var10000.setCallbacks((Callback[])var3[0]);
                          return null;
                      case 14:
                          2a1a85db.CGLIB$STATICHOOK1();
                          return null;
                      case 15:
                          return new Boolean(var10000.CGLIB$equals$1(var3[0]));
                      case 16:
                          return var10000.CGLIB$toString$2();
                      case 17:
                          return var10000.CGLIB$clone$4();
                      case 18:
                          return new Integer(var10000.CGLIB$hashCode$3());
                      case 19:
                          var10000.CGLIB$print$0();
                          return null;
                      case 20:
                          return 2a1a85db.CGLIB$findMethodProxy((Signature)var3[0]);
                  }
              } catch (Throwable var4) {
                  throw new InvocationTargetException(var4);
              }
      
              throw new IllegalArgumentException("Cannot find matching method/constructor");
          }
      
          public Object newInstance(int var1, Object[] var2) throws InvocationTargetException {
              CglibProxyUserMapperImpl..EnhancerByCGLIB..2a1a85db var10000 = new CglibProxyUserMapperImpl..EnhancerByCGLIB..2a1a85db;
              CglibProxyUserMapperImpl..EnhancerByCGLIB..2a1a85db var10001 = var10000;
              int var10002 = var1;
      
              try {
                  switch (var10002) {
                      case 0:
                          var10001.<init>();
                          return var10000;
                  }
              } catch (Throwable var3) {
                  throw new InvocationTargetException(var3);
              }
      
              throw new IllegalArgumentException("Cannot find matching method/constructor");
          }
      
          public int getMaxIndex() {
              return 20;
          }
      }
      版权声明:本文内容来自第三方投稿或授权转载,原文地址:https://blog.51cto.com/u_16231213/9831553,作者:会下蛋的咯咯,版权归原作者所有。本网站转在其作品的目的在于传递更多信息,不拥有版权,亦不承担相应法律责任。如因作品内容、版权等问题需要同本网站联系,请发邮件至ctyunbbs@chinatelecom.cn沟通。

      上一篇:单例模式

      下一篇:continue 语句将控制权传递给它所在的封闭迭代语句的下一次迭代

      相关文章

      2025-05-08 09:03:29

      JDK动态代理笔记整理

      JDK动态代理笔记整理

      2025-05-08 09:03:29
      JDK , 代理 , 动态 , 笔记
      2025-05-06 09:19:12

      JDK动态代理和CGLIB动态代理的区别

      JDK动态代理和CGLIB动态代理的区别

      2025-05-06 09:19:12
      JDK , 代理 , 动态 , 调用
      2024-12-23 09:16:52

      java动态代理

      动态代理是指,程序在整个运行过程中根本就不存在目标类的代理类,目标对象的代理对象只是由代理生成工具(不是真实定义的类)在程序运行时由 JVM 根据反射等机制动态生成的。代理对象与目标对象的代理关系在程序运行时才确立。

      2024-12-23 09:16:52
      invoke , Object , 代理 , 对象 , 接口 , 目标
      查看更多
      推荐标签

      作者介绍

      天翼云小翼
      天翼云用户

      文章

      33561

      阅读量

      5243256

      查看更多

      最新文章

      JDK动态代理笔记整理

      2025-05-08 09:03:29

      JDK动态代理和CGLIB动态代理的区别

      2025-05-06 09:19:12

      查看更多

      热门文章

      JDK动态代理和CGLIB动态代理的区别

      2025-05-06 09:19:12

      JDK动态代理笔记整理

      2025-05-08 09:03:29

      查看更多

      热门标签

      linux java python javascript 数组 前端 docker Linux vue 函数 shell git 节点 容器 示例
      查看更多

      相关产品

      弹性云主机

      随时自助获取、弹性伸缩的云服务器资源

      天翼云电脑(公众版)

      便捷、安全、高效的云电脑服务

      对象存储

      高品质、低成本的云上存储服务

      云硬盘

      为云上计算资源提供持久性块存储

      查看更多

      随机文章

      JDK动态代理笔记整理

      JDK动态代理和CGLIB动态代理的区别

      • 7*24小时售后
      • 无忧退款
      • 免费备案
      • 专家服务
      售前咨询热线
      400-810-9889转1
      关注天翼云
      • 旗舰店
      • 天翼云APP
      • 天翼云微信公众号
      服务与支持
      • 备案中心
      • 售前咨询
      • 智能客服
      • 自助服务
      • 工单管理
      • 客户公告
      • 涉诈举报
      账户管理
      • 管理中心
      • 订单管理
      • 余额管理
      • 发票管理
      • 充值汇款
      • 续费管理
      快速入口
      • 天翼云旗舰店
      • 文档中心
      • 最新活动
      • 免费试用
      • 信任中心
      • 天翼云学堂
      云网生态
      • 甄选商城
      • 渠道合作
      • 云市场合作
      了解天翼云
      • 关于天翼云
      • 天翼云APP
      • 服务案例
      • 新闻资讯
      • 联系我们
      热门产品
      • 云电脑
      • 弹性云主机
      • 云电脑政企版
      • 天翼云手机
      • 云数据库
      • 对象存储
      • 云硬盘
      • Web应用防火墙
      • 服务器安全卫士
      • CDN加速
      热门推荐
      • 云服务备份
      • 边缘安全加速平台
      • 全站加速
      • 安全加速
      • 云服务器
      • 云主机
      • 智能边缘云
      • 应用编排服务
      • 微服务引擎
      • 共享流量包
      更多推荐
      • web应用防火墙
      • 密钥管理
      • 等保咨询
      • 安全专区
      • 应用运维管理
      • 云日志服务
      • 文档数据库服务
      • 云搜索服务
      • 数据湖探索
      • 数据仓库服务
      友情链接
      • 中国电信集团
      • 189邮箱
      • 天翼企业云盘
      • 天翼云盘
      ©2025 天翼云科技有限公司版权所有 增值电信业务经营许可证A2.B1.B2-20090001
      公司地址:北京市东城区青龙胡同甲1号、3号2幢2层205-32室
      • 用户协议
      • 隐私政策
      • 个人信息保护
      • 法律声明
      备案 京公网安备11010802043424号 京ICP备 2021034386号