一文帶你解讀Spring5原始碼解析 IOC之開啟Bean的載入，以及FactoryBean和BeanFactory的區別。

前言

通過往期的文章我們已經瞭解了Spring對XML配置檔案的解析，將分析的資訊組裝成BeanDefinition，並將其儲存到相應的BeanDefinitionRegistry中，至此Spring IOC的初始化工作已經完成，這篇文章主要對Bean的載入進行一個深入的瞭解及探索。

想要了解Bean就必要要知道介面BeanFactory，接下來我們就從BeanFactory切入

BeanFactory

我們在呼叫getBean()方法時，無論是顯示呼叫還是隱式呼叫。都會觸發Bean載入的階段。demo如下：

@Test
public void Test(){
	//使用BeanFactory方式載入XML.
	BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));
	MyTestBean myTestBean = (MyTestBean) beanFactory.getBean("myTestBean");
	System.out.println(myTestBean.getName());
}

實際上這個getBean方法是在介面BeanFactory中定義的。我們先看一下BeanFactory的類圖：

根據如上類圖最一個簡單的整理：

• BeanFactory作為一個主介面不繼承實現任何介面，我們可以定義為一級介面。

• 有3個子介面都繼承了它，進行功能上的增強，這3個子介面我們可以定義為二級介面。

• ConfiguratbleBeanFactory我們可以定義為三級介面，對二級介面HierarchicalBeanFactory，進行再次增強。它還繼承了另外一個介面SingletomBeanRegistry

• ConfigurableListableBeanFactory是一個更強大的介面，繼承了上述的所有介面，無所不包，我們可以定義為四級介面，(這4級介面是BeanFactory的基本介面體系，繼續，下面是繼承關係的2個抽象類和2個實現類)

• AbstractBeanFactory作為一個抽象類，實現了三級介面ConfigurableBe·anFactory

• AbstractAutowireCapableBeanFactory同樣是抽象類繼承自AbstractBeanFactory，並額外實現了二級介面AutowireCapableBeanFactory

• DefaultListableBeanFactory繼承自AbstractAutowireCapableBeanFactory實現了強大的四級介面ConfigurableListableBeanFactory，並實現了一個外來介面BeanDefinitionRegistry，它並非抽象類。

• 最後就是強大的XmlBeanFactory繼承自DefaultListableBeanFactory，重寫了一些功能，是自己更強大。

BeanFactory，以Factory結尾，表示它是一個工廠類(介面)，它負責生產和管理Bean的一個工廠。在Spring中，BeanFactory是IOC容器的核心介面，它的職責包括：例項化、定位、配置應用程式中的物件及建立這些物件間的依賴。BeanFactory只是一個介面，並不是IOC的具體實現，但Spring容器給出了很多種實現，如：DefaultListableBeanFactory、XmlBeanFactory、ApplicationContext等，其中XmlBeanFactory就是常用的一個，該實現將以XML方式描述元件應用的物件及物件之間的依賴關係。XmlBeanFactory類將持有此Xml配置後設資料，並用它來構建一個完全可配置的系統或應用。

BeanFactory是Spring IOC容器的鼻祖，是IOC容器的基礎介面，所有的容器都是從它這裡繼承實現而來的。可以見其地位是多麼重要。BeanFactory提供了最基本的IOC容器的功能，即所有的容器至少需要實現的標準。

XmlBeanFactory，只是提供了最基本的IOC容器的功能。而且XmlBeanFactory繼承自DefaultListableBeanFactory。DefaultListableBeanFactory實際包含了基本IOC容器所具有的所有重要功能，是一個完整的IOC容器

ApplicationContext包含了BeanFactory的所有功能，通常建議比BeanFactory優先。

BeanFactory體系結構是典型的工廠方法模式，即什麼樣的工廠生產什麼樣的產品。BeanFactory是最基本的抽象工廠，而其它的IOC容器只不過是具體的工廠，對應著各自的Bean定義方法。但同時，其它容器也針對具體場景不同，進行了擴充，提供了具體的服務，如下：

// 1
Resource resource = new FileSystemResource("beans.xml");
BeanFactory factory = new XmlBeanFactory(resource);
// 2
ClassPathResource resource = new ClassPathResource("beans.xml");
BeanFactory factory = new XmlBeanFactory(resource);
// 3
ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"applicationContext.xml"});
BeanFactory factory = (BeanFactory) context;

