SpringBean循环依赖源码分析

水深无声 2022-12-20 02:23 203阅读 0赞

### 文章目录 ###

*   *  什么循环依赖
     *  什么循环依赖无法解决
     *  解决方式
     *  整体处理流程图
     *  核心方法
     *  为什么使用三级缓存

## 什么循环依赖 ##

循环依赖其实就是循环引用，也就是两个或则两个以上的bean互相持有对方，最终形成闭环。比如A 依赖 B，B 又依赖 A；或者A依赖于B，B依赖于C，C又依赖于A

这里用一个代码来说明

*  TestA

@Component
    public class TestA { 
        @Autowired
        private TestB testB;
    }

*  TestB

@Component
    public class TestB { 
        @Autowired
        private TestA testA;
    
    }

> 这里可以看到，A 依赖B， B 依赖A，在我们获取A的时候Spirng会为初始化A，然后给A的相应属性赋值时，发现A依赖B，B还没有初始化，就初始化B，然后初始化B的时候又发现A还没有初始化又初始化，就陷入死循环。我们接下来看看Spring是如何解决这个问题

## 什么循环依赖无法解决 ##

*  构造器的循环依赖：这种依赖spring是处理不了的，直 接抛出BeanCurrentlylnCreationException异常
 *  非单例循环依赖：无法处理

## 解决方式 ##

单例模式下的setter循环依赖：通过“三级缓存”处理循环依赖。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70_pic_center]

Spring中的缓存  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70_pic_center 1]

## 整体处理流程图 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70_pic_center 2]

## 核心方法 ##

// 获取对象

*  Object sharedInstance = getSingleton(beanName);

@Nullable
    	protected Object getSingleton(String beanName, boolean allowEarlyReference) { 
    		/** * singletonObjects 第一级缓存，BeanFactory的单例全存在singletonObjects中 * 保存的是已经初始化完全的单例 * IOC容器初始化加载单实例bean的时候第一次进来的时候 该map中一般返回空 */
    		Object singletonObject = this.singletonObjects.get(beanName);
    		//isSingletonCurrentlyInCreation=true，代表beanName所代表的bean循环依赖了
    		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { 
    			synchronized (this.singletonObjects) { 
    				/** * 第二级缓存，保存的是未初始化完全的早期对象(只是实例化) * 早期对象：就是bean刚刚调用了构造方法，还来不及给bean的属性进行赋值的对象 */
    				singletonObject = this.earlySingletonObjects.get(beanName);
    				/** * 二级缓存中也没有获取到对象,allowEarlyReference为true(参数是有上一个方法传递进来的true) */
    				if (singletonObject == null && allowEarlyReference) { 
    					/** * 直接从三级缓存中获取 ObjectFactory对象 这个对接就是用来解决循环依赖的关键所在 * 在ioc后期的过程中,当bean调用了构造方法的时候,把早期对象包裹成一个ObjectFactory * 暴露到三级缓存中,即缓存的是生成二级缓存的工厂方法 也就是前面传入的一个lambda表达式 */
    					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
    					//从三级缓存中获取到对象不为空
    					if (singletonFactory != null) { 
    						/** * 通过缓存singletonFactories中的对象工厂获取bean的早期对象 * 在这个环节中会调用到 getEarlyBeanReference()来进行后置处理 * 如果有AOP，获取的会是代理对象 */
    						singletonObject = singletonFactory.getObject();
    						//把早期对象放置在二级缓存,
    						this.earlySingletonObjects.put(beanName, singletonObject);
    						//ObjectFactory 包装对象从三级缓存中删除掉
    						this.singletonFactories.remove(beanName);
    					}
    				}
    			}
    		}
    		return singletonObject;
    	}

