【Spring】三、SpringIOC Bean的初始化流程-循环依赖

逃离我推掉我的手 2023-10-09 14:16 45阅读 0赞

[**上一篇: 【Spring】二、SpringIOC Bean的初始化流程**][_Spring_SpringIOC Bean]

#### 文章目录 ####

*  一、循环依赖现象理解
 *  二、模拟与理解分析
 *   *  1、三级缓存
     *  2、其余缓存
     *  3、流程梳理
     *  4、循环依赖支持条件：

## 一、循环依赖现象理解 ##

*  Spring bean的创建，本质上是一个对象的创建；
 *  一个完整的对象包含两部分：当前对象和对象的属性所依赖的另一个对象；  
    对象实例化通过反射实现，而对象的属性实例化通过依赖注入实现；
 *  Spring实例化bean是通过ApplicationContext.getBean()方法来进行的，如果要获取的对象又依赖了另一个对象，那么其首先会创建当前对象，然后通过递归调用ApplicationContext.getBean()方法来获取所依赖的对象，最后将获取到的对象注入到当前对象中；

## 二、模拟与理解分析 ##

### 1、三级缓存 ###

***spring内部有三级缓存：***

*  **singletonObjects** 一级缓存，用于保存实例化、注入、初始化完成的bean实例。
 *  **earlySingletonObjects** 二级缓存，用于保存实例化完成的bean实例。
 *  **singletonFactories** 三级缓存，用于保存bean创建工厂，以便于后面扩展有机会创建代理对象。

### 2、其余缓存 ###

![在这里插入图片描述][aa5d9493f2b44d3b936905d36a8c74b5.png_pic_center]

![在这里插入图片描述][5a4f2ded0fc2426f9b7c49eeb469a0df.png_pic_center]

### 3、流程梳理 ###

*  **现在有两个bean对象 MyBean、 HeBean**
 *  **前提：（HeBean 依赖 MyBean，MyBean依赖HeBean）**
 *  ***假设容器首先创建HeBean：***

1、创建HeBean对象：反射 （此时MyBean还没有创建）
      
      2、把“heBean”放入 singletonFactories的Map中；
      
       protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
        
    		Assert.notNull(singletonFactory, "Singleton factory must not be null");
    		synchronized (this.singletonObjects) {
        
    			if (!this.singletonObjects.containsKey(beanName)) {
        
    				this.singletonFactories.put(beanName, singletonFactory);
    				this.earlySingletonObjects.remove(beanName);
    				this.registeredSingletons.add(beanName);
    			}
    		}
    	}
      
      3、给heBean设置属性值（也就是给heBean的成员变量赋值）
      
      4、当HeBean依赖了MyBean，而MyBean还没有创建，此时HeBean无法完成属性赋值，HeBean还  是一个半成品，然后就跳到了：beanFactory.getBean(“myBean”); （递归到了获取bean的入口处）
      
      5、开始创建MyBean对象
          5.1、创建MyBean对象：反射 （此时HeBean是个半成品）
          
          5.2、把“myBean”放入 singletonFactories的Map
           	protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
        
    		Assert.notNull(singletonFactory, "Singleton factory must not be null");
    		synchronized (this.singletonObjects) {
        
    			if (!this.singletonObjects.containsKey(beanName)) {
        
    				this.singletonFactories.put(beanName, singletonFactory);
    				this.earlySingletonObjects.remove(beanName);
    				this.registeredSingletons.add(beanName);
    			}
    		}
    	}
           
          5.3、给myBean设置属性值（也就是给MyBean的成员变量赋值）
          5.4、MyBean此时是一个半成品，此时代码：
            //TODO 解析候选者bean，会调beanFactory.getBean()方法获取bean，该方法内部会进                  行初始化
            instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
           // 并没有完成heBean属性设置然后就跳到了：beanFactory.getBean(“heBean”);（递归到了获取bean的入口处）
            //去入口处：
           public Object resolveCandidate(String beanName, Class<?> requiredType,                  BeanFactory beanFactory) throws BeansException {
        
    		  // TODO 根据bean名称获取bean对象
    		  return beanFactory.getBean(beanName);
    	  }
          5.5、从这里获取heBean： 
             ObjectFactory<?> singletonFactory =
             this.singletonFactories.get(beanName);
             singletonObject = singletonFactory.getObject();
             
      6、把heBean放入earlySingletonObjects的map中
       @Nullable
    	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        
    		//从singletonObjects这个Map中获取bean对象，如果存在，则不需要创建
    		Object singletonObject = this.singletonObjects.get(beanName);
    		// 如果缓存中不存在目标对象，则判断当前对象是否已经处于创建过程中，在前面的第一次尝试获取该对象
    		// 的实例之后，就会将该对象标记为正在创建中，因而此处尝试获取该对象的时候，if判断就会为true
    		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        
    
    			synchronized (this.singletonObjects) {
        
    				singletonObject = this.earlySingletonObjects.get(beanName);
    
    				if (singletonObject == null && allowEarlyReference) {
        
    					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
    					if (singletonFactory != null) {
        
    						singletonObject = singletonFactory.getObject();
    						this.earlySingletonObjects.put(beanName, singletonObject);
    						this.singletonFactories.remove(beanName);
    					}
    				}
    			}
    		}
    		//返回单例bean对象
    		return singletonObject;
    	}
        
       7、回到入口处：
          public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory) throws BeansException {
        
    		// TODO 根据bean名称获取bean对象
    		return beanFactory.getBean(beanName);
    	}
       8、此时已经拿到了HeBean对象，反射调用：field.set(bean, value); 把MyBean对象的heBean属性赋值，此时MyBean对象就完全创建好了；
       
       9、把myBean放入ioc容器：
          	/**
    	 * Add the given singleton object to the singleton cache of this factory.
    	 * <p>To be called for eager registration of singletons.
    	 * @param beanName the name of the bean
    	 * @param singletonObject the singleton object
    	 */
    	protected void addSingleton(String beanName, Object singletonObject) {
        
    
    		synchronized (this.singletonObjects) {
        
    
    			//TODO bean保存在singletonObjects的Map中，key为bean的名称，value为bean对象实例
    			this.singletonObjects.put(beanName, singletonObject);
    			this.singletonFactories.remove(beanName);
    			this.earlySingletonObjects.remove(beanName);
    			this.registeredSingletons.add(beanName);
    		}
    	}
       10、返回到 resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory) 方法
       （相当于返回到创建HeBean的第4步，此时已经拿到mybean对象，通过反射调用field.set(bean, value);
       把heBean对象的mybean属性赋值，此时HeBean对象也就创建好了，放入ioc的map容器中）

