Spring Ioc中Bean加載的方法

本篇內(nèi)容主要講解“Spring Ioc中Bean加載的方法”，感興趣的朋友不妨來(lái)看看。本文介紹的方法操作簡(jiǎn)單快捷，實(shí)用性強(qiáng)。下面就讓小編來(lái)帶大家學(xué)習(xí)“Spring Ioc中Bean加載的方法”吧!

前言

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

我們接著分析一下Ioc的bean實(shí)例化過(guò)程：

一、getBean

當(dāng)我們顯示或者隱式地調(diào)用 BeanFactory#getBean(String name) 方法時(shí)，則會(huì)觸發(fā)加載 Bean 階段。代碼如下：

// AbstractBeanFactory.java

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

內(nèi)部調(diào)用 doGetBean(String name, final Class<T> requiredType, Object[] args, boolean typeCheckOnly) 方法，其接受四個(gè)方法參數(shù)：

• name ：要獲取 Bean 的名字

• requiredType ：要獲取 bean 的類(lèi)型

• args ：創(chuàng)建 Bean 時(shí)傳遞的參數(shù)。這個(gè)參數(shù)僅限于創(chuàng)建 Bean 時(shí)使用。

• typeCheckOnly ：是否為類(lèi)型檢查。

二、doGetBean

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

		//根據(jù)指定的名稱(chēng)獲取被管理Bean的名稱(chēng)，剝離指定名稱(chēng)中對(duì)容器的相關(guān)依賴(lài)
		// 如果指定的是別名，將別名轉(zhuǎn)換為規(guī)范的Bean名稱(chēng)
<1>		final String beanName = transformedBeanName(name);
		Object bean;

		// Eagerly check singleton cache for manually registered singletons.
		// 從緩存中獲取已被創(chuàng)建過(guò)的單例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的工廠(chǎng)
			//     FactoryBean是創(chuàng)建創(chuàng)建對(duì)象的工廠(chǎng)Bean，兩者之間有區(qū)別

			//獲取給定Bean的實(shí)例對(duì)象，該對(duì)象要么是 bean 實(shí)例本身，要么就是 FactoryBean 創(chuàng)建的 Bean 對(duì)象
			//（為什么要再次獲取呢，因?yàn)樯厦娅@取的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.
			// 因?yàn)?nbsp;Spring 只解決單例模式下的循環(huán)依賴(lài)，在原型模式下如果存在循環(huán)依賴(lài)則會(huì)拋出異常。
<4>			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

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

			// 創(chuàng)建的Bean是否需要進(jìn)行類(lèi)型驗(yàn)證，一般不需要
<5>			if (!typeCheckOnly) {
				//向容器標(biāo)記指定的Bean已經(jīng)被創(chuàng)建
				markBeanAsCreated(beanName);
			}

			try {
				//從容器中獲取 beanName 相應(yīng)的 GenericBeanDefinition 對(duì)象，并將其轉(zhuǎn)換為 RootBeanDefinition 對(duì)象
				// 主要解決Bean繼承時(shí)子類(lèi)合并父類(lèi)公共屬性問(wèn)題
<6>				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				// 檢查給定的合并的 BeanDefinition (是否為抽象類(lèi))
				checkMergedBeanDefinition(mbd, beanName, args);

				// Guarantee initialization of beans that the current bean depends on.
				// 處理所依賴(lài)的 bean @DependsOn()
				// 獲取當(dāng)前Bean所有依賴(lài)Bean的名稱(chēng)
<7>				String[] dependsOn = mbd.getDependsOn();
				//如果有依賴(lài)
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						//校驗(yàn)該依賴(lài)是否已經(jīng)注冊(cè)過(guò)給當(dāng)前 Bean
						if (isDependent(beanName, dep)) {
							//已注冊(cè)，拋出異常
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
						}
						//沒(méi)有，則先注冊(cè)依賴(lài)的bean
						registerDependentBean(dep, beanName);
						//遞歸調(diào)用getBean()，先生成依賴(lài)的bean
						getBean(dep);
					}
				}

				// Create bean instance.
				//創(chuàng)建單例Bean
