十六、开启Bean加载

开启Bean加载

Spring IOC容器的作用：它会以某种方式加载 Configuration Metadata，将其解析注册到容器内部，然后回根据这些信息绑定整个系统的对象，最终组装成一个可用的基于轻量级容器的应用系统。具体流程分为两个阶段：

1、容器初始化阶段

首先，通过某种方式加载 Configuration Metadata (主要是依据 Resource、ResourceLoader 两个体系) 。
然后，容器会对加载的 Configuration MetaData 进行解析，并将解析的信息组装成 BeanDefinition 。
最后，将 BeanDefinition 保存注册到相应的 BeanDefinitionRegistry 中。
至此，Spring IoC 的初始化工作完成。

2、加载Bean阶段

经过容器初始化阶段后，应用程序中定义的 bean 信息已经全部加载到系统中了，当我们显示或者隐式地调用 BeanFactory.getBean(...) 方法时，则会触发加载 Bean 阶段。
在这阶段，容器会首先检查所请求的对象是否已经初始化完成了，如果没有，则会根据注册的 Bean 信息实例化请求的对象，并为其注册依赖，然后将其返回给请求方。

`getBean()`方法

当我们显示或者隐式地调用 BeanFactory.getBean(...) 方法时，则会触发加载 Bean 阶段。

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

内部调用 doGetBean(String name, final Class requiredType, Object[] args, boolean typeCheckOnly) 方法。

`doGetBean()`方法

getBean()内部调用的是该方法，主要步骤总结在下方：

