Spring5源码分析(5)----循环依赖源码分析

0.前置内容

相关文章链接: Spring5源码分析(4)----循环依赖原理分析

1.循环依赖流程图

假设instA依赖instB，instB又依赖instA，那么在代码中的调用流程如下图：

2.doGetBean方法

	protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
			throws BeansException {
		//在这里传入的名称可能是别名，也可能是工厂bean的name，所以在这里需要装换
		String beanName = transformedBeanName(name);
		Object bean;

		//1.从缓存中获取bean
		Object sharedInstance = getSingleton(beanName);
		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 = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}
		//省略部分代码。。。
		else {
			/**
			 * spring只能解决单例对象的setter注入的循环依赖，不能解决构造器注入
			 */
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}
			try {
				RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);
				//省略部分代码。。。。
				// 2. 创建单例bean
				if (mbd.isSingleton()) {
					/**
					 * 此方法用于标记此bean正在创建，添加到singletonsCurrentlyInCreation，为循环依赖提供出口
					 */
					sharedInstance = getSingleton(beanName, () -> {
						try {
							//进入创建bean的逻辑
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							// 创建bean的过程发生异常，需要销毁关于当前bean的所有信息
							destroySingleton(beanName);
							throw ex;
						}
					});
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

2.1 getSingleton(beanName，true)(重要)

**注意在代码里有两个getSingleton方法，但是形参是不一样的。**此方法的作用就是去缓存中获取对象。

	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		// 1.从一级缓存中获取对象，一级缓存中存放的完整的bean，即初始化完成的bean
		Object singletonObject = this.singletonObjects.get(beanName);
		//1.1 如果一级缓存中没有，并且正在创建，说明存在循环依赖
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			//2. 从二级缓存中获取，如果此时bean中存在AOP，则获取到的就是代理的只实例化而未初始化的bean（不完整bean）
			// 如果不存在AOP，则返回普通的不完整bean，其作用就是避免某一个bean存在多次循环依赖而创建多次代理bean的情况
			singletonObject = this.earlySingletonObjects.get(beanName);
			//3.如果二级缓存中不存在，则从三级缓存中获取bean
			if (singletonObject == null && allowEarlyReference) {
				synchronized (this.singletonObjects) {
					//从一级缓存中获取（用于避免获取不完整bean的时候来避免反复创建bean，下篇文章会详细介绍）
					singletonObject = this.singletonObjects.get(beanName);
					if (singletonObject == null) {
						//从二级缓存中获取
						singletonObject = this.earlySingletonObjects.get(beanName);
						if (singletonObject == null) {
							//3.1 根据beanName从三级缓存中获取，此处不是获取bean对象
							ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
							if (singletonFactory != null) {
								//3.2 三级缓存中value存放的并不是bean对象，而是函数式接口，用于回调
								//此处调用getObject()方法，就是判断是否要创建动态代理，是，则实例化代理bean，否，则实例化普通bean
								singletonObject = singletonFactory.getObject();
								//3.3 将创建的不完整bean放入二级缓存中，下次先在二级缓存中拿，避免重复
								this.earlySingletonObjects.put(beanName, singletonObject);
								//3.4 三级缓存的回调作用已完成，进行移除
								this.singletonFactories.remove(beanName);
							}
						}
					}
				}
			}
		}
		return singletonObject;
	}

2.2 getSingleton(beanName, singletonFactory)

这个getSingleton方法中，传入的是一个函数式接口。用于回调外面的createBean方法。

	public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(beanName, "Bean name must not be null");
		synchronized (this.singletonObjects) {
			//1.先判断一级缓存中是否存在该bean，如果存在，不做任何操作，直接返回bean对象
			Object singletonObject = this.singletonObjects.get(beanName);
			//1.1 如果一级缓存中没有
			if (singletonObject == null) {
				//2.根据beanName判断是否在正在创建列表中，即是否正在创建
				if (this.singletonsCurrentlyInDestruction) {
					throw new BeanCreationNotAllowedException(beanName,
							"Singleton bean creation not allowed while singletons of this factory are in destruction " +
							"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
				}
				if (logger.isDebugEnabled()) {
					logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
				}
				//3.标记为正在创建
				beforeSingletonCreation(beanName);
				boolean newSingleton = false;
				boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = new LinkedHashSet<>();
				}
				try {
					//4.调用函数式接口的getObject()方法，即调用外层的createBean方法
					singletonObject = singletonFactory.getObject();
					newSingleton = true;
				}
				//省略部分代码。。。
				finally {
					if (recordSuppressedExceptions) {
						this.suppressedExceptions = null;
					}
					afterSingletonCreation(beanName);
				}
				if (newSingleton) {
					//5.加入到缓存中
					addSingleton(beanName, singletonObject);
				}
			}
			return singletonObject;
		}
	}

2.3 doCreateBean(重要)

在createBean方法中，会调用doCreateBean方法。

		try {
			/**
			 * 此步骤是我们真正创建我们bean的实例对象的过程
			 */
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isTraceEnabled()) {
				logger.trace("Finished creating instance of bean '" + beanName + "'");
			}
			return beanInstance;
		}

	/**
	 * 1.实例化
	 * 2.填充属性
	 * 3.初始化
	 */
	protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {

		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			/**
			 * <1> bean实例化，使用合适的实例化策略来创建新的实例：工厂方法、构造方法
			 * 一、使用反射：
			 * ①无参构造方法，默认:在bean定义中有beanClass属性获取到beanName，Class.forName(beanName).newInstance
			 * ②有参构造方法：自动装配、construct... Class.getConstruct().newInstance
			 * 二、工厂
			 * @Bean创建对象时
			 */
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		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 {
					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.
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isTraceEnabled()) {
				logger.trace("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			// <2> 添加到三级缓存中，注意此时的位置为bean实例化之后，属性赋值之前
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
			//<3> 属性赋值（调用set进行属性赋值）
			//属性赋值过程中，autowireByName方法或autowireByType中会再次调用getBean方法
			populateBean(beanName, mbd, instanceWrapper);
			//<4> 初始化，调用很多的xxxAware接口进行方法回调
			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) {
			//<5> 再次去缓存中获取
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				}
				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 " +
								"'getBeanNamesForType' 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;
	}