Spring5源码-FactoryBean介绍

Swin Transformer注意力计算复杂度为何比全局注意力少那么多? 本文对比分析了Vision Transformer(ViT)和Swin Transformer的计算复杂度。ViT采用全局注意力机制,计算复杂度为4[hwc^2]+2[(hw)^2C],当图像尺寸较大时计算量显著增加。而Swin Transformer采用窗口注意力机制,将图像划分为M×M的窗口(如7×7),计算复杂度降为4[hwc^2]+2[(hw)(M*M)*C]。以224×224图像为例,Swin Transformer的计算量比ViT减少约900倍,大幅节省了计算资源。文章通过矩阵乘法运算详细推导了 阅读详情

1. 简介

一般情况下,Spring通过反射机制利用bean的class属性指定实现类来实例化bean。但是在某些情况下,实例化bean 的过程比较复杂,在XML配置下如果按照传统的编码方式,则需要进行大量配置,灵活性受限,这时候Spring 提供了一个 org.springframework.beans.factory.FactoryBean 的工厂类接口。可以通过该接口定制实例化bean 的逻辑。

除此之外,FactoryBean在Spring框架中都占有很重要的地位,Spring自身就提供了非常多的FactoryBean的实现。

首先我们来看看 FactoryBean 接口的定义。方法比较简单,见名知意。

public interface FactoryBean<T> {
    // 属性名
    String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";

    // 获取bean实例,实例化bean 的逻辑就在这里实现
    @Nullable
    T getObject() throws Exception;
    // 获取bean类型
    @Nullable
    Class<?> getObjectType();
    // 是否是单例
    default boolean isSingleton() {
        return true;
    }

}

  • T getObject() : 返回由FactoryBean创建的bean实例,如果isSingleton() 返回true,则会将该实例方法Spring容器的单例缓冲池中
  • Class<?> getObjectType() : 返回由FactoryBean 创建的bean 的类型
  • boolean isSingleton() : 返回由FactoryBean 创建的bean实例的作用域是singleton还是Prototype。

FactoryBean就是一种方法,要么是解决生成BeanDefinition的困难;要么是解决反射实例化bean时候遇到的困难,将spring不好自动化处理的逻辑写到getObject方法内。

在Mybatis 中,默认情况下 Mybatis会将所有的Mapper生成的代理对象保存到 SqlSession 中,如果需要获取 Mapper对象可以通过SqlSession.geMapper 获取。而当使用Spring 集成 Mybatis 框架时,Spring会将所有的Bean 都保存到单独的缓存中,当进行属性注入时从缓存中获取对象并赋值。而Mapper 对象保存到 SqlSession中,那么Spring 如何获取Mapper对象则成了一个问题。这时 Mybatis 为每个Mapper对象创建了一个 MapperFactoryBean。当Spring需要获取 Mapper 对象时,会通过MapperFactoryBean 来获取,而 MapperFactoryBean#getObject 实现如下,MapperFactoryBean会从 SqlSession 中获取 Mapper。

  @Override
  public T getObject() throws Exception {
    return getSqlSession().getMapper(this.mapperInterface);
  }

2. FactoryBean 简单使用

下面举个简单的例子进一步说明FactoryBean 的用法。

@Component  //也可以实现 SmartFactoryBean。指定提前加载
public class HelloFactory implements FactoryBean<Hello> {

   @Override
   public Hello getObject() throws Exception {
      return new Hello(); //这是最终获取到的对象
   }

   @Override
   public Class<?> getObjectType() {
      return Hello.class;
   }
}

public class AnnotationMainTest {

   public static void main(String[] args) {

      AnnotationConfigApplicationContext context =
            new AnnotationConfigApplicationContext(MainConfig.class);

      // FactoryBean测试
      Object hello = context.getBean("helloFactory");
      System.out.println(hello);
      Object helloFactory = context.getBean("&helloFactory");
      System.out.println(helloFactory);
  }
}

如上一个简单的例子,调用结果如下,可以看到:我们这里直接调用 run.getBean("helloFactory"); 返回的并不是 HelloFactory ,Hello 。而我们使用 run.getBean("&helloFactory"); 返回的结果却是HelloFactory 。