大概就是這些了，接著使用getBean(String beanName)方法取得bean的例項；BeanFactory提供的方法極其簡單，僅僅提供了六種方法供客戶呼叫：

• boolean containsBean(String name);判斷工廠中是否包含了給定名稱的Bean定義，若有則返回true
• Object getBean(String name);返回給定名稱註冊的bean例項。根據Bean的配置情況，如果是singleton模式將返回一個共享的例項，否則將返回一個新建的例項，如果沒有找到指定Bean，該方法會丟擲異常(BeansException)。
• < T> T getBean(String name, Class requiredType) ;返回給定名稱註冊的Bean例項，並轉換為給定class型別。
• boolean isSingleton(String name); 判斷給定名稱的Bean定義是否是單例模式。
• Class<?> getType(String name); 返回給定名稱的Bean的Class，如果沒有找到指定的Bean例項，則丟擲NoSuchBeanDefinitionException異常。
• String[] getAliases(String name); 返回給定名稱Bean的所有別名。

我們大致看一下BeanFactory原始碼裡的所有方法。

public interface BeanFactory {
	String FACTORY_BEAN_PREFIX = "&";
	Object getBean(String name) throws BeansException;
	<T> T getBean(String name, Class<T> requiredType) throws BeansException;
	Object getBean(String name, Object... args) throws BeansException;
	<T> T getBean(Class<T> requiredType) throws BeansException;
	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
	<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
	<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);
	Boolean containsBean(String name);
	Boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
	Boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
	Boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
	Boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
	@Nullable
	Class<?> getType(String name) throws NoSuchBeanDefinitionException;
	@Nullable
	Class<?> getType(String name, Boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;
	String[] getAliases(String name);
}

FactoryBean

概述：一一般情況下，Spring通過反射機制利用< bean>的class屬性指定實現類例項化Bean，在某些情況下，例項化Bean的過程比較複雜，如果按照傳統的方式，則需要在< bean>中提供大量的配置資訊；配置方式的靈活性是受限的，這是採用編碼的方式可能會得到一個簡單的方案。Spring為此提供了一個org.springframework.beans.factory.FactoryBean的工廠類介面，使用者可以通過實現該介面定製例項化Bean的邏輯。FactoryBean介面對於Spring框架來說佔有重要的地位，Spring自身就提供了70多個Factory Bean的實現，它們隱藏例項化一些複雜Bean的細節，給上層應用帶來了便利，從Spring3.0開始，FactoryBean開始支援泛型，即介面宣告改為FactoryBean< T>的形式。

以Bean結尾，表示它是一個Bean，不同於普通Bean的是：它實現了FactoryBean< T> 介面的Bean，根據該Bean的ID從BeanFactory中獲取的實際上是FactoryBean的getObject()返回的物件，而不是FactoryBean本身，如果想要獲取FactoryBean物件，請在id前面加一個&符號來獲取。

• 看原始碼(FactoryBean.java)

public interface FactoryBean<T> {
	String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";
	@Nullable
	T getObject() throws Exception;
	@Nullable
	Class<?> getObjectType();
	default Boolean isSingleton() {
		return true;
	}
}

從上述原始碼中我們可以看到，該介面一共定義了3個方法：

• T getObject() throws Exception; 返回由FactoryBean建立的Bean例項，如果isSingleton()返回true，則該例項會放到Spring容器中單例例項快取池中；
• Class<?> getObjectType(); 返回FactoryBean建立的Bean例項；
• default boolean isSingleton() { return true;} 返回FactoryBean建立的Bean例項的作用域是singleton還是prototype；

補充：當配置檔案中< bean>的class屬性配置的實現類是FactoryBean時，通過getBean()方法返回的不是FactoryBean本身，而是FactoryBean中的getObject()方法所返回的物件，相當於FactoryBean的getObject()代理了getBean()方法。

例如：如果使用傳統方式配置下面的Car的< bean>時，Car的每個屬性分別對應一個< property>元素標籤。

public class Car {
	private int maxSpeed ;
	private String brand ;
	private double price ;
	//get//set 方法
}

如果使用FactoryBean的方式實現的話就比較靈活，下例通過逗號的分割的方式一次性為Car的所有屬性指定配置值。

