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;
}