在之前的文章中，我們分析了Spring的Ioc的初始化過程，實際上就是把 beanName 和 BeanDefinition 注冊到DefaultListableBeanFactory的map中。
在完成 bean 的注冊之后， refresh() 還調用了很多后處理器的方法，其中有一個方法 finishBeanFactoryInitialization()，注釋上面寫著 Instantiateall remaining(non-lazy-init)singletons ，意味著非延遲加載的類，將在這一步實例化，完成類的加載。
而我們使用到 context.getBean("beanName") 方法，如果對應的 bean 是非延遲加載的，那么直接就能拿出來進行使用，而延遲加載的 bean 就需要上面的步驟進行類的加載，加載完之后才能進行使用。接著分析一下Ioc的bean實例化過程：

一、getBean

當我們顯示或者隱式地調用 BeanFactory#getBean(String name) 方法時，則會觸發加載 Bean 階段。代碼如下：

// AbstractBeanFactory.java @Override public Object getBean(String name) throws BeansException {return doGetBean(name, null, null, false); }

內部調用

//name ：要獲取 Bean 的名字 //requiredType ：要獲取 bean 的類型 //args ：創建 Bean 時傳遞的參數。這個參數僅限于創建 Bean 時使用。 //typeCheckOnly ：是否為類型檢查。 doGetBean(String name, final Class<T> requiredType, Object[] args, boolean typeCheckOnly)

二、doGetBean

//真正實現向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();//當前容器的父級容器存在，且當前容器中不存在指定名稱的Beanif (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) {//校驗該依賴是否已經注冊過給當前 Beanif (isDependent(beanName, dep)) {//已注冊，拋出異常throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");}//沒有，則先注冊依賴的beanregisterDependentBean(dep, beanName);//遞歸調用getBean()，先生成依賴的beangetBean(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);}//創建多例Beanelse 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.1.獲取原始beanName

代碼如下：

final String beanName = transformedBeanName(name);

繼續深入，代碼如下：

protected String transformedBeanName(String name) {return canonicalName(BeanFactoryUtils.transformedBeanName(name));}

BeanFactoryUtils.transformedBeanName(name)方法主要是去除 FactoryBean 的修飾符

//對FactoryBean的轉義定義，因為如果使用bean的名字檢索FactoryBean得到的對象是工廠生成的對象，//如果需要得到工廠本身，需要轉義String FACTORY_BEAN_PREFIX = "&";public static String transformedBeanName(String name) {Assert.notNull(name, "'name' must not be null");String beanName = name;while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());}return beanName;}

ps: 如果一個factoryBean的名稱為“student”，獲取factoryBean創建的Bean時，使用getBean(“student”)，獲取factoryBean本身時，使用getBean("&student")
接著深入，最終代碼如下：

/** Map from alias to canonical name */private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16); //循環處理，從aliasMap中根據aliasName獲取真實beanName，直到獲取到的真實beanName為nullpublic String canonicalName(String name) {String canonicalName = name;// Handle aliasing...String resolvedName;do {resolvedName = this.aliasMap.get(canonicalName);if (resolvedName != null) {canonicalName = resolvedName;}}while (resolvedName != null);return canonicalName;}

主要是一個循環獲取 beanName 的過程，例如，別名 A 指向名稱為 B 的 bean 則返回 B，若 別名 A 指向別名 B，別名 B 指向名稱為 C 的 bean，則返回 C

• 2.2、從緩存中獲取單例bean
  Spring 對單例模式的 bean 只會創建一次。后續，如果再獲取該 Bean ，則是直接從單例緩存中獲取，該過程就體現在 #getSingleton(String beanName) 方法中。代碼如下：

/** Cache of singleton objects: bean name --> bean instance *///單例bean的緩存private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);/** Cache of singleton factories: bean name --> ObjectFactory *///單例對象工廠緩存private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);/** Cache of early singleton objects: bean name --> bean instance *///預加載單例bean緩存//存放的 bean 不一定是完整的private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);//對于單例模式的Bean整個IOC容器中只創建一次，不需要重復創建@Nullableprotected Object getSingleton(String beanName, boolean allowEarlyReference) {//從單例緩存中獲取單例beanObject singletonObject = this.singletonObjects.get(beanName);//如果緩存中沒有 并且 該bean正在創建if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {synchronized (this.singletonObjects) {singletonObject = this.earlySingletonObjects.get(beanName);// earlySingletonObjects 中沒有，且允許提前創建if (singletonObject == null && allowEarlyReference) {//從緩存中獲取 ObjectFactoryObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);if (singletonFactory != null) {//從單例工廠中獲取beansingletonObject = singletonFactory.getObject();//存入earlythis.earlySingletonObjects.put(beanName, singletonObject);this.singletonFactories.remove(beanName);}}}}return singletonObject;}