/**
* @param name 要获取 Bean 的名字
* @param requiredType 要获取 bean 的类型
* @param args 创建 Bean 时传递的参数。这个参数仅限于创建 Bean 时使用。
* @param typeCheckOnly 是否为类型检
* @return an instance of the bean
* @throws BeansException if the bean could not be created
*/
@SuppressWarnings("unchecked")
protected <T> T doGetBean(
    String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
    throws BeansException {
    /*
	* 通过 name 获取 beanName。这里不使用 name 直接作为 beanName 有两点原因：
	* 1. name 可能会以 & 字符开头，表明调用者想获取 FactoryBean 本身，而非 FactoryBean
	* 实现类所创建的 bean。在 BeanFactory 中，FactoryBean 的实现类和其他的 bean 存储
	* 方式是一致的，即 <beanName, bean>，beanName 中是没有 & 这个字符的。所以我们需要
	* 将 name 的首字符 & 移除，这样才能从缓存里取到 FactoryBean 实例。
	* 2. 若 name 是一个别名，则应将别名转换为具体的实例名，也就是 beanName。
	*/
    // ①获取beanName
    String beanName = transformedBeanName(name);
    Object beanInstance;

    // ②从缓存中或者实例工厂中获取 Bean 对象
    // Eagerly check singleton cache for manually registered singletons.
    Object sharedInstance = getSingleton(beanName);

    /*
	* 如果容器中包含对应的bean则直接返回
	* 如果 sharedInstance = null，则说明缓存里没有对应的实例，表明这个实例还没创建。
	* BeanFactory 并不会在一开始就将所有的单例 bean 实例化好，而是在调用 getBean 获取
	* bean 时再实例化，也就是懒加载。
	* getBean 方法有很多重载，比如 getBean(String name, Object... args)，我们在首次获取
	* 某个 bean 时，可以传入用于初始化 bean 的参数数组（args），BeanFactory 会根据这些参数
	* 去匹配合适的构造方法构造 bean 实例。当然，如果单例 bean 早已创建好，这里的 args 就没有
	* 用了，BeanFactory 不会多次实例化单例 bean。
	*/
    if (sharedInstance != null && args == null) {
        if (logger.isTraceEnabled()) {//日志
            if (isSingletonCurrentlyInCreation(beanName)) {
                logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
            }
            else {
                logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
            }
        }
        /*
		* 如果 sharedInstance 是普通的单例 bean，下面的方法会直接返回。但如果
		* sharedInstance 是 FactoryBean 类型的，则需调用 getObject 工厂方法获取真正的
		* bean 实例。如果用户想获取 FactoryBean 本身，这里也不会做特别的处理，直接返回
		* 即可。毕竟 FactoryBean 的实现类本身也是一种 bean，只不过具有一点特殊的功能而已。
		*/
        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
    /*
	* 如果上面的条件不满足，则表明 sharedInstance 可能为空，此时 beanName 对应的 bean
	* 实例可能还未创建。这里还存在另一种可能，如果当前容器有父容器，beanName 对应的 bean 实例
	* 可能是在父容器中被创建了，所以在创建���例前，需要先去父容器里检查一下。
	*/
    else {
        // Fail if we're already creating this bean instance:
        // We're assumably within a circular reference.
        // 检查bean是否正在创建， BeanFactory 不缓存 Prototype 类型的 bean，无法处理该类型 bean 的循环依赖问题
        // ③因为 Spring 只解决单例模式下得循环依赖，在原型模式下如果存在循环依赖则会抛出异常。
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        // Check if bean definition exists in this factory.
        // ④如果 sharedInstance = null，则到父容器中查找 bean 实例
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // Not found -> check parent.
            // 获取 name 对应的 beanName，如果 name 是以 & 字符开头，则返回 & + beanName
            String nameToLookup = originalBeanName(name);
            if (parentBeanFactory instanceof AbstractBeanFactory) {
                return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                    nameToLookup, requiredType, args, typeCheckOnly);
            }
            // 根据 args 是否为空，以决定调用父容器哪个方法获取 bean
            else if (args != null) {
                // Delegation to parent with explicit args.
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else if (requiredType != null) {
                // No args -> delegate to standard getBean method.
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
            else {
                return (T) parentBeanFactory.getBean(nameToLookup);
            }
        }
        //⑤标记当前bean正在创建中，alreadyCreated中
        if (!typeCheckOnly) {
            markBeanAsCreated(beanName);
        }

        StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
            .tag("beanName", name);
        try {
            if (requiredType != null) {
                beanCreation.tag("beanType", requiredType::toString);
            }
            // ⑥从容器中获取 beanName 相应的 GenericBeanDefinition 对象，并将其转换为 RootBeanDefinition 对象
            RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            //检查是否为抽象类
            checkMergedBeanDefinition(mbd, beanName, args);

            // Guarantee initialization of beans that the current bean depends on.
            // ⑦处理所依赖的 bean，先创建需要在当前bean创建之前必须创建的bean，通过@DependsOn("eventListener")注解设置该信息， 检查是否有 dependsOn 依赖，如果有则先初始化所依赖的 bean
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    /*
					* 检测是否存在 depends-on 循环依赖，若存在则抛异常。比如 A 依赖 B，
					* B 又依赖 A，他们的配置如下：
					*   <bean id="beanA" class="BeanA" depends-on="beanB">
					*   <bean id="beanB" class="BeanB" depends-on="beanA">
					* beanA 要求 beanB 在其之前被创建，但 beanB 又要求 beanA 先于它
					* 创建。这个时候形成了循环，对于 depends-on 循环，Spring 会直接
					* 抛出异常
					*/
                    if (isDependent(beanName, dep)) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                    }
                    // 缓存依赖调用，注册依赖记录
                    registerDependentBean(dep, beanName);
                    try {
                        // 加载 depends-on 依赖
                        getBean(dep);
                    }
                    catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                    }
                }
            }

            // Create bean instance.
            // ⑧创建 bean 实例
            if (mbd.isSingleton()) {// 单例模式
                /*jiu
				* 这里并没有直接调用 createBean 方法创建 bean 实例，而是通过
				* getSingleton(String, ObjectFactory) 方法获取 bean 实例。
				* getSingleton(String, ObjectFactory) 方法会在内部调用
				* ObjectFactory 的 getObject() 方法创建 bean，并会在创建完成后，
				* 将 bean 放入缓存中。
				*/
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        // 创建 bean 实例
                        return createBean(beanName, mbd, args);
                    }
                    catch (BeansException ex) {
                        // 显式从单例缓存中删除 Bean 实例
                        // 因为单例模式下为了解决循环依赖，可能他已经存在了，所以销毁它。
                        destroySingleton(beanName);
                        throw ex;
                    }
                });
                // 如果 bean 是 FactoryBean 类型，则调用工厂方法获取真正的 bean 实例。否则直接返回 bean 实例
                beanInstance = 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);
                }jiu
                finally {
                    afterPrototypeCreation(beanName);
                }
                beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }

            else {// 从指定的 scope 下创建 bean
                String scopeName = mbd.getScope();
                if (!StringUtils.hasLength(scopeName)) {
                    throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
                }
                Scope scope = this.scopes.get(scopeName);
                if (scope == null) {
                    throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                }jiu
                try {
                    Object scopedInstance = scope.get(beanName, () -> {
                        beforePrototypeCreation(beanName);
                        try {
                            return createBean(beanName, mbd, args);
                        }
                        finally {
                            afterPrototypeCreation(beanName);
                        }
                    });
                    beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                }
                catch (IllegalStateException ex) {
                    throw new ScopeNotActiveException(beanName, scopeName, ex);
                }
            }
        }
        catch (BeansException ex) {
            beanCreation.tag("exception", ex.getClass().toString());
            beanCreation.tag("message", String.valueOf(ex.getMessage()));
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
        finally {
            beanCreation.end();
        }
    }

    return adaptBeanInstance(name, beanInstance, requiredType);
}
jiu
@SuppressWarnings("unchecked")
<T> T adaptBeanInstance(String name, Object bean, @Nullable Class<?> requiredType) {
    // Check if required type matches the type of the actual bean instance.
    // ⑨检查需要的类型是否符合 bean 的实际类型，如果需要进行类型转换，则在此处进行转换。
    if (requiredType != null && !requiredType.isInstance(bean)) {
        try {
            Object convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
            if (convertedBean == null) {
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
            return (T) convertedBean;
        }
        catch (TypeMismatchException ex) {
            if (logger.isTraceEnabled()) {
                logger.trace("Failed to convert bean '" + name + "' to required type '" +
                             ClassUtils.getQualifiedName(requiredType) + "'", ex);
            }
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
    }
    return (T) bean;
}

doGetBean()的流程：

①、获取beanName

②、从缓存中或者实例工厂中获取 Bean 对象

③、原型模式依赖检查

④、从父类容器加载bean

⑤、标记当前bean为正在创建或者创建中

⑥、获取BeanDefinition

⑦、依赖bean处理

⑧、不同作用域的bean实例化

⑨、类型转换

获取beanName

1	`String beanName = transformedBeanName(name);`

该name，不一定是beanName，可能是aliasName，也有可能是FactoryBean。所以需要执行该方法对name进行转换。

1
2
3

protected String transformedBeanName(String name) {
    return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}

`BeanFactoryUtils.transformedBeanName(name)`

先调用BeanFactoryUtils.transformedBeanName(name)方法，去除FactoryBean的修饰符：

// BeanFactoryUtils.java

/**
 * 缓存 {@link #transformedBeanName(String)} 已经转换好的结果。
 */
private static final Map<String, String> transformedBeanNameCache = new ConcurrentHashMap<>();
/**
 * 去除 FactoryBean 的修饰符 &
 * 如果 name 以 “&” 为前缀，那么会去掉该 "&" 。
 * 例如，name = "&studentService" ，则会是 name = "studentService"。
 */
public static String transformedBeanName(String name) {
    Assert.notNull(name, "'name' must not be null");
    if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {//FACTORY_BEAN_PREFIX=&
        return name;
    }
    // computeIfAbsent 方法，分成两种情况：
    //      1. 未存在，则进行计算执行，并将结果添加到缓存、
    //      2. 已存在，则直接返回，无需计算。
    return transformedBeanNameCache.computeIfAbsent(name, beanName -> {
        do {
            beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
        } while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
        return beanName;
    });
}

tip：假设配置了一个 FactoryBean 的名字为 "abc" ，那么获取 FactoryBean 创建的 Bean 时，使用 "abc" ，如果获取 FactoryBean 本身，使用 "$abc" 。

transformedBeanNameCache 集合的存在，是为了缓存转换后的结果。下次再获取相同的 name 时，直接返回缓存中的结果即可。

`canonicalName(...)`

其次执行canonicalName(String name)：AbstractBeanFactory继承了FactoryBeanRegistrySupport，FactoryBeanRegistrySupport继承了DefaultSingletonBeanRegistry，DefaultSingletonBeanRegistry继承了SimpleAliasRegistry。

//SimpleAliasRegistry.java
public String canonicalName(String name) {
    String canonicalName = name;
    // Handle aliasing...
    String resolvedName;
    // 循环，从 aliasMap 中，获取到最终的 beanName
    // 例如，别名 A 指向名称为 B 的 bean 则返回 B，若 别名 A 指向别名 B，别名 B 指向名称为 C 的 bean，则返回 C。
    do {
        resolvedName = this.aliasMap.get(canonicalName);
        if (resolvedName != null) {
            canonicalName = resolvedName;
        }
    }
    while (resolvedName != null);
    return canonicalName;
}

从缓存中或者实例工厂中获取 Bean 对象

相应代码

Object sharedInstance = getSingleton(beanName);

/*
* 如果容器中包含对应的bean则直接返回
* 如果 sharedInstance = null，则说明缓存里没有对应的实例，表明这个实例还没创建。
* BeanFactory 并不会在一开始就将所有的单例 bean 实例化好，而是在调用 getBean 获取
* bean 时再实例化，也就是懒加载。
* getBean 方法有很多重载，比如 getBean(String name, Object... args)，我们在首次获取
* 某个 bean 时，可以传入用于初始化 bean 的参数数组（args），BeanFactory 会根据这些参数
* 去匹配合适的构造方法构造 bean 实例。当然，如果单例 bean 早已创建好，这里的 args 就没有
* 用了，BeanFactory 不会多次实例化单例 bean。
*/
if (sharedInstance != null && args == null) {
    if (logger.isTraceEnabled()) {//日志
        if (isSingletonCurrentlyInCreation(beanName)) {
            logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
        }
        else {
            logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
        }
    }
/*
* 如果 sharedInstance 是普通的单例 bean，下面的方法会直接返回。但如果
* sharedInstance 是 FactoryBean 类型的，则需调用 getObject 工厂方法获取真正的
* bean 实例。如果用户想获取 FactoryBean 本身，这里也不会做特别的处理，直接返回
* 即可。毕竟 FactoryBean 的实现类本身也是一种 bean，只不过具有一点特殊的功能而已。
*/
    beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}

单例模式的 Bean 在整个过程中只会被创建一次。第一次创建后会将该 Bean 加载到缓存中。后面，在获取 Bean 就会直接从单例缓存中获取。

如果从缓存中得到了 Bean 对象，则需要调用 getObjectForBeanInstance(Object beanInstance, String name, String beanName, RootBeanDefinition mbd) 方法，对 Bean 进行实例化处理。因为，缓存中记录的是最原始的 Bean 状态，我们得到的不一定是我们最终想要的 Bean 。

原型模式依赖检查

// AbstractBeanFactory.java
// 因为 Spring 只解决单例模式下得循环依赖，在原型模式下如果存在循环依赖则会抛出异常。
if (isPrototypeCurrentlyInCreation(beanName)) {
	throw new BeanCurrentlyInCreationException(beanName);
}

Spring 只处理单例模式下得循环依赖，对于原型模式的循环依赖直接抛出异常。主要原因还是在于，和 Spring 解决循环依赖的策略有关。

对于单例( Singleton )模式， Spring 在创建 Bean 的时候并不是等 Bean 完全创建完成后才会将 Bean 添加至缓存中，而是不等 Bean 创建完成就会将创建 Bean 的 ObjectFactory 提早加入到缓存中，这样一旦下一个 Bean 创建的时候需要依赖 bean 时则直接使用 ObjectFactroy 。
但是原型( Prototype )模式，我们知道是没法使用缓存的，所以 Spring 对原型模式的循环依赖处理策略则是不处理。

从父类容器加载bean

// AbstractBeanFactory.java

// 如果当前容器中没有找到，则从父类容器中加载
// Check if bean definition exists in this factory.
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
    // Not found -> check parent.
    String nameToLookup = originalBeanName(name);
    // 如果，父类容器为 AbstractBeanFactory ，直接递归查找
    if (parentBeanFactory instanceof AbstractBeanFactory) {
        return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                nameToLookup, requiredType, args, typeCheckOnly);
    // 用明确的 args 从 parentBeanFactory 中，获取 Bean 对象
    } else if (args != null) {
        // Delegation to parent with explicit args.
        return (T) parentBeanFactory.getBean(nameToLookup, args);
    // 用明确的 requiredType 从 parentBeanFactory 中，获取 Bean 对象
    } else if (requiredType != null) {
        // No args -> delegate to standard getBean method.
        return parentBeanFactory.getBean(nameToLookup, requiredType);
    // 直接使用 nameToLookup 从 parentBeanFactory 获取 Bean 对象
    } else {
        return (T) parentBeanFactory.getBean(nameToLookup);
    }
}