<8>				if (mbd.isSingleton()) {
					//這里使用了一個(gè)匿名內(nèi)部類(lèi)，創(chuàng)建Bean實(shí)例對(duì)象，并且注冊(cè)給所依賴(lài)的對(duì)象
					sharedInstance = getSingleton(beanName, () -> {
						try {
							//創(chuàng)建一個(gè)指定Bean實(shí)例對(duì)象，如果有父級(jí)繼承，則合并子類(lèi)和父類(lèi)的定義
							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緩存中清除實(shí)例對(duì)象
							destroySingleton(beanName);
							throw ex;
						}
					});
					//獲取給定Bean的實(shí)例對(duì)象
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

				//創(chuàng)建多例Bean
				else if (mbd.isPrototype()) {
					//原型模式(Prototype)是每次都會(huì)創(chuàng)建一個(gè)新的對(duì)象
					Object prototypeInstance = null;
					try {
						//加載前置處理，默認(rèn)的功能是注冊(cè)當(dāng)前創(chuàng)建的原型對(duì)象
						beforePrototypeCreation(beanName);
						//創(chuàng)建指定Bean對(duì)象實(shí)例
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						//加載后置處理，默認(rèn)的功能告訴IOC容器指定Bean的原型對(duì)象不再創(chuàng)建
						afterPrototypeCreation(beanName);
					}
					//獲取給定Bean的實(shí)例對(duì)象
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}

				//要?jiǎng)?chuàng)建的Bean既不是Singleton也不是Prototype
				//如：request、session、application等生命周期
				else {
					String scopeName = mbd.getScope();
					final Scope scope = this.scopes.get(scopeName);
					//Bean定義資源中沒(méi)有配置生命周期范圍，則Bean定義不合法
					if (scope == null) {
						throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
					}
					try {
						//這里又使用了一個(gè)匿名內(nèi)部類(lèi)，獲取一個(gè)指定生命周期范圍的實(shí)例
						Object scopedInstance = scope.get(beanName, () -> {
							//前置處理
							beforePrototypeCreation(beanName);
							try {
								return createBean(beanName, mbd, args);
							}
							finally {
								//后置處理
								afterPrototypeCreation(beanName);
							}
						});
						//獲取給定Bean的實(shí)例對(duì)象
						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.
		//對(duì)創(chuàng)建的Bean實(shí)例對(duì)象進(jìn)行類(lèi)型檢查
<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;
	}

代碼很長(zhǎng)，需要一些耐心，下面我們來(lái)逐步分析這段代碼：

• <1>處：具體分析，見(jiàn)2.1獲取原始beanName

• <2>處: 具體分析，見(jiàn)2.2從緩存中獲取單例bean

• <3>處: 具體分析，見(jiàn)2.3獲取最終的bean實(shí)例對(duì)象

• <4>處: 具體分析，見(jiàn)2.4原型模式依賴(lài)檢查

• <5>處: 具體分析，見(jiàn)2.5標(biāo)記bean為已創(chuàng)建或即將創(chuàng)建

• <6>處: 具體分析，見(jiàn)2.6獲取BeanDefinition

• <7>處: 具體分析，見(jiàn)2.7bean依賴(lài)處理

• <8>處: 具體分析，見(jiàn)2.8不同作用域bean的實(shí)例化

• <9>處: 具體分析，見(jiàn)2.9類(lèi)型轉(zhuǎn)換

2.1、獲取原始beanName

代碼如下：

final String beanName = transformedBeanName(name);

繼續(xù)深入，代碼如下：

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

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

//對(duì)FactoryBean的轉(zhuǎn)義定義，因?yàn)槿绻褂胋ean的名字檢索FactoryBean得到的對(duì)象是工廠(chǎng)生成的對(duì)象，
	//如果需要得到工廠(chǎng)本身，需要轉(zhuǎn)義
	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: 如果一個(gè)factoryBean的名稱(chēng)為“student”，獲取factoryBean創(chuàng)建的Bean時(shí)，使用getBean("student")，獲取factoryBean本身時(shí)，使用getBean("&student")
接著深入，最終代碼如下：

/** Map from alias to canonical name */
	private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);


//循環(huán)處理，從aliasMap中根據(jù)aliasName獲取真實(shí)beanName，直到獲取到的真實(shí)beanName為null
	public 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;
	}

主要是一個(gè)循環(huán)獲取 beanName 的過(guò)程，例如，別名 A 指向名稱(chēng)為 B 的 bean 則返回 B，若 別名 A 指向別名 B，別名 B 指向名稱(chēng)為 C 的 bean，則返回 C

2.2、從緩存中獲取單例bean

Spring 對(duì)單例模式的 bean 只會(huì)創(chuàng)建一次。后續(xù)，如果再獲取該 Bean ，則是直接從單例緩存中獲取，該過(guò)程就體現(xiàn)在 #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 */
	//單例對(duì)象工廠(chǎng)緩存
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

	/** Cache of early singleton objects: bean name --> bean instance */
	//預(yù)加載單例bean緩存
	//存放的 bean 不一定是完整的
	private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

