Spring源码之bean的加载(一)

从本节开始，我们将对bean的加载进行探索。对于其的探索，我们主要是围绕着这句话进行的：MyTestBean bean = (MyTestBean)bf.getBean(“myTestBean”)。相信大家对这句并不要陌生。那么Spring的代码是如何实现这个功能的呢？这里主要的类是AbstractBeanFactory，这个类包含了主要的调用方法，然后我们再进行展开来讲解。（相关资源可到这里下载：http://pan.baidu.com/s/1sjSo9a9）

@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}

其实当读者点开AbstractBeanFactory的源码，就可以看到多个的getBean()。我们是调用MyTestBeanbean = (MyTestBean)bf.getBean(“myTestBean”)这个的，所以我们只用上面那个getBean函数就行了，而这个函数又去调用doGetBean的函数，这时候我们跟踪代码，就可以看到主要方法的调用。

@SuppressWarnings("unchecked")
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {

//提取对应的beanName
final String beanName = transformedBeanName(name);
Object bean;

// Eagerly check singleton cache for manually registered singletons.

/**
* 检查缓存中或者实例工厂中是否有对应的实例
* 为什么首先会使用这段代码呢？
* 因为在创建单例bean的时候会存在依赖注入的情况，而在创建依赖的时候为了避免循环依赖，
* Spring创建bean的原则是不等bean创建完成就会创建bean的ObjectFactory提供曝光
* 也就是将Object加入到缓存中，一旦下个bean创建时候需要依赖上个bean则直接使用ObjectFactory
*/
//直接尝试从缓存获取或者singlestonFactories中的ObjetFactory中获取
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 + "'");
}
}
//返回对应的实例，有时候存在诸如BeanFactory的情况并不是直接返回实例本身，而是返回指定方法返回的实例
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}

else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
//只有在单例情况下才会尝试解决循环依赖，原型模式情况下，如果存在A中有B的属性，B中有A的属性，那么依赖注入
//的时候，就会产生当A还未创建完的时候因为
//对B的创建再次返回创建A，造成循环依赖，也就是下面的情况
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}

// Check if bean definition exists in this factory.
BeanFactory parentBeanFactory = getParentBeanFactory();
//如果beanDefinitionMap中也就是在所在已经加载的类中不包括beanName则尝试从parentBeanFactory中检测
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
//递归到BeanFactory中寻找
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 {
//将存储XML配置文件的GernericBeanDefinition转换为RootBeanDefinition，如果指定BeanName是子
//Bean的话同时会合并父类相关属性
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 dependsOnBean : dependsOn) {
if (isDependent(beanName, dependsOnBean)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");
}
//缓存依赖调用
registerDependentBean(dependsOnBean, beanName);
getBean(dependsOnBean);
}
}

// Create bean instance.
//实例化依赖的bean后便可以实例化mdb本身
//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 = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
//prototype模式的创建（new）
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}

else {
//指定scope上实例化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 {
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.
//检查需要的类型是否符合bean的实际类型
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;
}

上面的代码比较多。对于加载过程中涉及的步骤大致可以分为以下几步：

1) 转换对应beanName。这里beanName的获取有这几个要求。首先，如果beanName含有特殊的修饰符，那么就要转换掉，如“&owe”就要转换为“owen”;其次，获取最终的beanName，如A指向B，B指向C，那么最终应该得到C。

2) 尝试从缓存中加载单例。单例在Spring的同一个容器中只会被加载创建一次，后续再获取bean，就直接从单例缓存中获取。

3) bean的实例化。从缓存中得到的bean并不一定是我们相要的，那只是原始的bean状态，则需要对其进行实例化。

4) 原型模式的依赖检查。

5) 检测parentBeanFactory。加载有XMNL配置文件中不包含beanName所对应的配置，就只能到parentBeanFactory去尝试下了，然后再去递归的调用getBean方法。

6) 将存储XML配置文件的GernericBeanDefinition转换为RootBeanDefinition.

7) 寻找依赖。

8) 针对不同的scope进行bean的创建。在Spring中存在着不同的scope，其中默认提singleton，当然还有protope、request。

9) 类型转换。