Spring IOC 深入浅出

最新推荐文章于 2024-05-25 10:57:37 发布
最新推荐文章于 2024-05-25 10:57:37 发布
阅读量535 收藏 1
点赞数
文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42274285/article/details/124553057
版权

Spring IOC 深入浅出

Spring IoC基础

在这里插入图片描述

BeanFactory与ApplicationContext区别

BeanFactory是Spring框架中IoC容器的顶层接⼝,它只是⽤来定义⼀些基础功能,定义⼀些基础规范,⽽ApplicationContext是它的⼀个⼦接⼝，所以ApplicationContext是具备BeanFactory提供的全部功能的。
通常，我们称BeanFactory为SpringIOC的基础容ApplicationContext是容器的⾼级接⼝，⽐BeanFactory要拥有更多的功能，⽐如说国际化⽀持和资源访问（xml，java配置类）等等
在这里插入图片描述
启动 IoC 容器的⽅式

  • Java环境下启动IoC容器 ClassPathXmlApplicationContext：从类的根路径下加载配置⽂件（推荐使⽤）
    FileSystemXmlApplicationContext：从磁盘路径上加载配置⽂件
    AnnotationConfigApplicationContext：纯注解模式下启动Spring容器
  • Web环境下启动IoC容器
    从xml启动容器
    在这里插入图片描述
    从配置类启动容器在这里插入图片描述在这里插入图片描述

纯xml模式

本部分内容我们不采⽤⼀⼀讲解知识点的⽅式，⽽是采⽤Spring IoC 纯 xml 模式改造我们前⾯⼿写的IoC 和 AOP 实现，在改造的过程中，把各个知识点串起来。

  • xml ⽂件头在这里插入图片描述

  • 实例化Bean的三种⽅式
    ⽅式⼀：使⽤⽆参构造函数
    在默认情况下，它会通过反射调⽤⽆参构造函数来创建对象。如果类中没有⽆参构造函数，将创建失败。在这里插入图片描述
    ⽅式⼆：使⽤静态⽅法创建
    在实际开发中，我们使⽤的对象有些时候并不是直接通过构造函数就可以创建出来的，它可能在创建的过程 中会做很多额外的操作。此时会提供⼀个创建对象的⽅法，恰好这个⽅法是static修饰的⽅法，即是此种情况。
    例如，我们在做Jdbc操作时，会⽤到java.sql.Connection接⼝的实现类，如果是mysql数据库，那么⽤的就 是JDBC4Connection，但是我们不会去写 JDBC4Connection connection = new JDBC4Connection() ，因 为我们要注册驱动，还要提供URL和凭证信息，⽤ DriverManager.getConnection ⽅法来获取连接。
    那么在实际开发中，尤其早期的项⽬没有使⽤Spring框架来管理对象的创建，但是在设计时使⽤了⼯⼚模式 解耦，那么当接⼊spring之后，⼯⼚类创建对象就具有和上述例⼦相同特征，即可采⽤此种⽅式配置。在这里插入图片描述
    ⽅式三：使⽤实例化⽅法创建
    此种⽅式和上⾯静态⽅法创建其实类似，区别是⽤于获取对象的⽅法不再是static修饰的了，⽽是类中的⼀ 个普通⽅法。此种⽅式⽐静态⽅法创建的使⽤⼏率要⾼⼀些。在早期开发的项⽬中，⼯⼚类中的⽅法有可能是静态的，也有可能是⾮静态⽅法，当是⾮静态⽅法时，即可 采⽤下⾯的配置⽅式：在这里插入图片描述

  • Bean的X及⽣命周期
    作⽤范围的改变
    在spring框架管理Bean对象的创建时，Bean对象默认都是单例的，但是它⽀持配置的⽅式改变作⽤范围。作⽤范围官⽅提供的说明如下图：在这里插入图片描述在上图中提供的这些选项中，我们实际开发中⽤到最多的作⽤范围就是singleton（单例模式）和prototype（原型模式，也叫多例模式）。配置⽅式参考下⾯的代码：在这里插入图片描述
    不同作⽤范围的⽣命周期
    单例模式：singleton
    对象出⽣：当创建容器时，对象就被创建了。
    对象活着：只要容器在，对象⼀直活着。
    对象死亡：当销毁容器时，对象就被销毁了。
    ⼀句话总结：单例模式的bean对象⽣命周期与容器相同。
    多例模式：prototype
    对象出⽣：当使⽤对象时，创建新的对象实例。
    对象活着：只要对象在使⽤中，就⼀直活着。
    对象死亡：当对象⻓时间不⽤时，被java的垃圾回收器回收了。
    ⼀句话总结：多例模式的bean对象，spring框架只负责创建，不负责销毁。

  • Bean标签属性
    在基于xml的IoC配置中，bean标签是最基础的标签。它表示了IoC容器中的⼀个对象。换句话说，如果⼀个对象想让spring管理，在XML的配置中都需要使⽤此标签配置，Bean标签的属性如下：
    id属性： ⽤于给bean提供⼀个唯⼀标识。在⼀个标签内部，标识必须唯⼀。
    class属性：⽤于指定创建Bean对象的全限定类名。
    name属性：⽤于给bean提供⼀个或多个名称。多个名称⽤空格分隔。
    factory-bean属性：⽤于指定创建当前bean对象的⼯⼚bean的唯⼀标识。当指定了此属性之后，class属性失效。
    factory-method属性：⽤于指定创建当前bean对象的⼯⼚⽅法，如配合factory-bean属性使⽤，则class属性失效。如配合class属性使⽤，则⽅法必须是static的。
    scope属性：⽤于指定bean对象的作⽤范围。通常情况下就是singleton。当要⽤到多例模式时，可以配置为prototype。
    init-method属性：⽤于指定bean对象的初始化⽅法，此⽅法会在bean对象装配后调⽤。必须是⼀个⽆参⽅法。
    destory-method属性：⽤于指定bean对象的销毁⽅法，此⽅法会在bean对象销毁前执⾏。它只能为scope是singleton时起作⽤。

  • DI 依赖注⼊的xml配置
    依赖注⼊分类
    按照注⼊的⽅式分类
    构造函数注⼊：顾名思义，就是利⽤带参构造函数实现对类成员的数据赋值。
    set⽅法注⼊：它是通过类成员的set⽅法实现数据的注⼊。（使⽤最多的）
    按照注⼊的数据类型分类
    基本类型和String
    注⼊的数据类型是基本类型或者是字符串类型的数据。
    其他Bean类型
    注⼊的数据类型是对象类型，称为其他Bean的原因是，这个对象是要求出现在IoC容器中的。那么针对当前Bean来说，就是其他Bean了。
    复杂类型（集合类型）
    注⼊的数据类型是Aarry，List，Set，Map，Properties中的⼀种类型。