import  org.springframework.beans.factory.FactoryBean;
public  class CarFactoryBean implements  FactoryBean<Car> {
	private String carInfo ;
	public  Car getObject()  throws  Exception  {
		Car car = new  Car();
		String[] infos = carInfo.split(",");
		car.setBrand(infos[0]);
		car.setMaxSpeed(Integer.valueOf(infos[1]));
		car.setPrice(double.valueOf(infos[2]));
		return  car;
	}
	public  Class<Car> getObjectType(){
		return Car.class ;
	}
	public Boolean isSingleton(){
		return false ;
	}
	public String getCarInfo(){
		return  this.carInfo;
	}
	//接受逗號分割符設定屬性資訊  
	public void setCarInfo (String carInfo){
		this.carInfo = carInfo;
	}
}

根據上述的CarFactoryBean，在配置檔案中使用如下的方式進行配置

<bean d="car"class="com.vipbbo.spring.CarFactoryBean" P:carInfo="大奔,600,1000000"/>

當呼叫getBean("car")時，Spring通過反射機制發現CarFactoryBean實現了FactoryBean的介面，這時Spring容器就呼叫介面方法CarFactoryBean的getObject()方法返回。如果希望獲取CarFactoryBean的例項，則需要在使用getBean(BeanName)方法時在BeanName前面加上"&"字首：比如：getBean("&car");

獲取Bean

接下來我們繼續回到文章一開始講的bean的載入階段，當我們顯式或隱式呼叫getBean()時，則會觸發載入Bean的階段，具體實現如下：

• 看原始碼(AbstractBeanFactory.java)

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

getBean()方法內部又呼叫了dogetBean()方法：

• 看原始碼(AbstractBeanFactory.java)

protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, Boolean typeCheckOnly)
			throws BeansException {
	// 獲取 beanName，這裡是一個轉換動作，將 name 轉換為 beanName
	String beanName = transformedBeanName(name);
	Object beanInstance;
	/*
			檢查快取中的例項工程是否存在對應的bean例項。
			為何要優先使用這段程式碼呢？
				因為在建立單例bean的時候會存在依賴注入的情況，而在建立依賴的時候為了避免迴圈依賴，Spring建立Bean的原則是在不等Bean建立完就會將
				建立Bean的 objectFactory 提前曝光，即將其加入到快取中，一旦下一個 Bean 建立時依賴上一個Bean則直接使用 objectFactory，直接
			從快取中或 singletonFactories 獲取 objectFactory
				就算沒有迴圈依賴，只是單純的依賴注入，如：B依賴A，如果A已經初始化完成，B進行初始化時，需要遞迴呼叫getBean()獲取去A，這時A已經在
				快取裡了，可以直接在這裡獲取到。
		 */
	// Eagerly check singleton cache for manually registered singletons.
	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 + "'");
			}
		}
		// 返回對應的例項，有些時候並不是直接返回例項，而是返回某些方法返回的例項
		/*
			 這裡涉及到我們上面講的FactoryBean，如果此 Bean 是 FactoryBean 的實現類，如果name字首為 "&"，則直接返回此實現類的Bean，如果
			  沒有字首，則需要呼叫此實現類的getObject方法，返回getObject裡真實的返回物件。
			 */
		beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
	} else {
		// Fail if we're already creating this bean instance:
		// We're assumably within a circular reference.
		//　只有在單例的情況下才會解決迴圈依賴
		if (isPrototypeCurrentlyInCreation(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}
		// Check if bean definition exists in this factory.
		// 嘗試從 parentBeanFactory 中查詢 bean
		BeanFactory parentBeanFactory = getParentBeanFactory();
		if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
			// Not found -> check parent.
			String nameToLookup = originalBeanName(name);
			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 if (requiredType != null) {
				// No args -> delegate to standard getBean method.
				return parentBeanFactory.getBean(nameToLookup, requiredType);
			} else {
				return (T) parentBeanFactory.getBean(nameToLookup);
			}
		}
		// 如果不是僅僅做型別檢查，則這裡需要建立bean，並做記錄
		if (!typeCheckOnly) {
			markBeanAsCreated(beanName);
		}
		StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
							.tag("beanName", name);
		try {
			if (requiredType != null) {
				beanCreation.tag("beanType", requiredType::toString);
			}
			// 將儲存XML配置檔案的GenericBeanDefinition轉換成RootBeanDefinition，同時如果存在父Bean合併父Bean的相關屬性
			RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
			checkMergedBeanDefinition(mbd, beanName, args);
			// Guarantee initialization of beans that the current bean depends on.
			// 如果存在依賴，則需要遞迴例項化依賴的Bean
			String[] dependsOn = mbd.getDependsOn();
			if (dependsOn != null) {
				for (String dep : dependsOn) {
					if (isDependent(beanName, dep)) {
						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
															"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
					}
					registerDependentBean(dep, beanName);
					try {
						getBean(dep);
					}
					catch (NoSuchBeanDefinitionException ex) {
						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
															"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
					}
				}
			}
			// Create bean instance.
			// 單例模式的Bean
			if (mbd.isSingleton()) {
				// 例項化依賴的Bean後對Bean本身進行例項化
				sharedInstance = getSingleton(beanName, () -> {
					try {
						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.
						destroySingleton(beanName);
						throw ex;
					}
				}
				);
				beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
			}
			// 原型模式 else if (mbd.isPrototype()) {
				// It's a prototype -> create a new instance.
				Object prototypeInstance = null;
				try {
					beforePrototypeCreation(beanName);
					prototypeInstance = createBean(beanName, mbd, args);
				}
				finally {
					afterPrototypeCreation(beanName);
				}
				beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
			}
			// 從指定的 scope 模式下建立 Bean else {
				String scopeName = mbd.getScope();
				if (!StringUtils.hasLength(scopeName)) {
					throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
				}
				Scope scope = this.scopes.get(scopeName);
				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);
						}
					}
					);
					beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
				}
				catch (IllegalStateException ex) {
					throw new ScopeNotActiveException(beanName, scopeName, ex);
				}
			}
		}
		catch (BeansException ex) {
			beanCreation.tag("exception", ex.getClass().toString());
			beanCreation.tag("message", String.valueOf(ex.getMessage()));
			cleanupAfterBeanCreationFailure(beanName);
			throw ex;
		}
		finally {
			beanCreation.end();
		}
	}
	return adaptBeanInstance(name, beanInstance, requiredType);
}