实际上,当调用 run.getBean("helloFactory"); 时,Spring通过反射会发现 HelloFactory 实现了FactoryBean接口,则会直接调用 其getObject() 方法,并将方法的返回值注入到Spring容器中。而如果想要获得DemoFactoryBean 实例,则需要在 beanName前加上 & ,即 run.getBean("&helloFactory");

3. 源码解读

比较完成的源码分析可以看 Spring5源码7-Bean创建及初始化(上)。这里仅仅介绍一下 FactoryBean 的处理过程,所以内容覆盖可能不够全面。

对于 FactoryBean的处理在 AbstractBeanFactory#getObjectForBeanInstance 方法中完成,我们需要判断其是否是 FactoryBean 的 实现类,如果是,则需要将其getObject() 的结果注入。所以该方法的功能简单来说就是用来检测当前bean是否是FactoryBean类型的bean,如果是,则调用其getObject() 方法,并将其返回值作为bean

bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);

代码逻辑大体如下:

  1. 首先是在 AbstractBeanFactory#getObjectForBeanInstance 中
  2. 判断程序是否想获取 FactoryBean实例(beanName 是否以 & 开头)。如果是判断当前beanInstance是否是 FactoryBean。如果是则返回,否则抛出异常
  3. 如果不是想获取FactoryBean,那么就是想获取bean实例了。那么判断此时的beanInstance是普通的bean还是FactoryBean类型,如果是普通的bean则直接返回。
  4. 此时beanInstance 必定是 FactoryBean类型并且程序想获取bean实例。那么首先尝试从缓存 factoryBeanObjectCache 中获取。获取失败,则调用FactoryBean#getObject 方法来获取bean实例。并且在允许调用后置方法的情况下(shouldPostProcess 为true),调用BeanPostProcessor#postProcessAfterInitialization 的方法。

下面我们来看详细代码

3.1 AbstractBeanFactory#getObjectForBeanInstance

getObjectForBeanInstance(beanInstance, name, beanName, mbd); 调用了 AbstractBeanFactory#getObjectForBeanInstance:

protected Object getObjectForBeanInstance(
      Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

   // Don't let calling code try to dereference the factory if the bean isn't a factory.
   // 1\. 检测name 是否是想获取 工厂类 (name 以 & 开头)
   if (BeanFactoryUtils.isFactoryDereference(name)) {
      if (beanInstance instanceof NullBean) {
         return beanInstance;
      }
      // 以&开头又不是FactoryBean实现类,则抛出异常
      if (!(beanInstance instanceof FactoryBean)) {
         throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
      }
      if (mbd != null) {
         mbd.isFactoryBean = true;
      }
      return beanInstance;
   }

   // Now we have the bean instance, which may be a normal bean or a FactoryBean.
   // If it's a FactoryBean, we use it to create a bean instance, unless the
   // caller actually wants a reference to the factory.
   // 2\. 此时bean可能是 FactoryBean 或者 普通的bean。
   // 判断如果 beanInstance 不是 FactoryBean而是普通的bean, 就直接返回
   if (!(beanInstance instanceof FactoryBean)) {
      return beanInstance;
   }

   // 3\. 到这一步就可以确定,当前beanInstance 是FactoryBean,并且需要获取getObject() 的结果
   Object object = null;
   if (mbd != null) {
      mbd.isFactoryBean = true;
   }
   else {
      // 尝试从缓存中加载bean。这一步是从 factoryBeanObjectCache 集合中获取
      // 在后面获取 bean 成功后,可能会将 其缓存到 factoryBeanObjectCache  中
      object = getCachedObjectForFactoryBean(beanName);
   }
   if (object == null) {
      // Return bean instance from factory.
      FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
      // Caches object obtained from FactoryBean if it is a singleton.
      // containsBeanDefinition 检测  beanDefinitionMap中也就是所有已经加载的类中检测是否定义beanName
      if (mbd == null && containsBeanDefinition(beanName)) {
         // 合并父类bean 定义的属性
         mbd = getMergedLocalBeanDefinition(beanName);
      }
      boolean synthetic = (mbd != null && mbd.isSynthetic());
      // 4\. 这一步中对FactoryBean进行了解析。
      object = getObjectFromFactoryBean(factory, beanName, !synthetic);
   }
   return object;
}

3.2 getObjectFromFactoryBean