如果当前容器缓存中没有相对应的 BeanDefinition 对象，则会尝试从父类工厂（parentBeanFactory）中加载，然后再去递归调用 getBean(...) 方法。

标记当前bean为正在创建或者创建中

// AbstractBeanFactory.java

// 如果不是仅仅做类型检查则是创建bean，这里需要记录
if (!typeCheckOnly) {
	markBeanAsCreated(beanName);
}

获取BeanDefinition

// AbstractBeanFactory.java

// 从容器中获取 beanName 相应的 GenericBeanDefinition 对象，并将其转换为 RootBeanDefinition 对象
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 检查给定的合并的 BeanDefinition
checkMergedBeanDefinition(mbd, beanName, args);

因为从 XML 配置文件中读取到的 Bean 信息是存储在GenericBeanDefinition 中的。但是，所有的 Bean 后续处理都是针对于 RootBeanDefinition 的，所以这里需要进行一个转换。转换的同时，如果父类 bean 不为空的话，则会一并合并父类的属性。

依赖bean处理

// AbstractBeanFactory.java

// Guarantee initialization of beans that the current bean depends on.
// 处理所依赖的 bean
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
    for (String dep : dependsOn) {
        // 若给定的依赖 bean 已经注册为依赖给定的 bean
        // 即循环依赖的情况，抛出 BeanCreationException 异常
        if (isDependent(beanName, dep)) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
        }
        // 缓存依赖调用
        registerDependentBean(dep, beanName);
        try {
            // 递归处理依赖 Bean
            getBean(dep);
        } catch (NoSuchBeanDefinitionException ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
        }
    }
}

