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

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

一、循环依赖现象理解

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

二、模拟与理解分析

1、三级缓存

spring内部有三级缓存：

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

2、其余缓存

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的多例模式 不支持