@SuppressWarnings("unchecked")
<T> T adaptBeanInstance(String name, Object bean, @Nullable Class<?> requiredType) {
	// Check if required type matches the type of the actual bean instance.
	if (requiredType != null && !requiredType.isInstance(bean)) {
		try {
			Object convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
			if (convertedBean == null) {
				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
			}
			return (T) convertedBean;
		}
		catch (TypeMismatchException ex) {
			if (logger.isTraceEnabled()) {
				logger.trace("Failed to convert bean '" + name + "' to required type '" +
											ClassUtils.getQualifiedName(requiredType) + "'", ex);
			}
			throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
		}
	}
	return (T) bean;
}

dogetBean()方法的原始碼時相當的長，一共包含了兩部分，也可以說是一部分，接下來：進行拆分講解：

1. 獲取BeanName

• 看原始碼(AbstractBeanFactory.java)

// 獲取 beanName，這裡是一個轉換動作，將 name 轉換為 beanName
String beanName = transformedBeanName(name);

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

• 原始碼分析

這裡要注意傳遞的name，不一定就是beanName，也有可能是aliasName 別名，也有可能是FactoryBean(帶有”&“字首)，因此這裡需要呼叫transformeBeanName()進行一下轉換，主要內容如下：

• 看原始碼(BeanFactoryUtils.java)

public static String transformedBeanName(String name) {
	// 這個方法主要是去掉FactoryBean的修飾符 &
	Assert.notNull(name, "'name' must not be null");
	if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
		return name;
	}
	return transformedBeanNameCache.computeIfAbsent(name, beanName -> {
		do {
			beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
		}
		while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
		return beanName;
	}
	);
}

對aliasName別名的轉換

public String canonicalName(String name) {
	// 這個方法是轉換aliasName
	String canonicalName = name;
	// Handle aliasing...
	String resolvedName;
	do {
		resolvedName = this.aliasMap.get(canonicalName);
		if (resolvedName != null) {
			canonicalName = resolvedName;
		}
	}
	while (resolvedName != null);
	return canonicalName;
}

