在上篇文章中Spring Ioc 之 Bean的載入（一），我們分析了Spring Ioc中Bean的載入 doGetBean() 方法的2.2從快取中獲取單例bean和2.3獲取最終的bean例項物件兩個步驟，我們接著分析餘下幾個步驟。
直接上程式碼：

//真正實現向IOC容器獲取Bean的功能，也是觸發依賴注入功能的地方
	protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

		//根據指定的名稱獲取被管理Bean的名稱，剝離指定名稱中對容器的相關依賴
		// 如果指定的是別名，將別名轉換為規範的Bean名稱
<1>		final String beanName = transformedBeanName(name);
		Object bean;

		// Eagerly check singleton cache for manually registered singletons.
		// 從快取中獲取已被建立過的單例Bean
<2>		Object sharedInstance = getSingleton(beanName);
		//如果快取中有
		if (sharedInstance != null && args == null) {
			if (logger.isDebugEnabled()) {
				if (isSingletonCurrentlyInCreation(beanName)) {
					logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
							"' that is not fully initialized yet - a consequence of a circular reference");
				}
				else {
					logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
				}
			}

			//注意：BeanFactory是管理容器中Bean的工廠
			//     FactoryBean是建立建立物件的工廠Bean，兩者之間有區別

			//獲取給定Bean的例項物件，該物件要麼是 bean 例項本身，要麼就是 FactoryBean 建立的 Bean 物件
			//（為什麼要再次獲取呢，因為上面獲取的sharedInstance不一定是完整的）
<3>			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			// Fail if we're already creating this bean instance:
			// We're assumably within a circular reference.
			// 因為 Spring 只解決單例模式下的迴圈依賴，在原型模式下如果存在迴圈依賴則會丟擲異常。
<4>			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			// Check if bean definition exists in this factory.
			//對IOC容器中是否存在指定名稱的BeanDefinition進行檢查，首先檢查是否
			//能在當前的BeanFactory中獲取的所需要的Bean，如果不能則委託當前容器
			//的父級容器去查詢，如果還是找不到則沿著容器的繼承體系向父級容器查詢
			BeanFactory parentBeanFactory = getParentBeanFactory();
			//當前容器的父級容器存在，且當前容器中不存在指定名稱的Bean
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// Not found -> check parent.
				//解析指定Bean名稱的原始名稱
				String nameToLookup = originalBeanName(name);
				// 若為 AbstractBeanFactory 型別，委託父類處理
				if (parentBeanFactory instanceof AbstractBeanFactory) {
					return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
							nameToLookup, requiredType, args, typeCheckOnly);
				}
				else if (args != null) {
					// Delegation to parent with explicit args.
					//委派父級容器根據指定名稱和顯式的引數查詢
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
				else {
					// No args -> delegate to standard getBean method.
					//委派父級容器根據指定名稱和型別查詢
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}

			// 建立的Bean是否需要進行型別驗證，一般不需要
<5>			if (!typeCheckOnly) {
				//向容器標記指定的Bean已經被建立
				markBeanAsCreated(beanName);
			}

			try {
				//從容器中獲取 beanName 相應的 GenericBeanDefinition 物件，並將其轉換為 RootBeanDefinition 物件
				// 主要解決Bean繼承時子類合併父類公共屬性問題
<6>				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				// 檢查給定的合併的 BeanDefinition (是否為抽象類)
				checkMergedBeanDefinition(mbd, beanName, args);

				// Guarantee initialization of beans that the current bean depends on.
				// 處理所依賴的 bean @DependsOn()
				// 獲取當前Bean所有依賴Bean的名稱
<7>				String[] dependsOn = mbd.getDependsOn();
				//如果有依賴
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						//校驗該依賴是否已經註冊過給當前 Bean
						if (isDependent(beanName, dep)) {
							//已註冊，丟擲異常
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
						}
						//沒有，則先註冊依賴的bean
						registerDependentBean(dep, beanName);
						//遞迴呼叫getBean()，先生成依賴的bean
						getBean(dep);
					}
				}

				// Create bean instance.
				//建立單例Bean
