以XmlBeanFactory為例
多個重載的getBean方法
beans.factory.support.AbstractBeanFactory(XmlBeanFactory 繼承自這個類，擁有這個方法)
//---------------------------------------------------------------------
// Implementation of BeanFactory interface
//---------------------------------------------------------------------
// 提供了getBean的多個重載方法，都是調用doGetBean主方法來實現的
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
@Override
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
return doGetBean(name, requiredType, null, false);
}
@Override
public Object getBean(String name, Object... args) throws BeansException {
return doGetBean(name, null, args, false);
}
doGetBean主方法
@SuppressWarnings("unchecked")
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
final String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
// 1.
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 + "'");
}
}
// 2.
bean = 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.
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
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);
}
}
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
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);
getBean(dep);
}
}
// Create bean instance.
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
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;
}
}
});
bean = 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);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
String scopeName = mbd.getScope();
final 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, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
}
});
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.
if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
try {
return getTypeConverter().convertIfNecessary(bean, requiredType);
}
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;
}
XmlBeanFactory.doGetBean(...)的總流程
1- 轉換對應的beanName
傳入的name參數可能是別名，也可能是FactoryBean，所以還需要進行一系列的解析。
- 去除FactoryBean的修飾符，也就是如果name = "&aBeanName"，那么會首先去除&而使name = "aBeanName"
- 將別名alias轉換為最終指向的beanName，比如別名A執行名稱為B的bean，而B沒有指向任何其他的bean，即為最終的bean，則返回B；
但是如果B又指向C，而是C是最終的bean，則返回C
2- 嘗試從緩存中加載原始單例
3- 檢測是否為FactoryBean并獲取Bean以及初始化后處理
在doGetBean方法中頻繁出現getObjectForBeanInstance方法，它主要完成對獲取的Bean Instance進行檢測是否為FactoryBean，如果是FactoryBean則通過工廠方法獲取Bean以及初始化后處理。
Spring-IOC-FactoryBean檢測與獲取Bean
4- 創建單例Bean
如果緩存中沒有單例Bean的緩存，則需要從頭開始創建單例Bean，這主要是重載getSingleton的重載方法來實現單例Bean的加載。
Spring-IOC-SingletonBean的創建過程
4- 原型模式的依賴檢查
只有單例模式才會嘗試解決循環依賴，如果存在A中有B的屬性，B中有A的屬性，那么當依賴注入的時候看，就會產生當A還未創建完的時候因為對于B的創建再次返回創建A，造成循環依賴，也就是情況：isPrototypeCurrentlyInCreation(beanName)判斷為true
5- 檢測parentBeanFactory
如果緩存中沒有數據的話直接轉到父類工廠上去加載
parentBeanFactory != null && !containsBeanDefinition(beanName),parentBeanFactory != null
上面的判斷中containsBeanDefinition(beanName)是檢測如果當前加載XML配置文件中不包含beanName所對應的配置，就只能到parentBeanFactory去嘗試下，然后再遞歸的調用getBean方法
6- 將注冊的GenericBeanFactory轉換為RootBeanDefinition
因為從XML配置文件中讀取到的Bean信息是存儲在GernericBeanDefinition中的，但是所有的Bean后續處理都是針對于RootBeanDefinition的，所以這里需要進行一個轉換，轉換的同時如果父類bean不為空的話，則會一并合并父類的屬性
7- 屬性依賴注入
在bean的初始化過程會用到某些屬性，而某些屬性很可能是動態配置的，并且配置成依賴于其他的bean，那么這個時候就有必要先加載依賴的bean，所以在Spring的加載順序中，在初始化某一個bean的時候首先會初始化這個bean所對應的依賴。
8- 根據不同scope進行bean的創建
默認的scope為singleton，但是還有些其他的配置注入prototype、request等，Spring會根據不同的配置進行不同的初始化策略。
9- 類型轉換
到這里bean的獲取基本就已經結束了，通常對該方法的調用參數requiredType是為空的，但是可能會存在這樣的情況，返回bean其實是個String，但是requiredType卻傳入的Integer類型，此時本步驟就會起作用了，它的功能是將返回的bean轉換為requiredType所指定的類型，當然，String轉換為Integer是最簡單的一種轉換，在Spring中提供了各種各樣的轉換器，用戶也可以自己拓展轉換器來滿足開發需求。
