【源码】spring循环引用

spring在单例，非构造方法注入的情况下允许循环依赖

1.循环依赖

a引用b，b引用a。a创建的时候需要b，但是b没有创建，需要先去创建b，b创建的时候又没有a，这就出现的循环依赖的问题

2.为什么单例，setter注入才能解决？

（1）构造器注入是在实例化对象时反射调用构造器去注入参数，所以既然beanA、beanB的都拿不到完整的依赖，就会进行无限的循环调用。setter注入方式 setter注入方式就是new出一个对象后，调用该对象的set方法对属性进行赋值。此时对象已经被new出来了，只不过是不完整而已。 如果出现了循环依赖的问题，这就要比构造器注入的方式好的多 所以Spring对于循环依赖问题的解决就是针对于setter方法的

（2）多例的bean是不需要放入到IOC容器中的

3.三级缓存

spring解决循环依赖主要是通过三级缓存

        // 用于存储完整的bean，接下来称之为【一级缓存】
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

        // 用于存储不完整的bean，完成实例化，但是还未进行属性注入及初始化的对象，接下来称之为【二级缓存】
	private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

        //提前暴露的一个单例工厂，二级缓存中存储的就是从这个工厂中获取到的对象，接下来称之为【三级缓存】
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

4.基本流程

（1）当创建A对象的时候，会调用getBeanSington()方法，也就是去单例池（一级缓存）中查找有没有A的Bean，A还没创建成功，肯定没有。

（2）调用下一个getBeanSington()方法，判断A对象是否正在被创建，也就是去查找set集合中有没有A对象，这时候也没有，然后将A加入set集合中

（3）判断是否支持循环依赖，是否是单例，是否允许提前暴露。是的话将A实例（反射空参构造。只实例化，没有属性注入）放入singltonFactors三级缓存，其实这儿存的是一个工厂，后面就是通过这个工厂获取对象的

（4）A开始注入属性B

（5）流程和前面一样，这样的话三级缓存里就有了A和B

（8）B也开始注入属性A

（9）去单例池获取A的Bean，没有获取到

（10）去set集合中获取A对象，获取到了，说明A正在被创建

（11）依次去二级缓存，三级缓存获取A

（12）在三级缓存获取到A对象工厂，调用工厂的方法获取到A对象（如果A对象做了代理，就会在这儿进行代理），A对象放到二级缓存

（13）B对象注入属性A完成(此时A对象还没有完成属性注入，B只是持有A的一个引用)，B进入单例池

（14）A对象此时就能从单例池中获取到B对象

（15）A对象完成初始化

         protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {

               // 默认调用无参构造实例化Bean
		// 构造方法的依赖注入，就是发生在这一步
		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		// 实例化后的Bean对象，这里获取到的是一个原始对象，即没有进行属性填充的对象
		final Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();

                 //......

		// 解决循环依赖的关键步骤
               // earlySingletonExposure：是否”提前暴露“原始对象的引用
               // 因为不论这个bean是否完整，他前后的引用都是一样的，所以提前暴露的引用到后来也指向完整的bean
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		// 如果需要提前暴露单例bean，则将该bean工厂放入【三级缓存】中
		if (earlySingletonExposure) {
			// 将刚创建的bean工厂放入三级缓存中singleFactories(key是beanName，value是FactoryBean)
                       // 同样也会移除【二级缓存】中对应的bean，即便没有
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
            //填充属性(依赖注入)
			populateBean(beanName, mbd, instanceWrapper);
			//调用初始化方法，完成bean的初始化操作
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		//......

		return exposedObject;
	}

5.为什么要使用三级缓存呢？二级缓存能解决循环依赖吗？

如果要使用二级缓存解决循环依赖，意味着所有Bean在实例化后就要完成AOP代理，这样违背了Spring设计的原则，Spring在设计之初就是通过AnnotationAwareAspectJAutoProxyCreator这个后置处理器来在Bean生命周期的最后一步来完成AOP代理，而不是在实例化后就立马进行AOP代理。