<8>				if (mbd.isSingleton()) {
					//這裡使用了一個匿名內部類，建立Bean例項物件，並且註冊給所依賴的物件
					sharedInstance = getSingleton(beanName, () -> {
						try {
							//建立一個指定Bean例項物件，如果有父級繼承，則合併子類和父類的定義
							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.
							//顯式地從容器單例模式Bean快取中清除例項物件
							destroySingleton(beanName);
							throw ex;
						}
					});
					//獲取給定Bean的例項物件
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

				//建立多例Bean
				else if (mbd.isPrototype()) {
					//原型模式(Prototype)是每次都會建立一個新的物件
					Object prototypeInstance = null;
					try {
						//載入前置處理，預設的功能是註冊當前建立的原型物件
						beforePrototypeCreation(beanName);
						//建立指定Bean物件例項
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						//載入後置處理，預設的功能告訴IOC容器指定Bean的原型物件不再建立
						afterPrototypeCreation(beanName);
					}
					//獲取給定Bean的例項物件
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}

				//要建立的Bean既不是Singleton也不是Prototype
				//如：request、session、application等生命週期
				else {
					String scopeName = mbd.getScope();
					final Scope scope = this.scopes.get(scopeName);
					//Bean定義資源中沒有配置生命週期範圍，則Bean定義不合法
					if (scope == null) {
						throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
					}
					try {
						//這裡又使用了一個匿名內部類，獲取一個指定生命週期範圍的例項
						Object scopedInstance = scope.get(beanName, () -> {
							//前置處理
							beforePrototypeCreation(beanName);
							try {
								return createBean(beanName, mbd, args);
							}
							finally {
								//後置處理
								afterPrototypeCreation(beanName);
							}
						});
						//獲取給定Bean的例項物件
						bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
					}
					catch (IllegalStateException ex) {
						throw new BeanCreationException(beanName,
								"Scope '" + scopeName + "' is not active for the current thread; consider " +
								"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
								ex);
					}
				}
			}
			catch (BeansException ex) {
				cleanupAfterBeanCreationFailure(beanName);
				throw ex;
			}
		}

		// Check if required type matches the type of the actual bean instance.
		//對建立的Bean例項物件進行型別檢查
<9>		if (requiredType != null && !requiredType.isInstance(bean)) {
			try {
				T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
				if (convertedBean == null) {
					throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
				}
				return convertedBean;
			}
			catch (TypeMismatchException ex) {
				if (logger.isDebugEnabled()) {
					logger.debug("Failed to convert bean '" + name + "' to required type '" +
							ClassUtils.getQualifiedName(requiredType) + "'", ex);
				}
				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
			}
		}
		return (T) bean;
	}
 

程式碼很長，需要一些耐心，下面我們來逐步分析這段程式碼：

• <1>處：具體分析，見2.1獲取原始beanName

• <2>處: 具體分析，見2.2從快取中獲取單例bean

• <3>處: 具體分析，見2.3獲取最終的bean例項物件

• <4>處: 具體分析，見2.4原型模式依賴檢查(Prototype)和從 parentBeanFactory 獲取 Bean

• <5>處: 具體分析，見2.5標記bean為已建立或即將建立

• <6>處: 具體分析，見2.6獲取BeanDefinition

• <7>處: 具體分析，見2.7bean依賴處理

• <8>處: 具體分析，見2.8不同作用域bean的例項化

• <9>處: 具體分析，見2.9型別轉換

2.4、原型模式依賴檢查(Prototype)和從 parentBeanFactory 獲取 Bean

原型模式依賴檢查，對應程式碼如下：

if (isPrototypeCurrentlyInCreation(beanName)) {
	throw new BeanCurrentlyInCreationException(beanName);
	}

跟蹤進去：

        /** Names of beans that are currently in creation */
	private final ThreadLocal<Object> prototypesCurrentlyInCreation =
			new NamedThreadLocal<>("Prototype beans currently in creation");

protected boolean isPrototypeCurrentlyInCreation(String beanName) {
		//從ThreadLocal中取出正在建立的prototype
		Object curVal = this.prototypesCurrentlyInCreation.get();
		return (curVal != null &&
				(curVal.equals(beanName) || (curVal instanceof Set && ((Set<?>) curVal).contains(beanName))));
	}
 