• 原始碼分析

上述的處理過程大致可以分為兩步：

1. 去除FactoryBean的修飾符，如果name以"&"為字首，那麼會去掉"&"，例如：name="&testService"，去除之後的結果是name=”testService“
2. 取出指定的alias所表示的最終的beanName，主要是一個迴圈beanName的過程，例如別名A指向名稱為B的bean則返回B，若別名A指向別名B，別名B指向名稱為C的bean，則返回C。

快取中獲取單例Bean

單例在Spring的同一個容器中只會被建立一次，後續再獲取Bean直接從單例快取中獲取即可，當然這裡也只是嘗試載入，首先嚐試先從快取中載入，然後再次從singletonFactory載入；因為在建立單例bean的時候會存在依賴注入的情況，而在建立依賴的時候為了避免迴圈依賴，Spring建立bean的原則是不等bean建立完成就會建立bean的ObjectFactory提早曝光加入到快取中，一旦下一個bean建立時需要依賴上個bean，則直接使用ObejectFactory；就算沒有迴圈依賴，只是單純的依賴注入，如：B依賴A，如果A已經初始化完成，B進行初始化時，需要遞迴呼叫getBean()獲取A，這時A已經在快取裡面了，直接可以從快取裡面獲取到，接下來我們看獲取單例bean的方法：

Object sharedInstance = getSingleton(beanName);

• 看原始碼(DefaultSingletonBeanRegistry.java)

@Override
@Nullable
public Object getSingleton(String beanName) {
	// 引數true，代表允許早期依賴
	return getSingleton(beanName, true);
}

@Nullable
protected Object getSingleton(String beanName, Boolean allowEarlyReference) {
	// Quick check for existing instance without full singleton lock
	// 檢查快取中是否存在例項，這裡就是說上面的單純的依賴注入，假設B依賴A，如果A已經初始化完成，B進行初始化時，需要遞迴呼叫getBean獲取A，這時
	// A已經在快取裡面了，直接可以從快取中獲取到。
	Object singletonObject = this.singletonObjects.get(beanName);
	// 如果快取為空，且單例Bean正在建立中，則鎖定全域性變數，
	// 為什麼要判斷單例Bean是否在建立中呢？
	// 		這裡就是可以判斷是否是迴圈依賴了。
	//		A依賴B，B也依賴A，A例項化的時候發現依賴B，則遞迴去例項化B；B又發現依賴A，則遞迴例項化A。這個時候就會回到原點A的例項化，第一次A的
	//		例項化還沒有完成，只不過是把例項化的物件加入到快取中了，但是狀態還是正在建立中。由此回到原點A發現A正在建立中，便可以根據此來判斷這
	//		是迴圈依賴了
	if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
		// 嘗試從 earlySingletonObjects 裡面獲取 如果此Bean正在載入，則不對其進行處理
		singletonObject = this.earlySingletonObjects.get(beanName);
		if (singletonObject == null && allowEarlyReference) {
			synchronized (this.singletonObjects) {
				// Consistent creation of early reference within full singleton lock
				// 嘗試從singletonObjects裡面獲取例項
				singletonObject = this.singletonObjects.get(beanName);
				if (singletonObject == null) {
					// 當某些方法需要提前初始化的時候會直接呼叫 addSingletonFactory 把對應的 ObjectFactory 初始化策略 儲存在
					// singletonFactories中。
					singletonObject = this.earlySingletonObjects.get(beanName);
					if (singletonObject == null) {
						ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
						if (singletonFactory != null) {
							// 使用預先設定的getObject方法
							singletonObject = singletonFactory.getObject();
							this.earlySingletonObjects.put(beanName, singletonObject);
							this.singletonFactories.remove(beanName);
						}
					}
				}
			}
		}
	}
	return singletonObject;
}

• 原始碼分析

我們對上述方法進行一個簡單的梳理，

首先該方法先從singletonObjects裡獲取例項；

如果獲取不到會從earlySingletonObjects裡面獲取例項；

如果還是獲取不到，再次嘗試從singletonFactories裡面獲取beanName對應的ObjectFactory，並從singletonFactories裡面remove掉這個ObjectFactory，而對於後續所有的記憶體操作都只為了迴圈依賴檢測時候使用，即allowEarlyReference為true時才會使用。