getObjectFromFactoryBean 方法中 调用 doGetObjectFromFactoryBean 方法来获取 FactoryBean 中的 bean实例。下面我们来看一下getObjectFromFactoryBean 代码:

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
   // 判断是否是单例模式 && singletonObjects 尚未缓存该bean (containsSingleton调用的是 singletonObjects )
   if (factory.isSingleton() && containsSingleton(beanName)) {
      synchronized (getSingletonMutex()) {
         // 尝试从 factoryBeanObjectCache 缓存中获取
         Object object = this.factoryBeanObjectCache.get(beanName);
         if (object == null) {
            // 在这个方法中进行解析。调用 FactoryBean 的 getObject 方法
            object = doGetObjectFromFactoryBean(factory, beanName);
            // Only post-process and store if not put there already during getObject() call above
            // (e.g. because of circular reference processing triggered by custom getBean calls)
            // 因为是单例模式,所以要保证变量的全局唯一。所以这里如果缓存中已经创建好了bean则替换为已经创建好的bean
            Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
            if (alreadyThere != null) {
               object = alreadyThere;
            }
            else {
               // 如果允许调用bean的后置处理器。因为这里是直接将bean创建返回了,如果要调用后置方法则只能在这里调用。
               if (shouldPostProcess) {
                  if (isSingletonCurrentlyInCreation(beanName)) {
                     // Temporarily return non-post-processed object, not storing it yet..
                     return object;
                  }
                  // 将beanName 添加到 singletonsCurrentlyInCreation 中缓存,表示当前bean正在创建中
                  beforeSingletonCreation(beanName);
                  try {
                     // 调用了ObjectFactory的后置处理器。
                     object = postProcessObjectFromFactoryBean(object, beanName);
                  }
                  catch (Throwable ex) {
                     throw new BeanCreationException(beanName,
                           "Post-processing of FactoryBean's singleton object failed", ex);
                  }
                  finally {
                     // 将beanName 从 singletonsCurrentlyInCreation 中移除,表示当前bean已经创建结束
                     afterSingletonCreation(beanName);
                  }
               }
               // return this.singletonObjects.containsKey(beanName);
               // 如果 singletonObjects缓存中存在当前beanName,则将其缓存到 factoryBeanObjectCache 中。
               if (containsSingleton(beanName)) {
                  // 这里保存的是 beanName : FactoryBean
                  this.factoryBeanObjectCache.put(beanName, object);
               }
            }
         }
         return object;
      }
   }
   else {
      // FactoryBean 非单例直接调用 getObject 方法
      Object object = doGetObjectFromFactoryBean(factory, beanName);
      if (shouldPostProcess) {
         try {
            // 如果允许调用后置方法,则调用postProcessObjectFromFactoryBean 方法
            object = postProcessObjectFromFactoryBean(object, beanName);
         }
         catch (Throwable ex) {
            throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
         }
      }
      return object;
   }
}

3.3 doGetObjectFromFactoryBean

doGetObjectFromFactoryBean 方法的实现在 FactoryBeanRegistrySupport#getObjectFromFactoryBean 中,作用是 从 FactoryBean 中获取 Object 对象。代码如下:

private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {
   Object object;
   try {
      // 如果设置了安全管理器,尝试通过特权方式从 FactoryBean 中获取 Object
      if (System.getSecurityManager() != null) {
         AccessControlContext acc = getAccessControlContext();
         try {
            object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
         }
         catch (PrivilegedActionException pae) {
            throw pae.getException();
         }
      }
      else {
         // 直接从 FactoryBean 中获取 Object
         object = factory.getObject();
      }
   }
   catch (FactoryBeanNotInitializedException ex) {
      throw new BeanCurrentlyInCreationException(beanName, ex.toString());
   }
   catch (Throwable ex) {
      throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
   }

   // Do not accept a null value for a FactoryBean that's not fully
   // initialized yet: Many FactoryBeans just return null then.
   // 如果当期bean是单例 && 正在创建中,则抛出异常
   if (object == null) {
      if (isSingletonCurrentlyInCreation(beanName)) {
         throw new BeanCurrentlyInCreationException(
               beanName, "FactoryBean which is currently in creation returned null from getObject");
      }
      object = new NullBean();
   }
   return object;
}

 