Spring 只處理單例模式下得迴圈依賴，對於原型模式的迴圈依賴直接丟擲異常。
Spring會把正在建立的原型模式Bean存入ThreadLoacl，在這裡通過ThreadLoacl來判斷當前Bean是否已經建立。

從 parentBeanFactory 獲取 Bean，對應程式碼如下：

// Check if bean definition exists in this factory.
	//對IOC容器中是否存在指定名稱的BeanDefinition進行檢查，首先檢查是否
	//能在當前的BeanFactory中獲取的所需要的Bean，如果不能則委託當前容器
	//的父級容器去查詢，如果還是找不到則沿著容器的繼承體系向父級容器查詢
	BeanFactory parentBeanFactory = getParentBeanFactory();
	//當前容器的父級容器存在，且當前容器中不存在指定名稱的Bean
	if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
		// Not found -> check parent.
		//解析指定Bean名稱的原始名稱
		String nameToLookup = originalBeanName(name);
		// 若為 AbstractBeanFactory 型別，委託父類處理
		if (parentBeanFactory instanceof AbstractBeanFactory) {
			return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
					nameToLookup, requiredType, args, typeCheckOnly);
		}
		else if (args != null) {
			// Delegation to parent with explicit args.
			//委派父級容器根據指定名稱和顯式的引數查詢
			return (T) parentBeanFactory.getBean(nameToLookup, args);
		}
		else {
			// No args -> delegate to standard getBean method.
			//委派父級容器根據指定名稱和型別查詢
			return parentBeanFactory.getBean(nameToLookup, requiredType);
		}
	}

如果當前容器快取中沒有相對應的 BeanDefinition 物件，則會嘗試從父類工廠（parentBeanFactory）中載入，然後再去遞迴呼叫 getBean(...) 方法

2.5、標記bean為已建立或即將建立

對應程式碼如下：

//建立的Bean是否需要進行型別驗證，一般不需要
			if (!typeCheckOnly) {
				//向容器標記指定的Bean已經被建立
				markBeanAsCreated(beanName);
			}

typeCheckOnly是doGetBean(final String name, @Nullable final Class<T> requiredType,@Nullable final Object[] args, boolean typeCheckOnly)方法中的一個引數，一般這個引數傳的都是false

接著追蹤markBeanAsCreated()方法：

protected void markBeanAsCreated(String beanName) {
		// 沒有建立
		if (!this.alreadyCreated.contains(beanName)) {
			synchronized (this.mergedBeanDefinitions) {
				// 再次檢查一次：DCL 雙重校驗
				if (!this.alreadyCreated.contains(beanName)) {
					clearMergedBeanDefinition(beanName);
					// 新增到已建立 bean 集合中
					this.alreadyCreated.add(beanName);
				}
			}
		}
	}

這裡用到了單例模式中耳熟能詳的雙重校驗

2.6、獲取BeanDefinition

對應程式碼如下：

        //從容器中獲取 beanName 相應的 GenericBeanDefinition 物件，並將其轉換為 RootBeanDefinition 物件
	//主要解決Bean繼承時子類合併父類公共屬性問題
	final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
	// 檢查給定的合併的 BeanDefinition (是否為抽象類)
	checkMergedBeanDefinition(mbd, beanName, args);

這段程式碼註釋很詳細，就不多解釋了。

2.7、bean依賴處理

對應程式碼如下：

// Guarantee initialization of beans that the current bean depends on.
	// 處理所依賴的 bean @DependsOn()
	//獲取當前Bean所有依賴Bean的名稱
<1>	String[] dependsOn = mbd.getDependsOn();
	//如果有依賴
	if (dependsOn != null) {
		for (String dep : dependsOn) {
			//校驗該依賴是否已經註冊過給當前 Bean
<2>			if (isDependent(beanName, dep)) {
				//已註冊，丟擲異常
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
			}
			//沒有，則先註冊依賴的bean
<3>			registerDependentBean(dep, beanName);
			//遞迴呼叫getBean()，先生成依賴的bean
<4>			getBean(dep);
		}
	}

在spring中有一個@DependsOn註解，它的作用是依賴載入，比如A物件要在B物件載入之後才能載入，那麼可以在A上面加@DependsOn(value = "B")註解，就可以達到我們的要求。
其實@DependsOn實現的原理就是上面這段程式碼。

