8.5 Spring解决循环依赖的原理(非AOP)

我们重点进入 valueResolver.resolveValueIfNecessary(pv, originalValue); 方法

//返回一个属性对象（此时我们要去获取 b 对象）
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
1
2

直接进入 resolveReference(argName, ref);

重点 bean = this.beanFactory.getBean(resolvedName); 返回一个bean对象，

直接进入 bean = this.beanFactory.getBean(resolvedName); 方法

我们发现又回到了doGetBean 方法，更 A 对象一样的去获取 B 对象

一句话

• 先去一级缓存寻找 A ，没有去创建 A， 然后 A 将自己放到三级缓存中，初始化的时候需要 B ，去创建 B

5、源码分析-2

以下一句话

• B 实例化同理 A （实例化后， B 放入到了 三级缓存），B 初始化的时候发现需要 A ，于是 B 先查一级缓存，没有，再查二级缓存，还是没有，再查三级缓存，找到了 A 然后把三级中的 A 放入二级缓存里面，并删除三级缓存中的 A

我们跳到对 b 对象的赋值操作，去获取 b 对象的属性 a 对象

//去获取 a 对象
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
1
2

在进入 BeanDefinitionValueResolver 的 resolveReference(argName, ref);

同理的 进入 resolveReference 方法去获取 a 对象

	@Nullable
	private Object resolveReference(Object argName, RuntimeBeanReference ref) {
        //...
        bean = this.beanFactory.getBean(resolvedName);
    }
1
2
3
4
5

我们此时到了 getSingleton(String beanName, boolean allowEarlyReference) 方法中。

我们获取 A 对象，先查一级缓存，没有，再查二级缓存，还是没有，再查三级缓存，找到了 A 然后把三级中的 A 放入二级缓存里面，并删除三级缓存中的 A

@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
   // Quick check for existing instance without full singleton lock
   Object singletonObject = this.singletonObjects.get(beanName);
   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
      singletonObject = this.earlySingletonObjects.get(beanName);
      if (singletonObject == null && allowEarlyReference) {
         synchronized (this.singletonObjects) {
            // Consistent creation of early reference within full singleton lock
             //先从一级缓存获取
            singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
                //再从二级缓存获取
               singletonObject = this.earlySingletonObjects.get(beanName);
               if (singletonObject == null) {
                   //再从三级缓存获取 a 的工厂
                  ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                  if (singletonFactory != null) {
                      //从整个的三级缓存(单例工厂)中获取 a 对象然后放入二级缓存，然后从当前三级缓存删除该对象
                     singletonObject = singletonFactory.getObject();
                     this.earlySingletonObjects.put(beanName, singletonObject);
                     this.singletonFactories.remove(beanName);
                  }
               }
            }
         }
      }
   }
   return singletonObject;//返回bean对象
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

6、源码分析-3

以下一句话

• B 顺利初始化完毕，将自己放到一级缓存里面（此时 B 里面的 A 依然是创建中的状态），再删除三级缓存中的 B 和 尝试去删除二级缓存中的 B （此时二级缓存中只有 A ）

从以上获取到 bean 对象后（a） ，一层一层的返回，

此时 Object resolvedValue = a 对象，将 a 对象赋值给 b 对象的 a 属性

	// 将解析、转换好的属性设置到BeanWrapper中
	//之所以bean需要BeanWrapper包装一次，也是为了方便给bean填充属性
	try {
		bw.setPropertyValues(new MutablePropertyValues(deepCopy));
    }
1
2
3
4
5

我们发现 b 的包装类 BeanWrapper 中含有了 a 对象

此时 b 完成了对属性的赋值

	protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {	
        //....
        //此时完成了这一步赋值
		populateBean(beanName, mbd, instanceWrapper);
        //然后接着去完成 b 对象的后续生命周期
		exposedObject = initializeBean(beanName, exposedObject, mbd);
        //...
        return exposedObject;//返回 b 对象
	}
1
2
3
4
5
6
7
8
9

不断的返回到

singletonObject = singletonFactory.getObject();
1

	protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
            //将 b 对象加入到 一级缓存中
			this.singletonObjects.put(beanName, singletonObject);
			//删除三级缓存中的 b 对象
			this.singletonFactories.remove(beanName);
            //尝试去删除二级缓存中的 b 对象
            //（此时二级缓存中只有 a 对象）
			this.earlySingletonObjects.remove(beanName);
			this.registeredSingletons.add(beanName);
		}
	}
1
2
3
4
5
6
7
8
9
10
11
12

此时B 顺利初始化完毕，将自己放到一级缓存里面（此时 B 里面的 A 依然是创建中的状态），再删除三级缓存中的 B 和 尝试去删除二级缓存中的 B （此时二级缓存中只有 A ）

7、源码分析-4

以下一句话

• 然后回来接着创建 A ，此时 B 已经创建结束，直接从一级缓存里面拿到 B ，然后 完成创建， 并将 A 自己放入到一级缓存里面

从以上不断的返回至

Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
1

给 a 对象属性的 b 属性赋值为 resolvedValue

其中 的 BeanWrapperImpl 就是 a 的包装类

a 对象注入属性完毕之后，然后去从缓存中获取 a 对象，此时 a 对象直接从二级缓存中获取

此时将返回的 a 对象放入到一级缓存中，删除三级缓存中的 a (此时三级缓存中没有 a)，删除二级缓存中的a。

最后完成了 a b 对象的依赖（最后全部放入到了一级缓存）

8、小总结

通过源码分析，其实单纯的循环依赖二/一级缓存也可以解决（只不过一级会覆盖中间态），但是用三级缓存有其他的作用（主要为了解决aop增强的问题，所以三级缓存的Value是objectFactory）。

• Spring 创建bean主要分为两个步骤，创建原始bean对象，接着去填充对象属性和初始化

• 每次创建 bean之前，我们都会从缓存中查下有没有该bean，因为是单例，只能有一个

• 当我们创建beanA的原始对象后，并把它放到三级缓存中，接下来就该填充对象属性了，这时候发现依赖了beanB，接着就又去创建beanB，同样的流程，创建完beanB填充属性时又发现它依赖了beanA又是同样的流程，

• $不同的是$

  • 这时候可以在三级缓存中查到刚放进去的原始对象beanA，所以不需要继续创建，用它注入 beanB，完成beanB的创建

  • 既然 beanB创建好了，所以 beanA就可以完成填充属性的步骤了，接着执行剩下的逻辑，闭环完成

• Spring解决循环依赖依靠的是Bean的"$中间态$"这个概念，
  • 而这个中间态指的是$已经实例化但还没初始化的状态->半成品$。

实例化的过程又是通过构造器创建的，如果A还没创建好出来怎么可能提前曝光，所以构造器的循环依赖无法解决。

Spring为了解决单例的循环依赖问题，使用了三级级存。

• 其中一级缓存为单例池（ singletonObjects)

• 二级缓存为提前曝光对象( earlySingletonObjects)

• 三级缓存为提前曝光对象工厂( singletonFactories） 。

假设A、B循环引用，实例化A的时候就将其放入三级缓存中，接着填充属性的时候，发现依赖了B，同样的流程也是实例化后放入三级缓存接着去填充属性时又发现自己依赖A，这时候从缓存中查找到早期暴露的A，没有AOP代理的话，直接将A的原始对象注入B，完成B的初始化后，进行属性填充和初始化，这时候B完成后，就去完成剩下的A的步骤，如果有AOP代理，就进行AOP处理获取代理后的对象A，注入B，走剩下的流程。

9、分析流程图