以上程式碼涉及到了很多個儲存bean的不同Map：

singletonObjects：用於儲存BeanName和建立Bean例項之間的關係，beanName->bean Instance

singletonFactories：用於儲存BeanName和建立Bean的工廠之間的聯絡，beanName->ObjectFactory

earlySingletonObjects：同樣也是用於儲存BeanName和建立Bean例項之間的關係，與singletonObjects的不同之處在於：當一個單例bean被放到這裡面後，那麼當bean還在建立過程中，就可以通過getBean方法獲取到了，其目的是用來檢測迴圈依賴的引用。

registeredSingletons：用來儲存當前所有已經註冊的bean。

從bean的例項中獲取物件

獲取到bean以後就要獲取例項物件了，這裡用到的時getObjectForBeanInstance方法。getObjectForBeanInstance是一個頻繁使用的方法，無論是從快取中獲取bean還是根據不同的scope策略載入Bean；總之，我們得到bean的例項後，要做的第一步就是呼叫這個方法來檢測一下正確性，其實就是檢測獲得的Bean是不是FactoryBean型別的bean，

如果是那麼需要呼叫該bean對應的FactoryBean例項中的getObject()作為返回值。

• 看原始碼(AbstractBeanFactory.java)

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.
	// 如果指定的name 是工廠相關的
	if (BeanFactoryUtils.isFactoryDereference(name)) {
		// 如果是 NullBean 則直接返回此Bean
		if (beanInstance instanceof NullBean) {
			return beanInstance;
		}
		// 如果不是FactoryBean 型別，則直接丟擲異常
		if (!(beanInstance instanceof FactoryBean)) {
			throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
		}
		if (mbd != null) {
			mbd.isFactoryBean = true;
		}
		return beanInstance;
	}
	// Now we have the bean instance, which may be a normal bean or a FactoryBean.
	// If it's a FactoryBean, we use it to create a bean instance, unless the
	// caller actually wants a reference to the factory.
	// 如果獲取的beanInstance不是FactoryBean型別，說明是普通的Bean，可直接返回
	// 如果獲取的beanInstance是FactoryBean 型別，但是是以&開頭，也可直接返回，此時返回的是FactoryBean例項
	if (!(beanInstance instanceof FactoryBean)) {
		return beanInstance;
	}
	Object object = null;
	if (mbd != null) {
		mbd.isFactoryBean = true;
	} else {
		object = getCachedObjectForFactoryBean(beanName);
	}
	if (object == null) {
		// Return bean instance from factory.
		FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
		// Caches object obtained from FactoryBean if it is a singleton.
		if (mbd == null && containsBeanDefinition(beanName)) {
			mbd = getMergedLocalBeanDefinition(beanName);
		}
		Boolean synthetic = (mbd != null && mbd.isSynthetic());
		// 到這裡說明了獲取的beanInstance是FactoryBean型別的，但是沒有以&開頭，此時就要返回factory內部的getObject裡面的物件了。
		// getObjectFromFactoryBean 核心方法
		object = getObjectFromFactoryBean(factory, beanName, !synthetic);
	}
	return object;
}

接下來我們繼續看一下里面的核心方法getObjectFromFactoryBean()

• 看原始碼(FactoryBeanRegistrySupport.java)

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, Boolean shouldPostProcess) {
	// 滿足是單例並且快取中存在的
	if (factory.isSingleton() && containsSingleton(beanName)) {
		synchronized (getSingletonMutex()) {
			// 從快取中獲取FactoryBean根據BeanName
			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 {
					// 需要後續處理
					if (shouldPostProcess) {
						// 若該 bean 處於建立中，則返回非處理物件，而不是儲存它
						if (isSingletonCurrentlyInCreation(beanName)) {
							// Temporarily return non-post-processed object, not storing it yet..
							return object;
						}
						// 前置處理
						beforeSingletonCreation(beanName);
						try {
							// 對從 FactoryBean 獲取的物件進行後處理
							// 生成的物件將暴露給bean引用
							object = postProcessObjectFromFactoryBean(object, beanName);
						}
						catch (Throwable ex) {
							throw new BeanCreationException(beanName,
																	"Post-processing of FactoryBean's singleton object failed", ex);
						}
						finally {
							// 後置處理
							afterSingletonCreation(beanName);
						}
					}
					// 快取
					if (containsSingleton(beanName)) {
						this.factoryBeanObjectCache.put(beanName, object);
					}
				}
			}
			return object;
		}
	}
	// 非單例 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;
	}
}