• <1>、通過我們前面從IoC容器中拿到的BeanDefinition，呼叫mbd.getDependsOn()方法，獲取當前bean所有的依賴。

• <2>、遍歷這些依賴，判斷此依賴是否已註冊給當前的Bean

• <3>、沒有，則先註冊依賴的Bean

• <4>、遞迴呼叫getBean()，先生成依賴的bean

<2>、遍歷這些依賴，判斷此依賴是否已註冊給當前的Bean

程式碼:

	
	// 儲存的是bean與其依賴的對映關係：B - > A
	private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);

        //儲存的是bean與其依賴的對映關係：A - > B
	private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);

private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) {
		if (alreadySeen != null && alreadySeen.contains(beanName)) {
			return false;
		}
		// 獲取當前原始 beanName
		String canonicalName = canonicalName(beanName);
		// 獲取該bean依賴的其他bean集合
		Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
		if (dependentBeans == null) {
			return false;
		}
		// 存在，則證明該依賴已經註冊到bean中
		if (dependentBeans.contains(dependentBeanName)) {
			return true;
		}
		// 遞迴檢測依賴
		for (String transitiveDependency : dependentBeans) {
			if (alreadySeen == null) {
				alreadySeen = new HashSet<>();
			}
			alreadySeen.add(beanName);
			if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
				return true;
			}
		}
		return false;
	}

這段程式碼很簡單，主要就是通過dependentBeanMap獲取當前bean對應的所有依賴dependentBeans，然後判斷是否已註冊，接著遞迴檢查依賴的Bean有沒有依賴，如果有，就遞迴呼叫isDependent()檢查

<3>、沒有，則先註冊依賴的Bean

如果沒有註冊依賴的Bean到該 Bean，則執行註冊registerDependentBean(dep, beanName)：

	// 儲存的是bean與其依賴的對映關係：B - > A
	private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);

        //儲存的是bean與其依賴的對映關係：A - > B
	private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);

//為指定的Bean注入依賴的Bean
	public void registerDependentBean(String beanName, String dependentBeanName) {
	// A quick check for an existing entry upfront, avoiding synchronization...
	//獲取原始beanName
	String canonicalName = canonicalName(beanName);
	Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
	if (dependentBeans != null && dependentBeans.contains(dependentBeanName)) {
		return;
	}

	// No entry yet -> fully synchronized manipulation of the dependentBeans Set
	//先從容器中：bean名稱-->全部依賴Bean名稱集合找查詢給定名稱Bean的依賴Bean
	synchronized (this.dependentBeanMap) {
		//獲取給定名稱Bean的所有依賴Bean名稱
		dependentBeans = this.dependentBeanMap.get(canonicalName);
		if (dependentBeans == null) {
			//為Bean設定依賴Bean資訊
			dependentBeans = new LinkedHashSet<>(8);
			this.dependentBeanMap.put(canonicalName, dependentBeans);
		}
		//把對映關係存入集合
		dependentBeans.add(dependentBeanName);
	}
	//從容器中：bean名稱-->指定名稱Bean的依賴Bean集合找查詢給定名稱Bean的依賴Bean
	synchronized (this.dependenciesForBeanMap) {
		Set<String> dependenciesForBean = this.dependenciesForBeanMap.get(dependentBeanName);
		if (dependenciesForBean == null) {
			dependenciesForBean = new LinkedHashSet<>(8);
			this.dependenciesForBeanMap.put(dependentBeanName, dependenciesForBean);
		}
		//把對映關係存入集合
		dependenciesForBean.add(canonicalName);
	}
	}

套用上面的例子，如果 A @DependsOn(value = "B") ，也就是說A依賴於B，那麼該方法registerDependentBean(dep, beanName)中，引數 dep 就是B，beanName 就是A。
這段程式碼中其實就是把bean之間的依賴關係註冊到兩個map中。

• dependentBeanMap 存入(B,A)

• dependenciesForBeanMap 存入(A,B)

<4>、遞迴呼叫getBean(dep)，先生成依賴的bean

到了這一步，遞迴呼叫getBean(beanName)方法也就是doGetBean(beanName)重走當前流程，來先例項化依賴的Bean。等依賴的Bean例項化之後，當前bean再接著往下執行。