依赖注⼊的配置实现之构造函数注⼊ 顾名思义，就是利⽤构造函数实现对类成员的赋值。它的使⽤要求是，类中提供的构造函数参数个数必须和配置的参数个数⼀致，且数据类型匹配。同时需要注意的是，当没有⽆参构造时，则必须提供构造函数参数的注⼊，否则Spring框架会报错。
在这里插入图片描述
在使⽤构造函数注⼊时，涉及的标签是 constructor-arg ，该标签有如下属性：
name：⽤于给构造函数中指定名称的参数赋值。
index：⽤于给构造函数中指定索引位置的参数赋值。
value：⽤于指定基本类型或者String类型的数据。
ref：⽤于指定其他Bean类型的数据。写的是其他bean的唯⼀标识。

  • 依赖注⼊的配置实现之set⽅法注⼊

顾名思义，就是利⽤字段的set⽅法实现赋值的注⼊⽅式。此种⽅式在实际开发中是使⽤最多的注⼊⽅式。
在这里插入图片描述
在这里插入图片描述
在使⽤set⽅法注⼊时，需要使⽤ property 标签，该标签属性如下：
name：指定注⼊时调⽤的set⽅法名称。（注：不包含set这三个字⺟,druid连接池指定属性名称）
value：指定注⼊的数据。它⽀持基本类型和String类型。
ref：指定注⼊的数据。它⽀持其他bean类型。写的是其他bean的唯⼀标识。
复杂数据类型注⼊ ⾸先，解释⼀下复杂类型数据，它指的是集合类型数据。集合分为两类，⼀类是List结构（数组结构），⼀类是Map接⼝（键值对） 。
接下来就是注⼊的⽅式的选择，只能在构造函数和set⽅法中选择，我们的示例选⽤set⽅法注⼊。
在这里插入图片描述
在这里插入图片描述在List结构的集合数据注⼊时， array , list , set 这三个标签通⽤，另外注值的 value 标签内部可以直接写值，也可以使⽤ bean 标签配置⼀个对象，或者⽤ ref 标签引⽤⼀个已经配合的bean的唯⼀标识。
在Map结构的集合数据注⼊时， map 标签使⽤ entry ⼦标签实现数据注⼊， entry 标签可以使⽤key和value属性指定存⼊map中的数据。使⽤value-ref属性指定已经配置好的bean的引⽤。同时 entry 标签中也可以使⽤ ref 标签，但是不能使⽤ bean 标签。⽽ property 标签中不能使⽤ ref 或者 bean 标签引⽤对象

xml与注解相结合模式