這段代碼很簡單，流程如下：

第一步，從singletonObjects中獲取Bean對象
第二步，如果獲取不到且Bean正在創建中，從earlySingletonObjects獲取Bean對象
第三步，如果獲取不到且允許提前創建,從singletonFactories獲取FactoryBean
第四步，如果不為null，則通過FactoryBean.getObject()獲取Bean，然后將其加入到
earlySingletonObjects ，并且從 singletonFactories 刪除，兩者是互斥的，主要用來解決循環依賴的問題

總結就是：從這三個Map依次去取，取不到就取下一個Map

2.2.1、isSingletonCurrentlyInCreation
在上面的代碼中又一個重要的方法isSingletonCurrentlyInCreation(beanName)，代碼如下：

private final Set<String> singletonsCurrentlyInCreation =Collections.newSetFromMap(new ConcurrentHashMap<>(16));public boolean isSingletonCurrentlyInCreation(String beanName) {return this.singletonsCurrentlyInCreation.contains(beanName);}

這個方法是用來判斷當前Bean是否在創建中，看到是個Map，我們可以猜測，應該有一個地方在創建Bean的時候，會把正在創建的BeanName給put到這個Map中。

• 2.3 獲取最終的bean實例對象

2.3.1、getObjectForBeanInstance
當我們從getSingleton(beanName)拿到bean對象后，會接著調用getObjectForBeanInstance()方法，來獲取最終的Bean實例。

為什么這里要再獲取一次Bean呢，之前明明都拿到了呀？

因為我們從緩存中獲取的 bean 是最原始的 Bean ，并不一定是我們最終想要的 Bean。

怎么辦呢？調用 #getObjectForBeanInstance(…) 方法，進行處理，該方法的定義為獲取給定 Bean 實例的對象，該對象要么是 bean 實例本身，要么就是 FactoryBean 創建的 Bean 對象。

看代碼：

//獲取給定Bean的實例對象，主要是完成FactoryBean的相關處理protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {// Don't let calling code try to dereference the factory if the bean isn't a factory.//容器已經得到了Bean實例對象，這個實例對象可能是一個普通的Bean，//也可能是一個工廠Bean，如果是一個工廠Bean，則使用它創建一個Bean實例對象，//如果調用本身就想獲得一個容器的引用，則指定返回這個工廠Bean實例對象//若為工廠類引用（name 以 & 開頭） 且 Bean實例也不是 FactoryBeanif (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {//拋出異常throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());}// Now we have the bean instance, which may be a normal bean or a FactoryBean.//如果類型不是FactoryBean，直接返回if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {return beanInstance;}Object object = null;//若 BeanDefinition 為 null，則從緩存中加載 Bean 對象if (mbd == null) {//從Bean工廠緩存中獲取給定名稱的Bean實例對象object = getCachedObjectForFactoryBean(beanName);}// 若 object 依然為空，則可以確認，beanInstance 一定是 FactoryBean 。從而，使用 FactoryBean 獲得 Bean 對象if (object == null) {// Return bean instance from factory.FactoryBean<?> factory = (FactoryBean<?>) beanInstance;// Caches object obtained from FactoryBean if it is a singleton.// 檢測是否定義 beanNameif (mbd == null && containsBeanDefinition(beanName)) {//從容器中獲取指定名稱的Bean定義，如果繼承基類，則合并基類相關屬性mbd = getMergedLocalBeanDefinition(beanName);}//如果從容器得到Bean定義信息，并且Bean定義信息不是虛構的，//則讓工廠Bean生產Bean實例對象boolean synthetic = (mbd != null && mbd.isSynthetic());//調用FactoryBeanRegistrySupport類的getObjectFromFactoryBean方法，//實現工廠Bean生產Bean對象實例的過程object = getObjectFromFactoryBean(factory, beanName, !synthetic);}return object;}

首先看下這個方法的流程：

