【Spring源码解析】Bean循环依赖

1.什么是循环依赖
....
2.Spring Bean循环依赖
2.1 不能解决：构造器注入循环依赖；
根本原因：Spring解决循环依赖依靠的是Bean的“中间态”这个概念，而这个中间态指的是已经实例化，但还没初始化的状态。
而构造器是完成实例化的东东，所以构造器的循环依赖无法解决~~~
加入singletonFactories三级缓存的前提是执行了构造器，所以构造器的循环依赖没法解决
2.2 prototype模式field属性注入循环依赖
2.3 能解决：singleton模式field属性注入（或setter方法注入）循环依赖
3.测试demo
3.1 spring-bean-circular-references.xml

<?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 http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="a" class="spring.circularreferences.A">
        <property name="b" ref="b" />
    </bean>
    <bean id="b" class="spring.circularreferences.B">
        <property name="a" ref="a" />
    </bean>
</beans>

3.2 CircularReferencesTest.java

public class CircularReferencesTest {
    
    @Test
    public void test01() {
        ClassPathResource resource = new ClassPathResource("spring-bean-circular-references.xml");
        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
        reader.loadBeanDefinitions(resource);
    
        A a = (A)factory.getBean("a");
        B b = (B)factory.getBean("b");
        Assert.assertEquals(a,b.getA());
        Assert.assertEquals(b,a.getB());
    }
}

4. 源码部分解析
   4.1 三级缓存，参考DefaultSingletonBeanRegistry.java

/** 一级缓存：存放完全实例化属性赋值完成的Bean，直接可以使用 **/
/** Cache of singleton objects: bean name --> bean instance */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

/** 三级缓存：singletonFactories，三级缓存，存放实例化完成的Bean工厂 **/
/** Cache of singleton factories: bean name --> ObjectFactory */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

/** 二级缓存：earlySingletonObjects，存放早期Bean的引用，尚未属性装配的Bean **/
/** Cache of early singleton objects: bean name --> bean instance */
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

4.2 流程

• getBean(...); // AbstractBeanFactory类 198行
• doGetBean(...) // AbstractBeanFactory类 239行
• getSingleton(beanName) // AbstractBeanFactory类 246行
• getSingleton(beanName,()->{...})// AbstractBeanFactory类 315行
• singletonFactory.getObject();// AbstractBeanFactory类 222行
• createBean();// AbstractAutowireCapableBeanFactory类 456行
• doCreateBean()// AbstractAutowireCapableBeanFactory类 526行
• addSingletonFactory()// AbstractAutowireCapableBeanFactory类 566行
• populateBean()// AbstractAutowireCapableBeanFactory类 572行

4.3 实例化Bean

// Create bean instance. 实例化Bean
if (mbd.isSingleton()) {
	sharedInstance = getSingleton(beanName, () -> {
		try {
			return createBean(beanName, mbd, args);
		}
		catch (BeansException ex) {
			// Explicitly remove instance from singleton cache: It might have been put there
			// eagerly by the creation process, to allow for circular reference resolution.
			// Also remove any beans that received a temporary reference to the bean.
			destroySingleton(beanName);
			throw ex;
		}
	});
	bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

4.4 getSingleton 获取实例对象

/**
 * Return the (raw) singleton object registered under the given name.
 * <p>Checks already instantiated singletons and also allows for an early
 * reference to a currently created singleton (resolving a circular reference).
 * @param beanName the name of the bean to look for
 * @param allowEarlyReference whether early references should be created or not
 * @return the registered singleton object, or {@code null} if none found
 */
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
	//先从一级缓存中获取已经实例化属性赋值完成的Bean
	Object singletonObject = this.singletonObjects.get(beanName);
	//一级缓存不存在，并且Bean正处于创建的过程中
	if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
		synchronized (this.singletonObjects) {
			//从二级缓存中查询，获取Bean的早期引用，实例化完成但是未赋值完成的Bean
			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);
				}
			}
		}
	}
	return singletonObject;
}

4.5 addSingletonFactory

	/**
	 * Add the given singleton factory for building the specified singleton
	 * if necessary.
	 * <p>To be called for eager registration of singletons, e.g. to be able to
	 * resolve circular references.
	 * @param beanName the name of the bean
	 * @param singletonFactory the factory for the singleton object
	 */
	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. 参考

• https://blog.csdn.net/fedorafrog/article/details/104550165
• https://www.cnblogs.com/CodeBear/p/13327899.html
• https://www.cnblogs.com/tongongV/p/13848796.html