注意：
1）实际企业开发中，纯xml模式使⽤已经很少了
2）引⼊注解功能，不需要引⼊额外的jar
3）xml+注解结合模式，xml⽂件依然存在，所以，spring IOC容器的启动仍然从加载xml开始
4）哪些bean的定义写在xml中，哪些bean的定义使⽤注解
第三⽅jar中的bean定义在xml，⽐如德鲁伊数据库连接池⾃⼰开发的bean定义使⽤注解

  • xml中标签与注解的对应（IoC）
    在这里插入图片描述

  • DI 依赖注⼊的注解实现⽅式
    @Autowired（推荐使⽤）
    @Autowired为Spring提供的注解，需要导⼊包
    org.springframework.beans.factory.annotation.Autowired。
    @Autowired采取的策略为按照类型注⼊。
    在这里插入图片描述如上代码所示，这样装配回去spring容器中找到类型为AccountDao的类，然后将其注⼊进来。这样会产⽣⼀个问题，当⼀个类型有多个bean值的时候，会造成⽆法选择具体注⼊哪⼀个的情况，这个时候我们需要配合着@Qualifier使⽤。
    @Qualifier告诉Spring具体去装配哪个对象。
    在这里插入图片描述这个时候我们就可以通过类型和名称定位到我们想注⼊的对象。
    @Resource
    @Resource 注解由 J2EE 提供，需要导⼊包 javax.annotation.Resource。
    @Resource 默认按照 ByName ⾃动注⼊。
    在这里插入图片描述

  • 如果同时指定了 name 和 type，则从Spring上下⽂中找到唯⼀匹配的bean进⾏装配，找不 到则抛出异常。

  • 如果指定了name，则从上下⽂中查找名称（id）匹配的bean进⾏装配，找不到则抛出异常。

  • 如果指定了type，则从上下⽂中找到类似匹配的唯⼀bean进⾏装配，找不到或是找到多个， 都会抛出异常。

  • 如果既没有指定name，⼜没有指定type，则⾃动按照byName⽅式进⾏装配；
    注意:
    @Resource 在 Jdk 11中已经移除，如果要使⽤，需要单独引⼊jar包
    在这里插入图片描述

纯注解模式

改造xm+注解模式，将xml中遗留的内容全部以注解的形式迁移出去，最终删除xml，从Java配置类启动
对应注解
@Configuration 注解，表名当前类是⼀个配置类
@ComponentScan 注解，替代 context:component-scan
@PropertySource，引⼊外部属性配置⽂件
@Import 引⼊其他配置类
@Value 对变量赋值，可以直接赋值，也可以使⽤ ${} 读取资源配置⽂件中的信息
@Bean 将⽅法返回对象加⼊ SpringIOC 容器

Spring IOC⾼级特性

lazy-Init 延迟加载

Bean的延迟加载（延迟创建）
ApplicationContext 容器的默认⾏为是在启动服务器时将所有 singleton bean 提前进⾏实例化。提前实例化意味着作为初始化过程的⼀部分，ApplicationContext 实例会创建并配置所有的singleton
bean。
⽐如：在这里插入图片描述lazy-init=“false”，⽴即加载，表示在spring启动时，⽴刻进⾏实例化。
如果不想让⼀个singleton bean 在 ApplicationContext实现初始化时被提前实例化，那么可以将bean设置为延迟实例化。
在这里插入图片描述设置 lazy-init 为 true 的 bean 将不会在 ApplicationContext 启动时提前被实例化，⽽是第⼀次向容器通过 getBean 索取 bean 时实例化的。
如果⼀个设置了⽴即加载的 bean1，引⽤了⼀个延迟加载的 bean2 ，那么 bean1 在容器启动时被实例
化，⽽ bean2 由于被 bean1 引⽤，所以也被实例化，这种情况也符合延时加载的 bean 在第⼀次调⽤时才被实例化的规则。也可以在容器层次中通过在 元素上使⽤ “default-lazy-init” 属性来控制延时初始化。如下⾯配置：在这里插入图片描述如果⼀个 bean 的 scope 属性为 scope=“pototype” 时，即使设置了 lazy-init=“false”，容器启动时也不会实例化bean，⽽是调⽤ getBean ⽅法实例化的。

应⽤场景
（1）开启延迟加载⼀定程度提⾼容器启动和运转性能
（2）对于不常使⽤的 Bean 设置延迟加载，这样偶尔使⽤的时候再加载，不必要从⼀开始该 Bean 就占⽤资源

FactoryBean 和 BeanFactory

BeanFactory接⼝是容器的顶级接⼝，定义了容器的⼀些基础⾏为，负责⽣产和管理Bean的⼀个⼯⼚，具体使⽤它下⾯的⼦接⼝类型，⽐如ApplicationContext；此处我们重点分析FactoryBean
Spring中Bean有两种，⼀种是普通Bean，⼀种是⼯⼚Bean（FactoryBean），FactoryBean可以⽣成某⼀个类型的Bean实例（返回给我们），也就是说我们可以借助于它⾃定义Bean的创建过程。
Bean创建的三种⽅式中的静态⽅法和实例化⽅法和FactoryBean作⽤类似，FactoryBean使⽤较多，尤其在Spring框架⼀些组件中会使⽤，还有其他框架和Spring框架整合时使⽤在这里插入图片描述Company类在这里插入图片描述在这里插入图片描述CompanyFactoryBean类在这里插入图片描述在这里插入图片描述xml配置在这里插入图片描述测试，获取FactoryBean产⽣的对象在这里插入图片描述测试，获取FactoryBean，需要在id之前添加“&”在这里插入图片描述