(持续更新中!)详解【计算机类&面试真题】军队文职考试 ——第二期(真题+解析)| 网络协议的三个核心要素;交互式系统中的非剥夺策略;中断和陷入的区别;可变分区管理中的硬件机制;数据库系统的优点 本篇博客将讨论军队文职面试(计算机类)的几个关键问题。我们将介绍网络协议的核心要素(帮助你理解网络通信的基本原理)、交互式系统中的非剥夺策略(解释为何这是一个优秀的策略以及其对用户体验、系统稳定性和可预测性的影响)、中断和陷入的区别(从引起原因、处理机制、权限级别和应用等方面进行阐述)、可变分区管理的硬件机制以及数据库系统与文件系统的优点比较。通过阅读本文,您将深入了解这些话题,为面试准备和实际应用提供有价值的知识。 阅读详情

相关推荐

DNS入侵检测 datacon2020

DNS入侵检测 datacon2020。

weixin_51491521的博客 524

分布式事务seata1.4.2客户端无法启动原因解决

客户端启动报BeanCreationException: Error creating bean with name ‘orderDAO’: Post-processing of FactoryBean’s singleton object failed; org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'orderController': Unsatisfied

博客模板 1726

安川机器人SOCKET 通讯

命令 功能 参数 示例 返回 SelectJob 选择程序 JobName LineNo SelectJob TEST 0 #SelectJob,Ok StartJob 启动程序 JobName StartJob TEST #StartJob,Ok Pause 暂停当前程序 - Pause #Pause,Ok Continue 继续当前程序 - Continue #Continue,Ok ServoOn 伺服上电 - ServoOn #ServoOn,Ok ServoOf...

记录学习内容 8288

Spring 源码学习笔记(四) bean的加载

个人学习Spring源码系列 bean的加载 一、总览 bean加载的调用方式 MyTestBean bean = (MyTestBean) bf.getBean("myTestBean") 加载过程相当复杂: (1)转换对应的beanName 去除FactoryBean的修饰符 取指定alias所表示的最终beanName (2)尝试从缓存中加载单例 如果加载不成功则再次尝试从singletonFactories中加载. 在Spring中创建bean的原则是不等bean创建完成就会将.

panjianlongWUHAN的专栏 1183

Intel Arc显卡玩《三角洲行动》报错?手把手教你修改注册表跳过验证

本文针对Intel Arc显卡用户在运行《三角洲行动》时遇到的驱动验证报错问题,提供了详细的解决方案。通过安全修改Windows注册表,添加特定键值以跳过游戏驱动兼容性验证,并结合游戏内图形设置与Intel驱动面板的优化建议,旨在帮助玩家顺利进入游戏并提升游戏帧率与运行稳定性。

weixin_29310605的博客 700

信创改造实战:SpringBoot项目迁移到宝兰德BES 9.5.5的完整避坑指南(附依赖与web.xml配置)

本文详细介绍了将SpringBoot项目迁移到宝兰德BES 9.5.5的完整流程,包括依赖改造、web.xml配置降级等关键步骤。通过实战案例和避坑指南,帮助开发者高效完成国产中间件适配,确保项目平稳运行。特别针对Tomcat依赖排除和BES适配器选择提供了专业建议。

weixin_30689307的博客 743

Spring Cloud Finchley.SR1版本遇到的坑以及解决方案

1.eureka.instance.instance-id中,会添加instance的信息,之前使用方式为 ${spring.application.name}:${spring.cloud.client.ipAddress}:${spring.application.instance_id:${server.port}}  其中,在eureka中展示IP使用的是属性spring.cloud...

LWJ285149763的专栏 1万+

STM32实战:用定时器触发ADC+DMA双缓冲实现电机电流采样(附避坑指南)

本文详细介绍了如何利用STM32的定时器触发ADC注入组采样,结合DMA双缓冲机制实现电机电流的高效采样。通过PWM触发和双缓冲架构,解决了开关噪声干扰、实时性要求和数据一致性等核心挑战,显著降低CPU负载并提升采样精度。附有完整的代码示例和避坑指南,适用于无人机电调、工业伺服驱动器等高精度电机控制场景。

weixin_33737134的博客 520

从源码层面解读spring中bean的循环依赖解决方案(4)