每个 Bean 都不是单独工作的，它会依赖其他 Bean，其他 Bean 也会依赖它。
对于依赖的 Bean ，它会优先加载，所以，在 Spring 的加载顺序中，在初始化某一个 Bean 的时候，首先会初始化这个 Bean 的依赖。

不同作用域的bean实例化

// AbstractBeanFactory.java

// bean 实例化
// Create bean instance.
if (mbd.isSingleton()) { // 单例模式
    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.
            // 显式从单例缓存中删除 Bean 实例
            // 因为单例模式下为了解决循环依赖，可能他已经存在了，所以销毁它。 TODO 芋艿
            destroySingleton(beanName);
            throw ex;
        }
    });
    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} else if (mbd.isPrototype()) { // 原型模式
    // It's a prototype -> create a new instance.
    Object prototypeInstance;
    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, () -> {
            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);
    }
}

Spring Bean 的作用域默认为 singleton 。当然，还有其他作用域，如 prototype、request、session 等。
不同的作用域会有不同的初始化策略。

类型转换

// AbstractBeanFactory.java

// 检查需要的类型是否符合 bean 的实际类型
// Check if required type matches the type of the actual bean instance.
if (requiredType != null && !requiredType.isInstance(bean)) {
    try {
        // 执行转换
        T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
        // 转换失败，抛出 BeanNotOfRequiredTypeException 异常
        if (convertedBean == null) {
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
        return convertedBean;
    } catch (TypeMismatchException ex) {
        if (logger.isTraceEnabled()) {
            logger.trace("Failed to convert bean '" + name + "' to required type '" +
                    ClassUtils.getQualifiedName(requiredType) + "'", ex);
        }
        throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
    }
}

在调用 #doGetBean(...) 方法时，有一个 requiredType 参数。该参数的功能就是将返回的 Bean 转换为 requiredType 类型。
当然就一般而言，我们是不需要进行类型转换的，也就是 requiredType 为空（比如 #getBean(String name) 方法）。但有，可能会存在这种情况，比如我们返回的 Bean 类型为 String ，我们在使用的时候需要将其转换为 Integer，那么这个时候 requiredType 就有用武之地了。当然我们一般是不需要这样做的。

总结

以上是对Spring Bean加载过程的概览，主要过程：

分析从缓存中获取单例 Bean ，以及对 Bean 的实例中获取对象。
如果从单例缓存中获取 Bean ，Spring 是怎么加载的呢？所以第二部分是分析 Bean 加载，以及 Bean 的依赖处理。
Bean 已经加载了，依赖也处理完毕了，第三部分则分析各个作用域的 Bean 初始化过程。

java > spring > IOC

#spring

十六、开启Bean加载

http://www.muzili.ren/2022/06/11/开启Bean加载/

作者

jievhaha

发布于

2022年6月11日

许可协议

宕机重启服务器docker中redis无法启动上一篇

十六、开启Bean加载

getBean()方法

doGetBean()方法

获取beanName

BeanFactoryUtils.transformedBeanName(name)

canonicalName(...)

从缓存中或者实例工厂中获取 Bean 对象

原型模式依赖检查

从父类容器加载bean

标记当前bean为正在创建或者创建中

获取BeanDefinition

依赖bean处理

不同作用域的bean实例化

类型转换

总结

`getBean()`方法

`doGetBean()`方法

`BeanFactoryUtils.transformedBeanName(name)`

`canonicalName(...)`