### 4、循环依赖支持条件： ###

1、setter注入 支持  
2、构造方法注入 不支持  
3、bean的多例模式 不支持

[_Spring_SpringIOC Bean]: https://blog.csdn.net/weixin_43333483/article/details/125090031?spm=1001.2014.3001.5502
[aa5d9493f2b44d3b936905d36a8c74b5.png_pic_center]: https://img-blog.csdnimg.cn/aa5d9493f2b44d3b936905d36a8c74b5.png#pic_center
[5a4f2ded0fc2426f9b7c49eeb469a0df.png_pic_center]: https://img-blog.csdnimg.cn/5a4f2ded0fc2426f9b7c49eeb469a0df.png#pic_center

发表评论取消回复

表情：

评论列表（有 0 条评论，45人围观）

还没有评论，来说两句吧...

相关阅读

相关 Spring Beans 初始化流程分析

试用例依然使用这个官网上的用例，来进行调试； Person.java package org.shangyang.spring.container; ...

「爱情、让人受尽委屈。」/ 2024年04月19日 13:22/ 0 赞/ 169 阅读

相关【Spring】三、SpringIOC Bean的初始化流程-循环依赖

[上一篇: 【Spring】二、SpringIOC Bean的初始化流程][_Spring_SpringIOC Bean] 文章目录一、循环依赖现象理解

逃离我推掉我的手/ 2023年10月09日 14:16/ 0 赞/ 46 阅读

相关【Spring】二、SpringIOC Bean的初始化流程

上一篇：[【Spring】一、Spring注解真的你会用吗][Spring_Spring] 下一篇：[【Spring】三、SpringIOC Bean的初始化流程-循环依赖]

系统管理员/ 2023年10月09日 14:16/ 0 赞/ 116 阅读

相关 Spring-bean的循环依赖以及解决方式___Spring源码初探--Bean的初始化-循环依赖的解决

> 本文主要是分析Spring bean的循环依赖，以及Spring的解决方式。通过这种解决方式，我们可以应用在我们实际开发项目中。 > > 1. 什么是循环依赖？ >

喜欢ヅ旅行/ 2023年10月01日 08:38/ 0 赞/ 51 阅读

相关 Spring 如何解决 bean 的循环依赖？

原型模式下的循环依赖是无法无法解决的构造方法注入 + 单例模式，仅可以通过延迟加载解决 setter 方法和属性注入 + 单例模式下，可以解决核心逻辑如

心已赠人/ 2023年01月15日 02:12/ 0 赞/ 280 阅读

相关分析Spring单例Bean初始化和循环依赖解决方式

Spring IoC 容器会在运行时检测到构造函数注入循环引用，并抛出 BeanCurrentlyInCreationException。Spring 会自动解决基于 sett

朱雀/ 2022年11月19日 07:41/ 0 赞/ 261 阅读

相关关于Spring Bean循环依赖

Spring Bean循环依赖不一定需要三级缓存，实际上二级代理即可：直接在实例化原始对象的时候就建立代理对象；参考代码：[https://github.com/benyu

ゝ一纸荒年。/ 2022年10月16日 06:16/ 0 赞/ 244 阅读

相关 spring怎么解决bean的循环依赖

前言在实际工作中，经常由于设计不佳或者各种因素，导致类之间相互依赖。这些类可能单独使用时不会出问题，但是在使用Spring进行管理的时候可能就会抛出BeanCurren

╰半橙微兮°/ 2022年03月16日 19:48/ 0 赞/ 338 阅读

相关 Spring-bean循环依赖

循环依赖指的是两个或以上bean相互存在引用。 Spring中循环依赖的几种情况： 1.构造器参数循环依赖；无法解决，只能避免 2.setter方式，单例； 3.

深藏阁楼爱情的钟/ 2022年02月25日 05:16/ 0 赞/ 425 阅读

相关 Springboot 源码分析 —— bean 初始化流程、beanPostProcessor 用法、循环依赖

文章目录 1 问题来源 2 bean 初始化流程 2.1 getBean->doGetBean->createBean 2.2 cr

小灰灰/ 2022年02月02日 00:57/ 0 赞/ 145 阅读