写在前面的话 源码层面解读spring中bean的循环依赖解决方案系列来到了最终章, 我们主要研究spring如何从bean的实例中获取对象。 从bean的实例中获取对象 在getBean的方法中,getObjectForBeanInstance是一个高频使用的方法,无论是从缓存中获取还是从不同的scope策略加载bean。 这个方法的主要作用就是检测当前bean是否是FactoryBean类型的bean,如果是,就需要条 用该bean队友的FactoryBean实例中的getObject()作为放回值。

qq_41692749的博客 443

Zotero+WPS文献引用跳转功能缺失?3分钟教你用VBA宏搞定(附完整代码)

本文针对WPS用户使用Zotero时文献引用无法点击跳转的痛点,提供了一套完整的VBA宏解决方案。通过解析Zotero的域代码,自动在文内引用和文末参考文献之间创建超链接,实现一键跳转,极大提升了学术写作与文献查阅的效率。

weixin_28419039的博客 674

Cisco三层交换机的详细配置

** 本文适用于新手小白以及微微基础的同学来用于参考,实验是在Cisco Packet Tracer Student 进行,实验最终效果如图所示,所有命令配置与图中的一致。 使用到的机器型号为:五台电脑,一台服务器,三个普通交换机(2960型号),一个三层交换机(3560-24PS),两台普通服务器(2811) 文章目录一、什么是三层交换机二、配置交换机步骤1.配置二层交换机2.配置三层交换机3.配置两台路由器以及最后一台电脑 一、什么是三层交换机 1.三层交换机 = 三层路由+二层交换机 2.工作在

真正的大师,永远都怀着一颗学徒的心。 4万+

Spring IOC - FactoryBean源码解析

FactoryBean是Spring框架中的一个接口,它允许我们自定义一个工厂类,用于创建和管理Spring容器中的Bean实例。getObject():用于返回一个Bean实例,这个方法可以自定义创建Bean实例的逻辑。getObjectType():用于返回创建的Bean实例的类型。当我们在Spring中自定义一个FactoryBean时,Spring容器会先创建这个FactoryBean实例,然后调用它的getObject()方法来获取实际的Bean实例。

zhangweiocp的专栏 700

关于笔记本测试的面试准备 2021-10-11

** 关于笔记本测试的面试准备 ** 一、根据JD分析,工作内容以软测为主,硬件知识需要了解一点。 以下几个问题为主要: 1.了解VGA、audio、wlan、bt、TP 、camera等driver,BIOS和image测试。 2.了解性能测试工具?压力测试相关设置? 3.了解preload流程? 二、解决 VGA: video graphics array ——笔记本上外接显示器的接口。 【VGA接口兼容性更强,但是不支持高分辨率。 支持高分辨率:HDMI、DIV、TP】 bt【Bluetooth

xw_009的博客 1868

深入Spring FactoryBean:揭秘factoryBeanObjectCache的存储机制

本文深入解析了Spring框架中FactoryBean的核心机制,重点剖析了factoryBeanObjectCache的工作原理。FactoryBean作为创建复杂对象的工厂接口,通过getObject()方法生成产品对象。当FactoryBean为单例时,其产品会被缓存在ConcurrentHashMap实现的factoryBeanObjectCache中,确保重复请求时返回同一实例。文章还介绍了SmartFactoryBean的高级特性,如立即初始化和原型作用域控制,并分析了典型应用场景与性能优化建议

weixin_51786043的博客 1280

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

rez注入器源码_最简 Spring IOC 容器源码分析

前言 BeanDefinition BeanFactory 简介 Web 容器启动过程 bean 的加载 FactoryBean 循环依赖 bean 生命周期 公众号 前言 许多文章都是分析的 xml 配置,但是现在 Spring Boot 开发多基于注解。本文从注解的角度分析 Spring IOC 容器源码。 版本: Spring Boot:2.1.6.RELEASE Spring ...

weixin_33901995的博客 162

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

rez注入器源码_细节满满!Spring IOC容器源码分析最优解

前言许多文章都是分析的 xml 配置,但是现在 Spring Boot 开发多基于注解。本文从 注解 的角度分析 Spring IOC 容器源码。版本:Spring Boot:2.1.6.RELEASESpring FrameWork:5.1.8.RELEASEJava 8BeanDefinitionBeanDefinition 接口定义了一个包含属性、构造器参数、其他具体信息的 bean 实例。...

weixin_36357157的博客 177

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

较真儿学源码系列-Spring IoC核心流程源码分析

Spring IoC核心流程源码分析