//對(duì)于單例模式的Bean整個(gè)IOC容器中只創(chuàng)建一次，不需要重復(fù)創(chuàng)建
	@Nullable
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		//從單例緩存中獲取單例bean
		Object singletonObject = this.singletonObjects.get(beanName);
		//如果緩存中沒(méi)有 并且 該bean正在創(chuàng)建
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			synchronized (this.singletonObjects) {
				singletonObject = this.earlySingletonObjects.get(beanName);
				// earlySingletonObjects 中沒(méi)有，且允許提前創(chuàng)建
				if (singletonObject == null && allowEarlyReference) {
					//從緩存中獲取 ObjectFactory
					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
						//從單例工廠(chǎng)中獲取bean
						singletonObject = singletonFactory.getObject();
						//存入early
						this.earlySingletonObjects.put(beanName, singletonObject);
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
		return singletonObject;
	}

這段代碼很簡(jiǎn)單，流程如下：

• 第一步，從singletonObjects中獲取Bean對(duì)象

• 第二步，如果獲取不到且Bean正在創(chuàng)建中，從earlySingletonObjects獲取Bean對(duì)象

• 第三步，如果獲取不到且允許提前創(chuàng)建,從singletonFactories獲取FactoryBean

• 第四步，如果不為null，則通過(guò)FactoryBean.getObject()獲取Bean，然后將其加入到 earlySingletonObjects ，并且從 singletonFactories 刪除，兩者是互斥的，主要用來(lái)解決循環(huán)依賴(lài)的問(wèn)題

• 總結(jié)就是：從這三個(gè)Map依次去取，取不到就取下一個(gè)Map

2.2.1、isSingletonCurrentlyInCreation

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

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

這個(gè)方法是用來(lái)判斷當(dāng)前Bean是否在創(chuàng)建中，看到是個(gè)Map，我們可以猜測(cè)，應(yīng)該有一個(gè)地方在創(chuàng)建Bean的時(shí)候，會(huì)把正在創(chuàng)建的BeanName給put到這個(gè)Map中。具體我們之后將。

2.2.2、getObjectForBeanInstance

當(dāng)我們從getSingleton(beanName)拿到bean對(duì)象后，會(huì)接著調(diào)用getObjectForBeanInstance()方法，來(lái)獲取最終的Bean實(shí)例。

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

• 因?yàn)槲覀儚木彺嬷蝎@取的 bean 是最原始的 Bean ，并不一定是我們最終想要的 Bean

• 怎么辦呢？調(diào)用 #getObjectForBeanInstance(...) 方法，進(jìn)行處理，該方法的定義為獲取給定 Bean 實(shí)例的對(duì)象，該對(duì)象要么是 bean 實(shí)例本身，要么就是 FactoryBean 創(chuàng)建的 Bean 對(duì)象。

看代碼：

//獲取給定Bean的實(shí)例對(duì)象，主要是完成FactoryBean的相關(guān)處理
	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.
		//容器已經(jīng)得到了Bean實(shí)例對(duì)象，這個(gè)實(shí)例對(duì)象可能是一個(gè)普通的Bean，
		//也可能是一個(gè)工廠(chǎng)Bean，如果是一個(gè)工廠(chǎng)Bean，則使用它創(chuàng)建一個(gè)Bean實(shí)例對(duì)象，
		//如果調(diào)用本身就想獲得一個(gè)容器的引用，則指定返回這個(gè)工廠(chǎng)Bean實(shí)例對(duì)象

		//若為工廠(chǎng)類(lèi)引用（name 以 & 開(kāi)頭） 且 Bean實(shí)例也不是 FactoryBean
		if (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.
		
		//如果類(lèi)型不是FactoryBean，直接返回
		if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
			return beanInstance;
		}

		Object object = null;
		//若 BeanDefinition 為 null，則從緩存中加載 Bean 對(duì)象
		if (mbd == null) {
			//從Bean工廠(chǎng)緩存中獲取給定名稱(chēng)的Bean實(shí)例對(duì)象
			object = getCachedObjectForFactoryBean(beanName);
		}

		// 若 object 依然為空，則可以確認(rèn)，beanInstance 一定是 FactoryBean 。從而，使用 FactoryBean 獲得 Bean 對(duì)象
		if (object == null) {
			// Return bean instance from factory.
			FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
			// Caches object obtained from FactoryBean if it is a singleton.
			// 檢測(cè)是否定義 beanName
			if (mbd == null && containsBeanDefinition(beanName)) {
				//從容器中獲取指定名稱(chēng)的Bean定義，如果繼承基類(lèi)，則合并基類(lèi)相關(guān)屬性
				mbd = getMergedLocalBeanDefinition(beanName);
			}
			//如果從容器得到Bean定義信息，并且Bean定義信息不是虛構(gòu)的，
			//則讓工廠(chǎng)Bean生產(chǎn)Bean實(shí)例對(duì)象
			boolean synthetic = (mbd != null && mbd.isSynthetic());
			//調(diào)用FactoryBeanRegistrySupport類(lèi)的getObjectFromFactoryBean方法，
			//實(shí)現(xiàn)工廠(chǎng)Bean生產(chǎn)Bean對(duì)象實(shí)例的過(guò)程
			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
		}
		return object;
	}