后置处理器

Spring提供了两种后处理bean的扩展接⼝，分别为BeanPostProcessor 和BeanFactoryPostProcessor，两者在使⽤上是有所区别的。
⼯⼚初始化（BeanFactory）—> Bean对象
在BeanFactory初始化之后可以使⽤BeanFactoryPostProcessor进⾏后置处理做⼀些事情
在Bean对象实例化（并不是Bean的整个⽣命周期完成）之后可以使⽤BeanPostProcessor进⾏后置处理做⼀些事情
注意：对象不⼀定是springbean，⽽springbean⼀定是个对象
SpringBean的⽣命周期

BeanPostProcessor

BeanPostProcessor是针对Bean级别的处理，可以针对某个具体的Bean.
在这里插入图片描述该接⼝提供了两个⽅法，分别在Bean的初始化⽅法前和初始化⽅法后执⾏，具体这个初始化⽅法指的是什么⽅法，类似我们在定义bean时，定义了init-method所指定的⽅法
定义⼀个类实现了BeanPostProcessor，默认是会对整个Spring容器中所有的bean进⾏处理。如果要对具体的某个bean处理，可以通过⽅法参数判断，两个类型参数分别为Object和String，第⼀个参数是每个bean的实例，第⼆个参数是每个bean的name或者id属性的值。所以我们可以通过第⼆个参数，来判断我们将要处理的具体的bean。
注意：处理是发⽣在Spring容器的实例化和依赖注⼊之后。

BeanFactoryPostProcessor

BeanFactory级别的处理，是针对整个Bean的⼯⼚进⾏处理，典型应⽤:PropertyPlaceholderConfigurer在这里插入图片描述在这里插入图片描述其中有个⽅法名为getBeanDefinition的⽅法，我们可以根据此⽅法，找到我们定义bean 的BeanDefinition对象。然后我们可以对定义的属性进⾏修改，以下是BeanDefinition中的⽅法
在这里插入图片描述⽅法名字类似我们bean标签的属性，setBeanClassName对应bean标签中的class属性，所以当我们拿到BeanDefinition对象时，我们可以⼿动修改bean标签中所定义的属性值。
BeanDefinition对象：我们在 XML 中定义的 bean标签，Spring 解析 bean 标签成为⼀个 JavaBean，这个JavaBean 就是 BeanDefinition
注意：调⽤ BeanFactoryPostProcessor ⽅法时，这时候bean还没有实例化，此时 bean 刚被解析成BeanDefinition对象

Spring IoC容器初始化主体流程

Spring IoC的容器体系

IoC容器是Spring的核⼼模块，是抽象了对象管理、依赖关系管理的框架解决⽅案。Spring 提供了很多的容器，其中 BeanFactory 是顶层容器（根容器），不能被实例化，它定义了所有 IoC 容器 必须遵从的⼀套原则，具体的容器实现可以增加额外的功能，⽐如我们常⽤到的ApplicationContext，其下更具体的实现如 ClassPathXmlApplicationContext 包含了解析 xml 等⼀系列的内容，AnnotationConfigApplicationContext 则是包含了注解解析等⼀系的内容。Spring IoC 容器继承体系⾮常聪明，需要使⽤哪个层次⽤哪个层次即可，不必使⽤功能⼤⽽全的。
BeanFactory 顶级接⼝⽅法栈如下
在这里插入图片描述BeanFactory 容器继承体系在这里插入图片描述通过其接⼝设计，我们可以看到我们⼀贯使⽤的 ApplicationContext 除了继承BeanFactory的⼦接⼝，还继承了ResourceLoader、MessageSource等接⼝，因此其提供的功能也就更丰富了。
下⾯我们以 ClasspathXmlApplicationContext 为例，深⼊源码说明 IoC 容器的初始化流程。

Bean⽣命周期关键时机点

