DefaultListableBeanFactory,是 GenericApplicationContext 和 AbstractRefreshableApplicationContext 的(bean工廠)默認策略,而這兩者是所有 xxxApplicationContext 的基類,因此 DefaultListableBeanFactory 可以說是 ApplicationContext 的標準配置,非常具有學習價值
- 值得一提的是,Spring 3.1 推薦的做法是採用 DefaultListableBeanFactory + XmlBeanDefinitionReader(不要將兩者捆綁起來),前者用於管理Bean工廠,而後者可讀取多種多樣的XML資源,具有高度可配置性,這種模式得到大量使用,例如:
- XmlWebApplicationContext 採用了 DefaultListableBeanFactory + XmlBeanDefinitionReader,後者專門用於讀取XML配置
- AnnotationConfigApplicationContext 採用了 DefaultListableBeanFactory + AnnotatedBeanDefinitionReader,後者專門用於讀取註解配置
繼承體系
1.查看getBean(String name)源碼
DefaultListableBeanFactory 的 getBean(String name) 方法是由其父類 AbstractBeanFactory 實現的,查看其源碼
@Override
public Object getBean(String name) throws BeansException {
//第二個參數:bean的類型
//第三個參數:僅用於實例創建過程所採用的參數
//第四個參數:貌似是一種優化措施
return doGetBean(name, null, null, false);
}
//......
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
//解析 bean name
final String beanName = transformedBeanName(name);
Object bean;
//快速檢查singleton實例的緩存
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
//判斷該singleton實例是否處於“正在創建”
if (isSingletonCurrentlyInCreation(beanName)) {
//是的話,說明這是“循環引用”現象,返回的是提前創建的未完全初始化的singleton實例
logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
//否的話,說明singleton實例已完成初始化並緩存
logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
//bean instance -> 返回它本身
//FactoryBean -> 創建一個Object,並返回
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
//判斷該prototype實例是否處於“正在創建”(在當前線程)
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
//獲取父Bean工廠(父容器)
BeanFactory parentBeanFactory = getParentBeanFactory();
//判斷bean definition是否存在
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
//不存在 -> 遞歸查找父Bean工廠(父容器)
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);
}
}
//標記該bean爲“已創建”,可用於後續的重複創建實例優化緩存效果
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
//如果目標是child bean definition,呢麼會遞歸融合parent bean definition的所有屬性
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//BeanDefinition校驗(比如Bean不能是Abstract)
checkMergedBeanDefinition(mbd, beanName, args);
//優先初始化當前Bean所依賴的其他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);
getBean(dep);
}
}
//獲取singleton實例,必要時創建一個新的並註冊(比如延遲加載的場景)
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 instance -> 返回它本身
//FactoryBean -> 創建一個Object,並返回
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//創建一個新的prototype實例
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 instance -> 返回它本身
//FactoryBean -> 創建一個Object,並返回
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
//其他作用域(request、session、ServletContext等等)
else {
//獲取Bean的作用域
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 {
//從目標作用域的底層存儲機制中獲取該實例,必要時創建一個新的
//----比如 request.getAttribute("")就是“request”作用域的底層存儲機制
//注:如果類似於singleton(長作用域)依賴一個request(短作用域)的場景,建議採用“Spring作用域代理”
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 instance -> 返回它本身
//FactoryBean -> 創建一個Object,並返回
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;
}
}
//類型檢查
if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
//如果類型不符,嘗試進行“類型轉換”
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;
}