*  createBean(beanName, mbd, args)

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    			throws BeanCreationException { 
    
    		if (logger.isDebugEnabled()) { 
    			logger.debug("Creating instance of bean '" + beanName + "'");
    		}
    		RootBeanDefinition mbdToUse = mbd;
    
    		// Make sure bean class is actually resolved at this point, and
    		// clone the bean definition in case of a dynamically resolved Class
    		// which cannot be stored in the shared merged bean definition.
    		// 确保此时的 bean 已经被解析了
    		// 如果获取的class 属性不为null，则克隆该 BeanDefinition
    		// 主要是因为该动态解析的 class 无法保存到到共享的 BeanDefinition
    		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { 
    			mbdToUse = new RootBeanDefinition(mbd);
    			mbdToUse.setBeanClass(resolvedClass);
    		}
    
    		// Prepare method overrides.
    		try { 
    			/** * 验证和准备覆盖方法 * lookup-method 和 replace-method * 这两个配置存放在 BeanDefinition 中的 methodOverrides * 我们知道在 bean 实例化的过程中如果检测到存在 methodOverrides ， * 则会动态地位为当前 bean 生成代理并使用对应的拦截器为 bean 做增强处理。 * 具体的实现我们后续分析，现在先看 mbdToUse.prepareMethodOverrides() 代码块 */
    			mbdToUse.prepareMethodOverrides();
    		}
    		catch (BeanDefinitionValidationException ex) { 
    			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
    					beanName, "Validation of method overrides failed", ex);
    		}
    
    		try { 
    			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
    			/** * 通过bean的后置处理器来进行后置处理生成代理对象,一般情况下在此处不会生成代理对象 * 为什么不能生成代理对象,不管是我们的jdk代理还是cglib代理都不会在此处进行代理，因为我们的 * 真实的对象没有生成,所以在这里不会生成代理对象，那么在这一步是我们aop和事务的关键，因为在这里 * 解析我们的aop切面信息进行缓存 */
    			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
    			if (bean != null) { 
    				return bean;
    			}
    		}
    		catch (Throwable ex) { 
    			throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
    					"BeanPostProcessor before instantiation of bean failed", ex);
    		}
    
    		try { 
    			/** * 该步骤是我们真正的创建我们的bean的实例对象的过程 重点关注 */
    			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    			if (logger.isDebugEnabled()) { 
    				logger.debug("Finished creating instance of bean '" + beanName + "'");
    			}
    			return beanInstance;
    		}
    		catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) { 
    			// A previously detected exception with proper bean creation context already,
    			// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
    			throw ex;
    		}
    		catch (Throwable ex) { 
    			throw new BeanCreationException(
    					mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
    		}
    	}

