spring-循环依赖

spring-系列

---

---

前言

spring-循环依赖是内部实现逻辑，实际上在工作中不用去关心循环依赖原理，那为什么还要花一篇文章来讲解呢？很显然这是因为这是面试高频试题，且大部分人不知道怎么回答，基于这样的原因博主从源码的角度分析循环依赖的实现原理。

场景

两个对象相互依赖，如对象ObjectA内部依赖于对象ObjectB，对象ObjectB内部依赖于对象ObjectA，导致对象ObjectA和ObjectB存在循环依赖问题。实例代码如下：

@Component
public class ObjectA {
   

    @Autowired
    private ObjectB objectB;

}

@Component
public class ObjectB {
   

   @Autowired
   private ObjectA objectA;

}

spring中对Bean的定义有几种模式：prototype，singleton，request，session，默认为singleton。循环依赖只有在singleton模式下存在。

原因

上面我们描述了循环依赖发生的场景，现在我们来说一下发生的原因。spring中生成bean是在getBean方法中，下面描述getBean 生成Bean的步骤：

• 第一步： 根据Bean名称在BeanFactory的缓存singletonObjects（ Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256)）查询单例Bean，如果存在缓存Bean，直接执行第四步，否则执行第二步。

• 第二步： 根据Bean名称在BeanFactory中查询BeanDefinition对象（mbd）。

• 第三步： 根据上一步的mbd判断Bean的类型，如果当前Bean 不是singleton类型则每一次创建一个新的对象Bean（所以不存在循环依赖），如果是singleton类型则创建全局唯一的单例Bean（两个Bean相互依赖时存在循环依赖）。

• 第四步： 最后判断Bean类型是否为FactoryBean，是FactoryBean类型调用getObject()方法返回Bean实例，否则直接返回当前Bean。

循环依赖原因：当通过getBean创建ObjectA 单例bean时，先创建ObjectA 实例对象，然后再为参数objectB注入ObjectB类型的Bean，这时由于ObjectB类型Bean没有创建，再通过getBean创建ObjectB 单例bean，先创建ObjectB 实例对象，然后再为参数objectA注入ObjectA类型的Bean，但是ObjectA 类型的Bean并没有全部创建完成，所以整个过程就出现了循环依赖。

解决方法

根据上文我们知道循环依赖只出现在singleton类型的Bean且出现时期是在注入的过程中。这一节我们详细讨论singleton类型Bean的生成过程。直接上源码

protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException{
   

		/**
		 * 获取Bean名称，如果是FactoryBean则去掉前缀“&”
		 */
		String beanName = transformedBeanName(name);
		
		Object beanInstance;

		/**
		 * 尝试从缓存中获取Bean，getSingleton采用了3级缓存，第一级缓存：singletonObjects(单例对象池),第二级：earlySingletonObjects(对象引用),第三级：singletonFactories 对象工厂
		 */
		Object sharedInstance = getSingleton(beanName);
		
		/**
		 * Bean已经被创建的执行逻辑
		 */
		if (sharedInstance != null && args == null) {
   
			if (logger.isTraceEnabled()) {
   
				if (isSingletonCurrentlyInCreation(beanName)) {
   
					logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
							"' that is not fully initialized yet - a consequence of a circular reference");
				}
				else {
   
					logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
				}
			}
			/**
			 * 获取Bean实例,处理FactoryBean类型Bean
			 */
			beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

              ...
 
   // 根据Bean名称获取BeanDefinition
   RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

     // 当前Bean类型是singleton
	if (mbd.isSingleton()) {
   
			/**
			 * 创建单例Bean
			 */
			sharedInstance = getSingleton(beanName, () -> {
   
				try {
   
				    // 生成Bean
					return createBean(beanName, mbd, args);
				}
				catch (BeansException ex) {
   
					// 出现异常销毁当前Bean
					destroySingleton(beanName);
					throw ex;
				}
			});
			/**
			 * 获取Bean实例,处理FactoryBean类型Bean
			 */
			beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
		}
		
		...
		
}

• transformedBeanName(name) 获取Bean名称，如果是FactoryBean则去掉前缀“&”
• getSingleton(beanName)从单例缓存中获取单例Bean。
• getSingleton(String beanName, ObjectFactory<?> singletonFactory)从单例工厂中获取单例Bean。

getSingleton

	@Override
	@Nullable
	public Object getSingleton(String beanName) {
   
		return getSingleton(beanName, true);
	}

	@Nullable
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
   
		// Quick check for existing instance without full singleton lock
		Object singletonObject = this.singletonObjects.get(beanName);
		/**
		 * 如果singletonObject==null 判断当前Bean是否正在创建
		 */
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
   
			/**
			 * 检查是否已经缓存Bean（早期的Bean的引用，未实例化之前，这时还不是完整的实例）
			 */
			singletonObject = this.earlySingletonObjects.get(beanName);
			if (singletonObject == null && allowEarlyReference) {
   
				synchronized (this.singletonObjects) {