思路：创建⼀个类 LagouBean ，让其实现⼏个特殊的接⼝，并分别在接⼝实现的构造器、接⼝⽅法中断点，观察线程调⽤栈，分析出 Bean 对象创建和管理关键点的触发时机。
LagouBean类
在这里插入图片描述在这里插入图片描述BeanPostProcessor 接⼝实现类在这里插入图片描述BeanFactoryPostProcessor 接⼝实现类在这里插入图片描述applicationContext.xml在这里插入图片描述IoC 容器源码分析⽤例在这里插入图片描述（1）分析 Bean 的创建是在容器初始化时还是在 getBean 时
在这里插入图片描述根据断点调试，我们发现，在未设置延迟加载的前提下，Bean 的创建是在容器初始化过程中完成的。
（2）分析构造函数调⽤情况
在这里插入图片描述在这里插入图片描述通过如上观察，我们发现构造函数的调⽤时机在AbstractApplicationContext类refresh⽅法的finishBeanFactoryInitialization(beanFactory)处;
（3）分析 InitializingBean 之 afterPropertiesSet 初始化⽅法调⽤情况
在这里插入图片描述通过如上观察，我们发现 InitializingBean中afterPropertiesSet ⽅法的调⽤时机也是在AbstractApplicationContext类refresh⽅法的finishBeanFactoryInitialization(beanFactory);
（4）分析BeanFactoryPostProcessor 初始化和调⽤情况
分别在构造函数、postProcessBeanFactory ⽅法处打断点，观察调⽤栈，发现
BeanFactoryPostProcessor 初始化在AbstractApplicationContext类refresh⽅法的
invokeBeanFactoryPostProcessors(beanFactory);
postProcessBeanFactory 调⽤在AbstractApplicationContext类refresh⽅法的
invokeBeanFactoryPostProcessors(beanFactory);
（5）分析 BeanPostProcessor 初始化和调⽤情况
分别在构造函数、postProcessBeanFactory ⽅法处打断点，观察调⽤栈，发现
BeanPostProcessor 初始化在AbstractApplicationContext类refresh⽅法的registerBeanPostProcessors(beanFactory);
postProcessBeforeInitialization 调⽤在AbstractApplicationContext类refresh⽅法的finishBeanFactoryInitialization(beanFactory);
postProcessAfterInitialization 调⽤在AbstractApplicationContext类refresh⽅法的
finishBeanFactoryInitialization(beanFactory);
（6）总结
根据上⾯的调试分析，我们发现 Bean对象创建的⼏个关键时机点代码层级的调⽤都在AbstractApplicationContext 类 的 refresh ⽅法中，可⻅这个⽅法对于Spring IoC 容器初始化来说相当关键，汇总如下：在这里插入图片描述

Spring IoC容器初始化主流程

由上分析可知，Spring IoC 容器初始化的关键环节就在 AbstractApplicationContext#refresh() ⽅法中，我们查看 refresh ⽅法来俯瞰容器创建的主体流程，主体流程下的具体⼦流程我们后⾯再来讨论。
在这里插入图片描述在这里插入图片描述在这里插入图片描述

BeanFactory创建流程

获取BeanFactory⼦流程

时序图如下
在这里插入图片描述

BeanDefinition加载解析及注册⼦流程

（1）该⼦流程涉及到如下⼏个关键步骤
Resource定位：指对BeanDefinition的资源定位过程。通俗讲就是找到定义Javabean信息的XML⽂件，并将其封装成Resource对象。
BeanDefinition载⼊ ：把⽤户定义好的Javabean表示为IoC容器内部的数据结构，这个容器内部的数据结构就是BeanDefinition。
注册BeanDefinition到 IoC 容器
（2）过程分析
Step 1：⼦流程⼊⼝在AbstractRefreshableApplicationContext#refreshBeanFactory ⽅法中
在这里插入图片描述
Step 2：依次调⽤多个类的 loadBeanDefinitions ⽅法 —> AbstractXmlApplicationContext —>AbstractBeanDefinitionReader —> XmlBeanDefinitionReader ⼀直执⾏到XmlBeanDefinitionReader 的 doLoadBeanDefinitions ⽅法在这里插入图片描述Step 3：我们重点观察XmlBeanDefinitionReader 类的registerBeanDefinitions ⽅法，期间产⽣了多次重载调⽤，我们定位到最后⼀个在这里插入图片描述此处我们关注两个地⽅：⼀个createRederContext⽅法，⼀个是
DefaultBeanDefinitionDocumentReader类的registerBeanDefinitions⽅法，先进⼊createRederContext ⽅法看看在这里插入图片描述我们可以看到，此处 Spring ⾸先完成了NamespaceHandlerResolver 的初始化。
我们再进⼊ registerBeanDefinitions ⽅法中追踪，调⽤了
DefaultBeanDefinitionDocumentReader#registerBeanDefinitions ⽅法
在这里插入图片描述进⼊ doRegisterBeanDefinitions ⽅法在这里插入图片描述进⼊ parseBeanDefinitions ⽅法在这里插入图片描述进⼊ parseDefaultElement ⽅法在这里插入图片描述进⼊ processBeanDefinition ⽅法在这里插入图片描述⾄此，注册流程结束，我们发现，所谓的注册就是把封装的 XML 中定义的 Bean信息封装为BeanDefinition 对象之后放⼊⼀个Map中，BeanFactory 是以 Map 的结构组织这些 BeanDefinition的。在这里插入图片描述可以在DefaultListableBeanFactory中看到此Map的定义在这里插入图片描述（3）时序图
在这里插入图片描述