• 原始碼分析

getObjectFromFactoryBean()該方法就是建立例項物件中的核心方法之一。我們關注它之中的單個方法即可：beforeSingletonCreation，afterSingletonCreation，postProcessObjectFromFactoryBean，這三個方法十分重要，萬分重要！！！！！！！！因為前兩個方法記錄著bean的載入狀態，是檢測當前bean是否處於建立中的關鍵之處，對解決bean迴圈依賴起著關鍵的作用。

before方法用於標記當前bean處於建立中，

after則是移除。

其實文章一開始的getSingleton原始碼分析就已經提到了isSingletonCurrentlyInCreation()是用於檢測當前bean是否處於建立之中，

• 看原始碼(DefaultSingletonBeanRegistry.java)

public Boolean isSingletonCurrentlyInCreation(String beanName) {
	return this.singletonsCurrentlyInCreation.contains(beanName);
}

beforeSingletonCreation()

上述程式碼是根據變數singletonsCurrentlyInCreation集合中是否包含了beanName判斷，集合的元素則一定是在beforeSingletonCreation()中新增的，如下：

protected void beforeSingletonCreation(String beanName) {
	if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
		throw new BeanCurrentlyInCreationException(beanName);
	}
}

afterSingletonCreation

afterSingletonCreation()為移除，則一定就是對singletonsCurrentlyInCreation集合remove了，如下：

protected void afterSingletonCreation(String beanName) {
	if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
		throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
	}
}

接下來我們再來看看真正的核心方法 doGetObjectFromFactoryBean

• 看原始碼(FactoryBeanRegistrySupport.java)

private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {
	Object object;
	try {
		if (System.getSecurityManager() != null) {
			AccessControlContext acc = getAccessControlContext();
			try {
				object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
			}
			catch (PrivilegedActionException pae) {
				throw pae.getException();
			}
		} else {
			object = factory.getObject();
		}
	}
	catch (FactoryBeanNotInitializedException ex) {
		throw new BeanCurrentlyInCreationException(beanName, ex.toString());
	}
	catch (Throwable ex) {
		throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
	}
	// Do not accept a null value for a FactoryBean that's not fully
	// initialized yet: Many FactoryBeans just return null then.
	if (object == null) {
		if (isSingletonCurrentlyInCreation(beanName)) {
			throw new BeanCurrentlyInCreationException(
									beanName, "FactoryBean which is currently in creation returned null from getObject");
		}
		object = new NullBean();
	}
	return object;
}

• 原始碼分析

在文章開始我們有介紹FactoryBean的呼叫方法，如果bean宣告為FactoryBean型別，則當提取bean的是否提取的不是FactoryBean，而是FactoryBean中對應的getObject方法返回的bean，而doGetObjectRFromFactoryBean正是實現這一功能的。

呼叫完doGetObjectFromFactoryBean方法後，並沒有直接返回，getObjectFromFactoryBean方法中還呼叫了object = postProcessObjectFromFactoryBean(object, beanName);方法，在子類AbstractAutowireCapableBeanFactory有該方法的具體實現：

• 看原始碼(AbstractAutowireCapableBeanFactory.java)

@Override
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
	return applyBeanPostProcessorsAfterInitialization(object, beanName);
}

@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException {
	Object result = existingBean;
	for (BeanPostProcessor processor : getBeanPostProcessors()) {
		Object current = processor.postProcessAfterInitialization(result, beanName);
		if (current == null) {
			return result;
		}
		result = current;
	}
	return result;
}

對於後處理器的使用，目前還沒有講到，後面再重新開篇去說，這裡我們只需要瞭解在Spring獲取Bean的規則中有這樣一條，儘可能保證所有bean初始化後都會呼叫註冊的BeanPostProcessor的postProcessAfterInitialization方法進行處理，在實際開發中大可針對此特性設計自己的業務處理。

整理不易，如果對你有所幫助歡迎點贊關注

微信搜尋【碼上遇見你】獲取更多精彩內容