天瑕的博客 826

设计模式啊

设计模式简约版笔记

A1455225785的博客 104

android.mk 脚本,Android------Android.mk调用shell脚本

each-SelectWhile Ruby’seachmethod is useful, it also comes with an awesome extended family of methods that ar ...List 接口以及实现类和相关类源码分析List 接口以及实现类和相关类源码分析 List接口分析 接口描述 用户可以对列表进行随机的读取(get),插入(add),删除...

weixin_42164534的博客 462

【Spring学习】FactoryBean的使用

FactoryBean 接口对于 Spring 框架来说占有重要的地位,Spring 自身就提供了 70 多个FactoryBean 的实现。它们隐藏了实例化一些复杂 bean 的细节,给上层应用带来了便利。一般情况下,Spring 通过反射机制利用 bean 的 class 属性指定实现类来实例化 bean。在某些情况下,实例化 bean 过程比较复杂,如果按照传统的方式,则需要在中提供大量的配置信息,配置方式的灵活性是受限的,这时采用编码的方式可能会得到一个简单的方案。

qq_43783527的博客 3159

Spring--MyBatis源码对FactoryBean的应用

本文分析Mybatis是如何应用Spring的FactoryBean的。

IT利刃出鞘的博客 4103

spring5源码分析-FactoryBean

一、引言 怎么说? 一直想写spring源码分析系列的文章,又不知道从何写起。 回想2018年小编写文章的目的是什么呢? 只是单纯的记录自己的学习,当作笔记来使用(对,真的只是当作笔记)。随着优快云发展、随着年龄的增长、随着心理的变化,反而变得不是那么单纯。 有时候花了一个礼拜、两个礼拜认认真真写一篇源码分析的文章,访问量少而又少,点赞寥寥无几。 正义也许会迟到,但绝不会缺席,怀着最初的心态,再加年底小编会习惯总结今年所学习的知识,整理整理还是觉得发到博客上,希望在看的小伙伴点个赞啥的。 小编分

贱男 754

Spring5源码 - 08 BeanFactory和FactoryBean 源码解析 & 使用场景

文章目录区别演示 区别 首先明确一下,这两个东西是玩完全不同的两个东西 BeanFactory 是Spring Framework的 顶级核心接口 , 没有这个接口,就没有Bean的产生。 演示

小工匠 2万+

Spring 源码分析衍生篇一:FactoryBean介绍

一、简介 一般情况下,Spring通过反射机制利用bean的class属性指定实现类来实例化bean。但是在某些情况下,实例化bean 的过程比较复杂,在XML配置下如果按照传统的编码方式,则需要进行大量配置,灵活性受限,这时候Spring 提供了一个 org.springframework.beans.factory.FactoryBean 的工厂类接口。可以通过该接口定制实例化bean 的逻辑...

猫吻鱼的博客 2692

Spring中FactoryBean的BeanName解读

这里写目录标题简介结果演示环境结论源码分析1、转变BeanName2、从容器中获取BeanName对应的对象3、核心方法getObjectForBeanInstance4、判断逻辑1、先判断`name`是否为空,是否是`&`开头2、 接下来继续走逻辑,通过BeanName从`某个`缓存中获取对象3、如果缓存取不到就进行创建对象处理4、创建对象过程5、加入到Bean对象`factoryBeanObjectCache`容器中小结DEBUG查看容器对象信息factoryBeanObjectCache容器B

a760352276的博客 3463

Spring FactoryBean源码解析与应用实践

FactoryBean是Spring框架中用于封装复杂对象创建逻辑的核心接口,属于工厂模式在IoC容器中的典型实现。其原理是通过实现getObject()方法将对象的构造过程标准化,使Spring能够统一管理需要特殊初始化逻辑的组件(如数据库连接池、动态代理等)。与基础容器接口BeanFactory不同,FactoryBean本身是被管理的Bean,同时又能作为其他Bean的生产者。这种设计在MyBatis SqlSessionFactory等第三方库集成场景中尤为重要,既能解决循环依赖问题,又能实现资源的

anjueci1221的博客 407
上一篇: 8年java技术岗面试官总结:2022超强面试大全,抓住金九银十起飞
下一篇: Java程序员必修技能:Spring全家桶实战
Java技术那些事儿
博客等级 码龄5年 2306粉丝 2584原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值