Bean创建流程

  • 通过最开始的关键时机点分析，我们知道Bean创建⼦流程⼊⼝在AbstractApplicationContext#refresh()⽅法的finishBeanFactoryInitialization(beanFactory)处在这里插入图片描述

  • 进⼊finishBeanFactoryInitialization在这里插入图片描述

  • 继续进⼊DefaultListableBeanFactory类的preInstantiateSingletons⽅法，我们找到下⾯部分的代码，看到⼯⼚Bean或者普通Bean，最终都是通过getBean的⽅法获取实例在这里插入图片描述

  • 继续跟踪下去，我们进⼊到了AbstractBeanFactory类的doGetBean⽅法，这个⽅法中的代码很多，我们直接找到核⼼部分在这里插入图片描述

  • 接着进⼊到AbstractAutowireCapableBeanFactory类的⽅法，找到以下代码部分在这里插入图片描述

  • 进⼊doCreateBean⽅法看看，该⽅法我们关注两块重点区域在这里插入图片描述

lazy-init 延迟加载机制原理

  • lazy-init 延迟加载机制分析
    普通 Bean 的初始化是在容器启动初始化阶段执⾏的，⽽被lazy-init=true修饰的 bean 则是在从容器⾥第⼀次进⾏context.getBean() 时进⾏触发。Spring 启动的时候会把所有bean信息(包括XML和注解)解析转化成Spring能够识别的BeanDefinition并存到Hashmap⾥供下⾯的初始化时⽤，然后对每个BeanDefinition 进⾏处理，如果是懒加载的则在容器初始化阶段不处理，其他的则在容器初始化阶段进⾏初始化并依赖注⼊。在这里插入图片描述在这里插入图片描述

  • 总结
    对于被修饰为lazy-init的bean Spring 容器初始化阶段不会进⾏ init 并且依赖注⼊，当第⼀次进⾏getBean时候才进⾏初始化并依赖注⼊
    对于⾮懒加载的bean，getBean的时候会从缓存⾥头获取，因为容器初始化阶段 Bean 已经初始化完成并缓存了起来

Spring IoC循环依赖问题

什么是循环依赖

循环依赖其实就是循环引⽤，也就是两个或者两个以上的 Bean 互相持有对⽅，最终形成闭环。⽐如A依赖于B，B依赖于C，C⼜依赖于A。
在这里插入图片描述注意，这⾥不是函数的循环调⽤，是对象的相互依赖关系。循环调⽤其实就是⼀个死循环，除⾮有终结条件。
Spring中循环依赖场景有：

  • 构造器的循环依赖（构造器注⼊）
  • Field 属性的循环依赖（set注⼊）
    其中，构造器的循环依赖问题⽆法解决，只能拋出 BeanCurrentlyInCreationException 异常，在解决属性循环依赖时，spring采⽤的是提前暴露对象的⽅法。

循环依赖处理机制

  • 单例 bean 构造器参数循环依赖（⽆法解决）

  • prototype 原型 bean循环依赖（⽆法解决）
    对于原型bean的初始化过程中不论是通过构造器参数循环依赖还是通过setXxx⽅法产⽣循环依赖，Spring都 会直接报错处理。
    AbstractBeanFactory.doGetBean()⽅法：在这里插入图片描述在这里插入图片描述在获取bean之前如果这个原型bean正在被创建则直接抛出异常。原型bean在创建之前会进⾏标记这个beanName正在被创建，等创建结束之后会删除标记在这里插入图片描述总结：Spring 不⽀持原型 bean 的循环依赖。

  • 单例bean通过setXxx或者@Autowired进⾏循环依赖
    Spring 的循环依赖的理论依据基于 Java 的引⽤传递，当获得对象的引⽤时，对象的属性是可以延后设置的，但是构造器必须是在获取引⽤之前
    Spring通过setXxx或者@Autowired⽅法解决循环依赖其实是通过提前暴露⼀个ObjectFactory对象来完成的，简单来说ClassA在调⽤构造器完成对象初始化之后，在调⽤ClassA的setClassB⽅法之前就把ClassA实例化的对象通过ObjectFactory提前暴露到Spring容器中。
    Spring容器初始化ClassA通过构造器初始化对象后提前暴露到Spring容器。在这里插入图片描述ClassA调⽤setClassB⽅法，Spring⾸先尝试从容器中获取ClassB，此时ClassB不存在Spring容器中。
    Spring容器初始化ClassB，同时也会将ClassB提前暴露到Spring容器中
    ClassB调⽤setClassA⽅法，Spring从容器中获取ClassA ，因为第⼀步中已经提前暴露了ClassA，因此可以获取到ClassA实例
    ClassA通过spring容器获取到ClassB，完成了对象初始化操作。
    这样ClassA和ClassB都完成了对象初始化操作，解决了循环依赖问题。