1、類型檢查，判斷是否是FactoryBean
2、對非 FactoryBean 不做處理
3、對 bean 進行轉換
4、處理 FactoryBean 類型：委托getObjectFromFactoryBean 方法進行處理。

走到這里，說明這個bean一定是FactoryBean類型的，再從Ioc容器中獲取該beanName對應的BeanDefinition，如果不為null，且不是abstract，則調用getObjectFromFactoryBean方法獲取bean實例
從這里可以看出， getObjectForBeanInstance(Object beanInstance, String name, String beanName,RootBeanDefinition mbd) 方法，分成兩種情況：

第一種，當該實例對象為非 FactoryBean類型，直接返回給定的 Bean 實例對象 beanInstance 。
第二種，當該實例對象為FactoryBean 類型，從 FactoryBean ( beanInstance ) 中，獲取 Bean實例對象。

2.3.2、getObjectFromFactoryBean
我們接著看第二種情況：

//Bean工廠生產Bean實例對象protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {//為單例模式且緩存中存在if (factory.isSingleton() && containsSingleton(beanName)) {//多線程同步，以防止數據不一致 1.1 synchronized (getSingletonMutex()) {//從緩存中獲取指定的 factoryBean 1.2 Object object = this.factoryBeanObjectCache.get(beanName);if (object == null) {// 為空，則從 FactoryBean 中獲取對象object = doGetObjectFromFactoryBean(factory, beanName);// Only post-process and store if not put there already during getObject() call above// (e.g. because of circular reference processing triggered by custom getBean calls)Object alreadyThere = this.factoryBeanObjectCache.get(beanName);if (alreadyThere != null) {object = alreadyThere;}else { 1.3 if (shouldPostProcess) {try {// 對從 FactoryBean 獲取的對象進行后處理// 生成的對象將暴露給 bean 引用object = postProcessObjectFromFactoryBean(object, beanName);}catch (Throwable ex) {throw new BeanCreationException(beanName,"Post-processing of FactoryBean's singleton object failed", ex);}}//將生產的實例對象添加到Bean工廠緩存中 1.4 this.factoryBeanObjectCache.put(beanName, object);}}return object;}}// 為空，則從 FactoryBean 中獲取對象 2 else {Object object = doGetObjectFromFactoryBean(factory, beanName);// 需要后續處理if (shouldPostProcess) {try {object = postProcessObjectFromFactoryBean(object, beanName);}catch (Throwable ex) {throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);}}return object;}}

1、判斷是否為單例并且緩存中存在 如果存在，則順著1.1往下走，不存在，則走2的流程
1.1、sync加鎖，鎖住的是singletonObjects，和其他單例鎖一樣，保證全局唯一
1.2、從緩存factoryBeanObjectCache中獲取Bean實例 如果獲取不到，則調用doGetObjectFromFactoryBean()方法獲取，實際最后調用的是factory.getObject()方法
1.3、如果需要后續處理( shouldPostProcess = true )，則進行下一步處理 postProcessObjectFromFactoryBean() 方法，對從 FactoryBean 處獲取的 Bean
實例對象進行后置處理。其默認實現是直接返回 object 對象，不做任何處理。
1.4、加入到 factoryBeanObjectCache 緩存中
2、如果緩存中不存在，同樣調用doGetObjectFromFactoryBean()獲取bean實例

1.3的代碼如下：

protected Object postProcessObjectFromFactoryBean(Object object, String beanName) throws BeansException {return object;} //但是子類可以重寫，例如應用后處理器等。

到這里，doGetBean()方法的2.2從緩存中獲取單例bean和2.3獲取最終的bean實例對象我們已經分析完了

• 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中取出正在創建的prototypeObject 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();//當前容器的父級容器存在，且當前容器中不存在指定名稱的Beanif (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 - > Aprivate final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);//保存的是bean與其依賴的映射關系：A - > Bprivate 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;}// 獲取當前原始 beanNameString 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 - > Aprivate final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);//保存的是bean與其依賴的映射關系：A - > Bprivate final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);//為指定的Bean注入依賴的Beanpublic void registerDependentBean(String beanName, String dependentBeanName) {// A quick check for an existing entry upfront, avoiding synchronization...//獲取原始beanNameString 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的依賴Beansynchronized (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的依賴Beansynchronized (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 等。不同的作用域會有不同的初始化策略。

• 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() 我們大致分析完了。

總結

以上是生活随笔為你收集整理的Spring Ioc 之 Bean的加载（1）（生命周期）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。