首先看下這個(gè)方法的流程：

• 1、類(lèi)型檢查，判斷是否是FactoryBean

• 2、對(duì)非 FactoryBean 不做處理

• 3、對(duì) bean 進(jìn)行轉(zhuǎn)換

• 4、處理 FactoryBean 類(lèi)型：委托給 getObjectFromFactoryBean 方法進(jìn)行處理。

我們直接看第3步，走到這里，說(shuō)明這個(gè)bean一定是FactoryBean類(lèi)型的，再?gòu)腎oc容器中獲取該beanName對(duì)應(yīng)的BeanDefinition，如果不為null，且不是abstract，則調(diào)用getObjectFromFactoryBean方法獲取bean實(shí)例

從這里可以看出， getObjectForBeanInstance(Object beanInstance, String name, String beanName,RootBeanDefinition mbd) 方法，分成兩種情況：

• 第一種，當(dāng)該實(shí)例對(duì)象為非 FactoryBean 類(lèi)型，直接返回給定的 Bean 實(shí)例對(duì)象 beanInstance 。

• 第二種，當(dāng)該實(shí)例對(duì)象為FactoryBean 類(lèi)型，從 FactoryBean ( beanInstance ) 中，獲取 Bean 實(shí)例對(duì)象。

2.2.3、getObjectFromFactoryBean

我們接著看第二種情況：

//Bean工廠(chǎng)生產(chǎn)Bean實(shí)例對(duì)象
	protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
		//為單例模式且緩存中存在
		if (factory.isSingleton() && containsSingleton(beanName)) {
			//多線(xiàn)程同步，以防止數(shù)據(jù)不一致
1.1			synchronized (getSingletonMutex()) {
				//從緩存中獲取指定的 factoryBean
1.2				Object object = this.factoryBeanObjectCache.get(beanName);
				if (object == null) {
					// 為空，則從 FactoryBean 中獲取對(duì)象
					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 {
								// 對(duì)從 FactoryBean 獲取的對(duì)象進(jìn)行后處理
								// 生成的對(duì)象將暴露給 bean 引用
								object = postProcessObjectFromFactoryBean(object, beanName);
							}
							catch (Throwable ex) {
								throw new BeanCreationException(beanName,
										"Post-processing of FactoryBean's singleton object failed", ex);
							}
						}
						//將生產(chǎn)的實(shí)例對(duì)象添加到Bean工廠(chǎng)緩存中
1.4						this.factoryBeanObjectCache.put(beanName, object);
					}
				}
				return object;
			}
		}
		// 為空，則從 FactoryBean 中獲取對(duì)象
2		else {
			Object object = doGetObjectFromFactoryBean(factory, beanName);
			// 需要后續(xù)處理
			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實(shí)例 如果獲取不到，則調(diào)用doGetObjectFromFactoryBean()方法獲取，實(shí)際最后調(diào)用的是factory.getObject()方法

• 1.3、如果需要后續(xù)處理( shouldPostProcess = true )，則進(jìn)行下一步處理 postProcessObjectFromFactoryBean() 方法，對(duì)從 FactoryBean 處獲取的 Bean 實(shí)例對(duì)象進(jìn)行后置處理。其默認(rèn)實(shí)現(xiàn)是直接返回 object 對(duì)象，不做任何處理。代碼如下：

protected Object postProcessObjectFromFactoryBean(Object object, String beanName) throws BeansException {
		return object;
	}

但是子類(lèi)可以重寫(xiě)，例如應(yīng)用后處理器等。

• 1.4、加入到 factoryBeanObjectCache 緩存中

• 2、如果緩存中不存在，同樣調(diào)用doGetObjectFromFactoryBean()獲取bean實(shí)例

到此，相信大家對(duì)“Spring Ioc中Bean加載的方法”有了更深的了解，不妨來(lái)實(shí)際操作一番吧！這里是億速云網(wǎng)站，更多相關(guān)內(nèi)容可以進(jìn)入相關(guān)頻道進(jìn)行查詢(xún)，關(guān)注我們，繼續(xù)學(xué)習(xí)！