Spring之Bean的加载

对于加载bean的功能，在Spring中的调用方式（示例）为：

MyTestBean bean = (MyTestBean)bf.getBean("myTestBean");

源码如下：

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.
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 + "'");
}
}
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;
}

加载的过程大致如下：

转换对应的beanName。这里传入的参数除了beanName外，还可以是别名alias或者是FactoryBean，这些解析的内容如下：

去除FactoryBean的修饰符，也就是如果name="&aa",那么首先去除&，使得name="aa"

· 取指定alias所表示的最终的beanName，例如别名A指向名称为B的bean，返回B。

尝试从缓存中加载实例。单例在Spring的同一个容器中只会被创建一次，后续再获取bean，就可以直接从单例缓存中获取。主要方法是getSingleton(beanName),后续详述该方法。

bean的实例化。如果是从缓存中得到了bean的原始状态，则需要对bean进行实例化。（强调：从缓存中获取的记录只是bean的最原始的bean状态，并不一定是我们最终想要的bean。例子：假如我们需要对工厂bean进行处理，那么这里其实得到的是工厂bean的初始状态但是我们真正需要的是工厂中定义的factory-method方法中返回的bean）。后续详述主要实现方法：getObjectForBeanInstance()。

原型模式的依赖检查。只有在单例模式下才会去解决循环依赖，如果存在A中有B的属性，B中有A的属性，当依赖注入的时候，就会产生当A还没有创建完的时候因为对B的创建再次返回创建A，就造成了循环依赖。主要方法是isPrototypeCurrentlyInCreation(beanName)。

检测parentBeanFactory。如果parentBeanFactory不为空，并且检测如果当前加载的XML配置文件中不包含beanName所对应的位置，就递归调用getBean方法。

将存储XML配置文件的GenericBeanDefinition转换为RootBeanDefinition。因为后续处理都是针对RootBeanDefinition的，所里这里需要一个转换。主要方法：getMergedLocalBeanDefinition(beanName)。

寻找依赖。因为bean的初始化过程中很可能会用到动态配置的某些属性，且这些属性依赖于其他的bean，那么这个时候就有必要先加载依赖的bean。所以初始化一个bean的时候首先会初始化这个bean所对应的依赖。主要方法有registerDependentBean（dependsOnBea,beanName）。

针对不同的scope进行bean的创建。这些scope包含singleton、prototype、request等，默认是singleton。

类型转换。程序到这里返回bean后就基本结束了。

猜你喜欢