豆豆种在春天里
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
IOC之深入理解SpringIoC
02-24
理解好它的关键在于我们需要回答如下四个问题：谁控制谁控制什么为何是反转哪些方面反转了在回答这四个问题之前，我们先看IOC的定义：所谓IOC，就是由SpringIOC容器来负责对象的生命周期和对象之间的关系上面这句话...
深入理解IOC
一只弱渣
04-08 175
在最开始的业务中，用户的需求可能会影响原来的代码，这个时候就需要程序员根据用户需求去修改源码 举个栗子： 在一次普通的程序设计中，我们会有以下几个部件： UserMapper 接口 public interface UserMapper { void getUser(); } UserMapperImpl 接口实现类 public class UserMapperImpl implements UserMapper { public void getUser(){ System.o
SpringIOC和AOP理解之深入浅出（建议收藏）
weixin_45105261的博客
01-13 6797
Spring框架介绍 概念：Spring是一个开源的框架，并且是一个轻量级的java开发框架 前身：interface21是他的前身 Spring理念：使现有的技术更加容易使用，本身就是一个大杂烩，整合了现有的主流技术框架 优点： 方便解耦，简化开发 （高内聚低耦合） Spring就是一个大工厂（容器），可以将所有对象创建和依赖关系维护，交给Spring管理 spring工厂是用于生成bean AOP编程的支持 Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能 声明式事务的支
转：如何通俗的理解Spring的控制反转IOC
季小沫的博客
09-17 875
1. IoC理论的背景 我们都知道，在采用面向对象方法设计的软件系统中，它的底层实现都是由N个对象组成的，所有的对象通过彼此的合作，最终实现系统的业务逻辑。 图1：软件系统中耦合的对象 如果我们打开机械式手表的后盖，就会看到与上面类似的情形，各个齿轮分别带动时针、分针和秒 针顺时针旋转，从而在表盘上产生正确的时间。图1中描述的就是这样的一个齿轮组，它拥有多个独立的齿轮，这些齿轮相互啮合在...
Spring ioc深入理解
feicongcong的博客
10-15 265
http://www.cnblogs.com/ITtangtang/p/3978349.html IOC/DI:控制反转/依赖注入 对象创建、依赖通过外部容器ioc容器以注入的方式实现 Spring IOC体系结构？ (1) BeanFactory          Spring Bean的创建是典型的工厂模式，这一系列的Bean工厂，也即IOC容器为开发者管理对象间的依赖关
spring Ioc 容器深入理解<一>
花裤衩
09-08 1495
IoC 概述     IOC是spring的内核，Aop、声明式事务都能功能都依赖于此功能，它涉及代码解耦，设计模式，代码优化的问题的考量。 ioc的初步理解     ioc的概念重要但比较晦涩难懂，如下通过一个小例子来说明这个概念：     示例场景：电影： 无间道-》角色：刘建明-》演员：刘德华     刘德华饰演的刘建明和梁朝
SPRING IOC注入方式过程解析
08-25
主要介绍了SPRING IOC注入方式过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring中IoC优点与缺点解析
08-28
主要为大家详细解析了Spring中IoC优点与缺点，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
详解Spring IOC 容器启动流程分析
08-25
主要介绍了Spring IOC 容器启动流程分析,本文给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友可以参考下
细说Spring——IoC详解（深入IoC实现）
啦啦啦的博客
05-12 3995
容器启动阶段我们可以其实可以偷偷做一些事情 书接上文：细说Spring——IoC详解（一），我们已经知道了容器实现控制反转和依赖注入的过程可以分为两个阶段： 容器启动阶段 Bean的实例化阶段 其实在这个两个阶段我们都可以偷偷的做一些事情，我们可以根据具体的场景加入自定义的扩展逻辑，下面我们就来了解一下容器启阶段我们可以做哪些事情。 Spring提供了一种叫做BeanFactoryPo...
【SSH系列】深入浅出spring IOC中三种依赖注入方式
从手指到键盘，谱出生命的轨迹~~~
07-18 6448
spring的核心思想是IOC和AOP，IOC-控制反转，是一个重要的面向对象编程的法则来消减计算机程序的耦合问题，控制反转一般分为两种类型，依赖注入和依赖查找，依赖什么？为什么需要依赖？注入什么？控制什么？依赖注入和控制反转是一样的概念吗？接触新的知识，小编的脑袋中全是大大的问号，不过没有关系，今天这篇博文，小编主要来简单的介绍一下在spring IOC中依赖注入的方法。 依赖注入和控制反转，目
2、【死磕 Spring】——IoC之深入理解Spring IoC
a1290123825的博客
12-24 2663
本文主要基于 Spring 5.0.6.RELEASE 摘要: 原创出处http://cmsblogs.com/?p=2652「小明哥」，谢谢！ 在一开始学习 Spring 的时候，我们就接触 IoC 了，作为 Spring 第一个最核心的概念，我们在解读它源码之前势必需要对其有深入的认识，本篇为【死磕 Spring】系列博客的第一篇博文，主要介绍 IoC 基本概念和各个组件。 1. I...
spring IOC的好处
ustcyy91的博客
06-06 2313
作者：Sevenvidia 链接：https://www.zhihu.com/question/23277575/answer/169698662 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 要了解控制反转( Inversion of Control ), 我觉得有必要先了解软件设计的一个重要思想：依赖倒置原则（Dependency Inver
android高斯模糊填充imageview背景
cf8833的博客
05-21 558
说明：最近碰到一个需求，安卓app显示在线的url图片，然后imageview没占满的部分，使用该图片的模糊背景填充。
Spring Bean Map之舞
m0_51176516的博客
05-23 491
在Spring框架中，Bean的生命周期管理是其核心功能之一。当Spring容器启动时，它会根据配置信息（如XML配置文件、注解等）来创建和管理Bean实例。这些Bean实例默认会被放置在一个Map数据结构中，以便容器能够快速地根据Bean的名称（或ID）来查找和访问它们。 在Spring的源码中，Bean实例的存储和管理主要依赖于DefaultSingletonBeanRegistry类。这个类内部使用了一个名为singletonObjects的Map来存储单例Bea...
SpringBoot Validation自定义注解之校验指定最小整数
thinkers
05-21 230
1，引入核心关键依赖。
深入理解Java的垃圾回收机制（GC）实现原理
最新发布
微笑听雨
05-25 784
GC是Java虚拟机的重要组成部分，通过自动内存管理，GC提高了Java程序的稳定性和安全性。理解GC的工作原理和不同收集器的特点，有助于选择合适的GC策略，优化应用性能。通过合理配置JVM参数，可以提高GC效率，减少应用停顿时间，提升系统的整体性能。
微信小程序uniapp+django洗脚按摩足浴城消费系统springboot
QQ1304979694的博客
05-24 511
Python语言官方规范访问数据库的统一接口规范(Python DB-API)，防止在使用不同数据库时，由于底层数据库技术不同造成接口程序紊乱的问题。（3）项目初期开发，美工设计，前端实现，开发信息系统的用户功能的实现，完善界面排版，实现信息提取发送等一系列功能。项目系统最后阶段的修改及最终测试运行。当然，在研究过程中也可以直接调查，对调查搜集到的资料进行综合分析、比较，调查法是科学研究中普遍的研究方法。（5）系统测试：对设计好的程序进行最终调试，通过调试发现存在的问题并解决，从而达到完善系统的目的。
Spring IOC深入理解使用
08-24
Spring IOC（Inversion of Control，控制反转）是Spring框架的核心特性之一，它通过将对象的创建和依赖关系的管理交给Spring容器来实现，降低了组件之间的耦合性。下面是Spring IOC的一些深入理解和使用方法： 1. 配置方式：Spring IOC提供了多种配置方式，包括XML配置、注解配置和Java配置。XML配置是最传统和常用的方式，可以通过在XML文件中定义bean来描述对象及其依赖关系；注解配置使用注解来标识对象及其依赖关系，更加简洁和方便；Java配置则是通过Java类来定义对象及其依赖关系。 2. Bean的定义：在Spring IOC中，对象称为Bean。Bean的定义包括类名、属性、构造函数参数等信息。在XML配置中，可以使用<bean>标签来定义Bean；在注解配置中，可以使用@Component等注解来标识Bean。 3. 依赖注入：Spring IOC通过依赖注入（Dependency Injection，DI）来管理对象之间的依赖关系。依赖注入可以通过构造函数注入、Setter方法注入和字段注入来实现。当Spring容器创建一个Bean时，会自动将其依赖的其他Bean注入进来。 4. 生命周期管理：Spring IOC容器负责管理Bean的生命周期。在Bean生命周期中，容器会在适当的时机调用Bean的初始化方法和销毁方法。可以通过在Bean类中定义@PostConstruct和@PreDestroy等注解方法来指定初始化和销毁方法。 5. AOP支持：Spring IOC提供了对面向切面编程（AOP）的支持。可以通过配置切面和增强器，将一些横切关注点（如日志、事务管理等）从业务逻辑中剥离出来，实现更好的代码解耦和复用。 6. 容器扩展点：Spring IOC容器提供了一些扩展点，可以通过实现相应的接口来对容器的行为进行定制。例如，可以实现BeanPostProcessor接口来在对象创建和初始化的过程中添加自定义逻辑。 总之，深入理解和使用Spring IOC可以帮助开发者更好地利用Spring框架的优势，实现松耦合、可测试、可扩展的应用程序。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值