*  doCreateBean

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
    			throws BeanCreationException { 
    
    		// Instantiate the bean.
    		//BeanWrapper 是对 Bean 的包装，其接口中所定义的功能很简单包括设置获取被包装的对象，获取被包装 bean 的属性描述器
    		BeanWrapper instanceWrapper = null;
    		if (mbd.isSingleton()) { 
    			//从没有完成的FactoryBean中移除
    			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    		}
    		if (instanceWrapper == null) { 
    			//使用合适的实例化策略来创建新的实例：工厂方法、构造函数自动注入、简单初始化 该方法很复杂也很重要
    			instanceWrapper = createBeanInstance(beanName, mbd, args);
    		}
    		//从beanWrapper中获取我们的早期对象
    		final Object bean = instanceWrapper.getWrappedInstance();
    		Class<?> beanType = instanceWrapper.getWrappedClass();
    		if (beanType != NullBean.class) { 
    			mbd.resolvedTargetType = beanType;
    		}
    
    		// Allow post-processors to modify the merged bean definition.
    		synchronized (mbd.postProcessingLock) { 
    			if (!mbd.postProcessed) { 
    				try { 
    					//进行后置处理 @AutoWired的注解的预解析
    					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
    				}
    				catch (Throwable ex) { 
    					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    							"Post-processing of merged bean definition failed", ex);
    				}
    				mbd.postProcessed = true;
    			}
    		}
    
    		// Eagerly cache singletons to be able to resolve circular references
    		// even when triggered by lifecycle interfaces like BeanFactoryAware.
    		/** * 该对象进行判断是否能够暴露早期对象的条件 * 单实例 * this.allowCircularReferences 默认为true * isSingletonCurrentlyInCreation(表示当前的bean对象正在创建singletonsCurrentlyInCreation包含当前正在创建的bean) */
    		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
    				isSingletonCurrentlyInCreation(beanName));
    		//上述条件满足，允许中期暴露对象
    		if (earlySingletonExposure) { 
    			if (logger.isDebugEnabled()) { 
    				logger.debug("Eagerly caching bean '" + beanName +
    						"' to allow for resolving potential circular references");
    			}
    			//把我们的早期对象包装成一个singletonFactory对象 该对象提供了一个getObject方法,该方法内部调用getEarlyBeanReference方法
    			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    		}
    
    		// Initialize the bean instance.
    		Object exposedObject = bean;
    		try { 
    			//给我们的属性进行赋值(调用set方法进行赋值)
    			populateBean(beanName, mbd, instanceWrapper);
    			//进行对象初始化操作(在这里可能生成代理对象)
    			exposedObject = initializeBean(beanName, exposedObject, mbd);
    		}
    		catch (Throwable ex) { 
    			if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { 
    				throw (BeanCreationException) ex;
    			}
    			else { 
    				throw new BeanCreationException(
    						mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
    			}
    		}
    		//允许早期对象的引用
    		if (earlySingletonExposure) { 
    			/** * 去缓存中获取到我们的对象 由于传递的allowEarlyReferce 是false 要求只能在一级二级缓存中去获取 * 正常普通的bean(不存在循环依赖的bean) 创建的过程中，压根不会把三级缓存提升到二级缓存中 */
    			Object earlySingletonReference = getSingleton(beanName, false);
    			//能够获取到
    			if (earlySingletonReference != null) { 
    				//经过后置处理的bean和早期的bean引用还相等的话(表示当前的bean没有被代理过)
    				if (exposedObject == bean) { 
    					exposedObject = earlySingletonReference;
    				}
    				//处理依赖的bean
    				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { 
    					String[] dependentBeans = getDependentBeans(beanName);
    					Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
    					for (String dependentBean : dependentBeans) { 
    						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { 
    							actualDependentBeans.add(dependentBean);
    						}
    					}
    					if (!actualDependentBeans.isEmpty()) { 
    						throw new BeanCurrentlyInCreationException(beanName,
    								"Bean with name '" + beanName + "' has been injected into other beans [" +
    								StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
    								"] in its raw version as part of a circular reference, but has eventually been " +
    								"wrapped. This means that said other beans do not use the final version of the " +
    								"bean. This is often the result of over-eager type matching - consider using " +
    								"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
    					}
    				}
    			}
    		}
    
    		// Register bean as disposable.
    		try { 
    			//注册销毁的bean的销毁接口
    			registerDisposableBeanIfNecessary(beanName, bean, mbd);
    		}
    		catch (BeanDefinitionValidationException ex) { 
    			throw new BeanCreationException(
    					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    		}
    
    		return exposedObject;
    	}

## 为什么使用三级缓存 ##

使用 earlySingletonObjects 和 singletonObjects 两级缓存，一个存放早期对象，一个存放初始化完成后的对象，也能实现同样的功能，singletonFactories 好像显得有些多此一举。其实不是的，对于普通对象，确实只要返回刚创建完的早期对象就好了，但对于内部有被 AOP 增强的方法的对象，需要返回的是代理对象。我们可以看一下 ObjectFactory 匿名内部类里面调用的 getEarlyBeanReference 方法：

/** *这个方法很重要 网上大多数人都没有说清楚，在解决循环依赖的过程中把三级对象的getObject()的时候，会触发getEarlyBeanReference * 在该方法中，我们可以通过SmartInstantiationAwareBeanPostProcessor的后置处理器来修改我们早期对象的属性, * 但是spring内部的SmartInstantiationAwareBeanPostProcessor.getEarlyBeanReference没有做任何的处理 * 正符合spring开放式接口规范 留个我们扩展 * @param beanName the name of the bean (for error handling purposes) * @param mbd the merged bean definition for the bean * @param bean the raw bean instance * @return the object to expose as bean reference */
    	protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) { 
    		Object exposedObject = bean;
    		//判读我们容器中是否有InstantiationAwareBeanPostProcessors类型的后置处理器
    		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { 
    			//获取我们所有的后置处理器
    			for (BeanPostProcessor bp : getBeanPostProcessors()) { 
    				//判断我们的后置处理器是不是实现了SmartInstantiationAwareBeanPostProcessor接口
    				//被调用，如果返回的对象需要加强，那这里就会生成代理对
    				//如果返回的对象需要AOP增强，那这里exposedObject 就会替换成代理对象的引用
    				比如上图中的bean A 如果被AOP增强，那么bean B 加载时获取的bean A 其实是A的代理对象 
    				if (bp instanceof SmartInstantiationAwareBeanPostProcessor) { 
    					//进行强制转换
    					SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
    					//挨个调用SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReference
    					exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
    				}
    			}
    		}
    		return exposedObject;
    	}

我们可以看到对于一般的对象，返回的就是传入的早期对象，但是对于内部有被 AOP 增强的方法的对象，会使用后置处理器返回一个代理对象。

参考：  
https://blog.csdn.net/qq\_22076345/article/details/104296675

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/a64667d1585b4775b76c69338249e7d6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20201109224417547.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20201109223735270.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0,size_16,color_FFFFFF,t_70#pic_center