Spring5原始碼解析9-doGetBean概述
接上回，AbstractApplicationContext#refresh呼叫AbstractApplicationContext#finishBeanFactoryInitialization來初始化所有的非懶載入單例 Bean。在該AbstractApplicationContext#finishBeanFactoryInitialization方法內部通過呼叫AbstractBeanFactory#doGetBean來獲取 Spring 容器所管理的 Bean。
AbstractBeanFactory#doGetBean
AbstractBeanFactory#doGetBean原始碼如下：
protected <T> T doGetBean(final String name,@Nullable final Class<T> requiredType,@Nullable final Object[] args,boolean typeCheckOnly) throws BeansException {
// 如果這個 name 是 FactoryBean 的beanName (&+beanName),就刪除&,返回beanName,傳入的name也可以是別名,也需要做轉換
// 注意 beanName 和 name 變數的區別,beanName是經過處理的,經過處理的beanName就直接對應singletonObjects中的key 主要流程都已經在上述的原始碼中增加了註釋，讀者可以自己查閱。其中，我覺得最主要是要明白以下幾點：
Object sharedInstance = getSingleton(beanName);
Object sharedInstance = getSingleton(beanName);這段程式碼是解決迴圈依賴的關鍵，先大概看一下，留個印象，具體的等後面有空講一下迴圈依賴吧。
public Object getSingleton(String beanName) {
return getSingleton(beanName,true);
}
//getSingleton(beanName,true);原始碼
@Nullable
protected Object getSingleton(String beanName,boolean allowEarlyReference) {
//singletonObjects 就是Spring內部用來存放單例Bean的物件池,key為beanName，value為Bean
Object singletonObject = this.singletonObjects.get(beanName);
// singletonsCurrentlyInCreation 存放了當前正在建立的bean的BeanName
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
// earlySingletonObjects 是早期單例Bean的快取池,此時Bean已經被建立(newInstance),但是還沒有完成初始化
// key為beanName，value為Bean
singletonObject = this.earlySingletonObjects.get(beanName);
//是否允許早期依賴
if (singletonObject == null && allowEarlyReference) {
//singletonFactories 單例工廠的快取,key為beanName,value 為ObjectFactory
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
//獲取早期Bean
singletonObject = singletonFactory.getObject();
//將早期Bean放到earlySingletonObjects中
this.earlySingletonObjects.put(beanName,singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
複製程式碼transformedBeanName 和 getObjectForBeanInstance 的作用
呼叫doGetBean方法時會傳入name變數，表明需要從容器中獲取那個 Bean。transformedBeanName除了在處理別名之外，這裡會有以下幾種情況：
第一種情況，直接往容器中註冊 Bean。
@Bean
public UserBean userBean() {
return new UserBean("shen",111);
}
複製程式碼在這種情況下，name變數如果為userBean，那麼就是要從容器中獲取UserBean物件。
呼叫transformedBeanName方法返回beanName物件的取值userBean。
然後根據beanName去容器中獲取相應的Bean，而獲取到的就是UserBean物件。
最後呼叫getObjectForBeanInstance方法，返回的還是UserBean物件。
第二種情況，通過FactoryBean往容器中註冊 Bean
@Bean
public FactoryBean userBean() {
return new FactoryBean<UserBean>() {
@Override
public UserBean getObject() throws Exception {
return new UserBean("shen",111);
}
@Override
public Class<?> getObjectType() {
return UserBean.class;
}
};
}
複製程式碼這裡又可以分為兩種情況：
第一種情況：
如果name變數如果為userBean，那麼也要從容器中獲取UserBean物件。
呼叫transformedBeanName方法返回beanName物件的取值為userBean。
然後根據beanName去容器中獲取相應的Bean，而獲取到的是FactoryBean物件。
最後呼叫getObjectForBeanInstance方法，發現是從容器中獲取UserBean物件，於是呼叫FactoryBean#getObject返回UserBean物件。
第二種情況：
name變數如果為&userBean，那麼就是要從容器中獲取FactoryBean物件本身。
呼叫transformedBeanName方法返回beanName物件的取值為userBean。
然後根據beanName去容器中獲取相應的Bean，而獲取到的是FactoryBean物件，
最後呼叫getObjectForBeanInstance方法，就是要獲取FactoryBean物件，於是方法返回FactoryBean物件。
@DependsOn
通過原始碼可以知道，Spring 在建立 Bean 之前，首先會建立當前 Bean 所有依賴的 Bean。
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName,dep)) {
throw new BeanCreationException(mbd.getResourceDescription(),"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
// 如果當前Bean依賴其他Bean,把被依賴Bean註冊給當前Bean
registerDependentBean(dep,beanName);
try {
// 先去建立所依賴的Bean
getBean(dep);
} catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(),ex);
}
}
}
複製程式碼那什麼是當前 Bean 所有依賴的 Bean 呢？也就是說，String[] dependsOn = mbd.getDependsOn();什麼情況下這個陣列中會有值呢？
在 Spring 中有這個一個註解：@DependsOn。這個註解一般用的很少(碰巧最近專案中用到了這個註解，哈哈哈)。來看一下 Spring 檔案中是怎麼描述的：
Beans on which the current bean depends. Any beans specified are guaranteed to be created by the container before this bean. Used infrequently in cases where a bean does not explicitly depend on another through properties or constructor arguments,but rather depends on the side effects of another bean's initialization. A depends-on declaration can specify both an initialization-time dependency and,in the case of singleton beans only,a corresponding destruction-time dependency. Dependent beans that define a depends-on relationship with a given bean are destroyed first,prior to the given bean itself being destroyed. Thus,a depends-on declaration can also control shutdown order.
機器翻譯：當前 bean 所依賴的 bean。任何指定的 bean 都保證在此 bean 之前由容器建立。當一個 bean 不是通過屬性或建構函式引數顯式依賴於另一個 bean，而是依賴於另一個 bean 初始化的副作用時，很少使用。依賴項宣告既可以指定初始化時間依賴項，也可以指定(在只有單例 bean 的情況下)對應的銷燬時間依賴項。在銷燬給定 bean 之前，首先銷燬定義與給定 bean 的依賴關係的依賴 bean。因此，依賴宣告也可以控制關機順序。
舉個例子
@Service
public class OrderService {
public OrderService() {
System.out.println("OrderService create");
}
@PreDestroy
public void destroy() {
System.out.println("OrderService destroy");
}
}
複製程式碼@DependsOn("orderService")
@Service
public class UserService {
public UserService() {
System.out.println("UserService create");
}
@PreDestroy
public void destroy() {
System.out.println("UserService destroy");
}
}
複製程式碼@Configuration
@ComponentScan
public class DependsOnMain {
public static void main(String[] args) {
AnnotationConfigApplicationContext context =
new AnnotationConfigApplicationContext(DependsOnMain.class);
context.close();
}
}
複製程式碼//執行結果
OrderService create
UserService create
UserService destroy
OrderService destroy
複製程式碼createBean(beanName,args);
在 Spring 中存在者多種 scope，Spring 會根據不用的 scope 選用不同的初始化方式。但是，不管怎麼樣，Spring 在底層建立 Bean 的時候都是通過呼叫AbstractAutowireCapableBeanFactory#createBean方法來建立物件的。
那 Spring 究竟是怎麼建立 Bean 的呢？AbstractAutowireCapableBeanFactory#createBean方法內部到底做了什麼事情呢？迴圈依賴該怎麼解決呢？
未完待續...
原始碼註釋 GITHUB 地址：github.com/shenjianeng…