2.8、不同作用域bean的例項化

程式碼：

        // Create bean instance.
	//建立單例Bean
	if (mbd.isSingleton()) {
		//這裡使用了一個匿名內部類，建立Bean例項物件，並且註冊給所依賴的物件
		sharedInstance = getSingleton(beanName, () -> {
			try {
				//建立一個指定Bean例項物件，如果有父級繼承，則合併子類和父類的定義
				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.
				//顯式地從容器單例模式Bean快取中清除例項物件
				destroySingleton(beanName);
				throw ex;
			}
		});
		//獲取給定Bean的例項物件
		bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
	}

	//建立多例Bean
	else if (mbd.isPrototype()) {
		//原型模式(Prototype)是每次都會建立一個新的物件
		Object prototypeInstance = null;
		try {
			//載入前置處理，預設的功能是註冊當前建立的原型物件
			beforePrototypeCreation(beanName);
			//建立指定Bean物件例項
			prototypeInstance = createBean(beanName, mbd, args);
		}
		finally {
			//載入後置處理，預設的功能告訴IOC容器指定Bean的原型物件不再建立
			afterPrototypeCreation(beanName);
		}
		//獲取給定Bean的例項物件
		bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
	}

	//要建立的Bean既不是Singleton也不是Prototype
	//如：request、session、application等生命週期
	else {
		String scopeName = mbd.getScope();
		final Scope scope = this.scopes.get(scopeName);
		//Bean定義資源中沒有配置生命週期範圍，則Bean定義不合法
		if (scope == null) {
			throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
		}
		try {
			//這裡又使用了一個匿名內部類，獲取一個指定生命週期範圍的例項
			Object scopedInstance = scope.get(beanName, () -> {
				//前置處理
				beforePrototypeCreation(beanName);
				try {
					return createBean(beanName, mbd, args);
				}
				finally {
					//後置處理
					afterPrototypeCreation(beanName);
				}
			});
			//獲取給定Bean的例項物件
			bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
		}
		catch (IllegalStateException ex) {
			throw new BeanCreationException(beanName,
					"Scope '" + scopeName + "' is not active for the current thread; consider " +
					"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
					ex);
		}
	}

這段程式碼很明顯，分成了3個部分：

• singleton Bean例項化

• Prototype Bean例項化

• 其他型別 Bean 例項化(session,request等)

我們先來看singleton Bean例項化：

if (mbd.isSingleton()) {
	//這裡使用了一個匿名內部類，建立Bean例項物件，並且註冊給所依賴的物件
	sharedInstance = getSingleton(beanName, () -> {
	try {
		//建立一個指定Bean例項物件，如果有父級繼承，則合併子類和父類的定義
		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.
		//顯式地從容器單例模式Bean快取中清除例項物件
		destroySingleton(beanName);
		throw ex;
	}
	});
	//獲取給定Bean的例項物件
	bean = getObjectForBeanInstance(sharedInstance, name,beanName, mbd);
	}

Spring Bean 的作用域預設為 singleton 。還有其他作用域，如 prototype、request、session 等。
不同的作用域會有不同的初始化策略。
詳見spring各個scope的bean建立。

2.9、型別轉換

程式碼：

// Check if required type matches the type of the actual bean instance.
	//對建立的Bean例項物件進行型別檢查
	if (requiredType != null && !requiredType.isInstance(bean)) {
	try {
	        //執行轉換
		T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
		// 轉換失敗，拋異常
		if (convertedBean == null) {
			throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
		}
		return convertedBean;
	}
	catch (TypeMismatchException ex) {
		if (logger.isDebugEnabled()) {
			logger.debug("Failed to convert bean '" + name + "' to required type '" +
					ClassUtils.getQualifiedName(requiredType) + "'", ex);
		}
		throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
	}
	}
	return (T) bean;

requiredType是 getBean() 方法可傳入的一個引數，即可以根據指定的 beanName 和 requiredType 來獲取Bean。

但是一般情況下是不需要型別檢查的，requiredType一般為null，如getBean(beanName)

當requiredType不為null的時候走這段邏輯。

總結：

至此，spring載入Bean也就是 getBean() 我們大致分析完了，之後會再寫幾篇文章對其中有些步驟進行詳細介紹。

參考：<