spring源码剖析之spring bean循环依赖

spring bean循环依赖

spring bean循环依赖应该是spring 源码中比较难的一块知识了，下面我们结合代码还有时序图，来进行分析，看下spring 是如何优雅的处理spring bean的循环依赖的。

什么是bean的循环依赖

我们都知道spring的IOC 和DI，它可以帮助我们创建对象，并且可以帮我们自动注入需要spring管理的对象。然后会存在一种这样的情况，在对象 A 中需要依赖 B，而在对象 B 中有又依赖 A，当然可以有更多的对象依赖，他们之间会组成了一个闭环，如下图

在spring 初始化bean A的时候发现bean A依赖于bean B，然后去实例化bean B，实例化bean B的时候又发现bean B依赖于bean A…，这样陷入了一个无限循环的过程中，最终可能会导致内存溢出。当然，这只是我们的一个设想，spring当然不会让这样的事情发生。spring提供一个很优雅的方式来帮我们解决了bean之间循环依赖的问题，通过引入三级缓存机制来解决。
另外再说一点，不是所有的循环依赖spring 都可以解决，以下两种方式spring也是无法解决的

• 依赖是通过构造方法实现的
• scope 为prototype，也就是原型的情况

在正式开始之前，我们再说下spring的三级缓存以及定义
先来看下代码中是如何定义的

	/** Cache of singleton objects: bean name to bean instance. */
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

	/** Cache of singleton factories: bean name to ObjectFactory. */
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

	/** Cache of early singleton objects: bean name to bean instance. */
	private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

• singletonObjects 一级缓存， 用于存放完全初始化之后的bean，也就是说，所有的准备工作已经完成了，可以拿出来使用了
• earlySingletonObjects 二级缓存，存放原始的bean对象，这时候bean只是实例化完成，还没有进行属性设置等工作
• singletonFactories 三级缓存，存放只是实例化，还没有进行其它任何操作的bean对象

下面我们结合代码来做进一步的分析

依赖代码

bean A

创建类BeanA，然后通过set注入BeanB

public class BeanA {
   

	private BeanB beanB;

	public void setBeanB(BeanB beanB) {
   
		this.beanB = beanB;
	}
}

bean B

创建类BeanB，然后通过set注入BeanA

public class BeanB {
   

	private BeanA beanA;

	public void setBeanA(BeanA beanA) {
   
		this.beanA = beanA;
	}
}

配置文件applicationContext.xml

将BeanA 和BeanB 交给spring来进行管理

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xsi:schemaLocation="
	    http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

	<!--循环依赖问题-->
	<bean id="beanA" class="com.wtf.test.BeanA">
		<property name="beanB" ref="beanB"/>
	</bean>
	<bean id="beanB" class="com.wtf.test.BeanB">
		<property name="beanA" ref="beanA"/>
	</bean>
</beans>

测试代码

使用ClassPathXmlApplicationContext来初始化bean

public class BeanTest {
   

	public static void main(String[] args) {
   
		ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
		Object beanA = applicationContext.getBean("beanA");
		System.out.println(beanA);
	}
}

源码分析

循环依赖时序图

在分析源码前我们先来看下spring 循环依赖的时序图，对于后面我们分析源码会有很大的帮助
原始文件可以从这里下载

ClassPathXmlApplicationContext.java

我们调用了ClassPathXmlApplicationContext的带参构造方法，最终调用了下面的构造。这里完成了三件事：

1. super(parent)初始化父类
2. setConfigLocations(configLocations)设置本地的配置信息
3. refresh()完成spring容器的初始化

这里我们重点观察第三个方法，因为spring bean的初始化是在这里完成的

	public ClassPathXmlApplicationContext(
			String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
			throws BeansException {
   
		// 初始化父类
		super(parent);
		// 设置本地的配置信息
		setConfigLocations(configLocations);
		// 完成Spring容器的初始化
		if (refresh) {
   
			refresh();
		}
	}

AbstractApplicationContext.java

上面说了，refresh方法是初始化spring容器的，所以这是一个核心方法。这里面包含beanFactory 和bean的初始化操作，因为方法比较多，对每个方法都进行了注释，不一一赘述了，这里我们重点关注finishBeanFactoryInitialization()，这个方法做了一下操作

• 初始化所有剩下的非懒加载的单例bean
• 初始化创建非懒加载方式的单例Bean实例（未设置属性）
• 填充属性
• 初始化方法调用（比如调用afterPropertiesSet方法、init-method方法）
• 调用BeanPostProcessor（后置处理器）对实例bean进行后置处理
  所以我们接下来看下这个方法

public void refresh() throws BeansException, IllegalStateException {
   
		// 对象锁加锁
		synchronized (this.startupShutdownMonitor) {
   
			//刷新前的预处理,表示在真正做refresh操作之前需要准备做的事情：
			prepareRefresh();
			/*
			 	获取BeanFactory；默认实现是DefaultListableBeanFactory
                加载BeanDefition 并注册到 BeanDefitionRegistry
			 */
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory()