版权声明：本文版权归作者所有，欢迎转载。转载时请在文章明显位置给出作者名字（潘威威）及原文链接。请勿将本文用于任何商业用途。 https://blog.csdn.net/panweiwei1994/article/details/79804807
本文已收录于【Spring源码札记专栏】。
关联文章：
(一)Spring IoC源码-2.bean的加载-01整体概览
(一)Spring IoC源码-2.bean的加载-02从缓存中获取单例bean
(一)Spring IoC源码-2.bean的加载-03从bean实例中获取对象
(一)Spring IoC源码-2.bean的加载-04创建bean
BeanFactory bf = new XmlBeanFactory(new ClassPathResource("MyBean.xml"));
MyBean myBean = (MyBean)bf.getBean("myBean");前面几篇文章都是在学习BeanFactory bf = new XmlBeanFactory(new ClassPathResource("MyBean.xml"))的实现原理，即IoC容器是如何初始化的。本文要学习的是MyBean myBean = (MyBean)bf.getBean("myBean");的实现原理，一般称其为bean的加载。
跟踪getBean(String)方法，找到AbstractBeanFactory.getBean(String)方法的源码。
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
@SuppressWarnings("unchecked")
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
//获取bean的真正名字（name参数可能是bean的别名）
final String beanName = transformedBeanName(name);
Object bean;
//在创建单例bean时会进行依赖注入，为了避免在依赖注入时发生循环依赖
//spring不等bean创建完成就将bean的ObjectFactory加入缓存中。
//如果下个bean创建时需要依赖此bean，则直接使用ObjectFactory。
// 尝试从缓存或者sigletonFactories中的ObjectFactory中加载单例bean。
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 + "'");
}
}
//处理sharedInstance，获取真正想要的bean。
//sharedInstance并不一定是我们最终想要的bean。举个例子，假如我们需要对工厂bean，即FactoryBean实例进行的处理，
//那么sharedInstance其实是工厂bean的初始状态，但我们真正想要的是工厂bean中定义的factory-method方法中返回的bean,
//而getObjectForBeanInstance方法就是完成这个工作的。
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
//原型模式的依赖检查
//prototype的Bean，Spring容器不进行缓存。
//如果是prototype的Bean处于正在创建的状态，直接抛出异常
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
//因为在缓存中没有加载到单例bean，所以检查ParentBeanFactory中是否包含了bean
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// 如果没有找到，递归查找
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else 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);
// 如果此bean依赖了其他的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);
}
}
// 创建bean
if (mbd.isSingleton()) {
//创建单例bean
sharedInstance = getSingleton(beanName, () -> {
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;
}
});
//处理sharedInstance，获取真正想要的bean。
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {//如果是原型模式
// 原型模式的创建
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
//处理sharedInstance，获取真正想要的bean。
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, () -> {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
});
//处理sharedInstance，获取真正想要的bean。
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;
}
}
// 如果requireType参数不为null，根据需要进行类型转换
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());
}
}
// For the nullability warning, see the elaboration in the comment above;
// in short: This is never going to be null unless user-declared code enforces null.
return (T) bean;
}将bean的加载步骤总结如下：
- 获取bean的真正名字（name可能是别名或者FactoryBean）。
- 尝试从缓存中加载单例bean。
- 如果从缓存中加载到了单例bean，从bean实例中获取对象并返回。从缓存中加载到的bean并不一定是我们最终想要的bean。举个例子，从缓存中加载到bean可能是工厂bean的初始状态，但我们真正想要的是工厂bean中定义的factory-method方法中返回的bean，所以需要处理从缓存中加载到bean。
- 原型模式的依赖检查。prototype的Bean，Spring容器不进行缓存。如果是prototype的Bean处于正在创建的状态，直接抛出异常。
- 递归加载依赖的bean。如果此bean依赖了其他的bean，则需要递归加载依赖的bean。
- 因为在缓存中没有加载到单例bean。
- 递归检查ParentBeanFactory中是否包含了想要的bean。
- 如果在ParentBeanFactory中也没有找到想要的bean，则创建bean。
- 如果是单例模式，创建单例bean。
- 如果是原型模式，创建原型bean。
- 如果既不是单例模式也不是原型模式，则根据scope创建bean。
- 从bean实例中获取对象
- 类型装换。如果requireType参数不为null，根据需要进行类型转换。
以上步骤会在下面的几篇文章中进行详细的介绍。