前言
通過往期的文章我們已經瞭解了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;
}
- 原始碼分析
上述的處理過程大致可以分為兩步：
- 去除FactoryBean的修飾符，如果name以"&"為字首，那麼會去掉"&"，例如：name="&testService"，去除之後的結果是name=”testService“
- 取出指定的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方法進行處理，在實際開發中大可針對此特性設計自己的業務處理。
整理不易，如果對你有所幫助歡迎點贊關注
微信搜尋【碼上遇見你】獲取更多精彩內容