一、概要
通过前面几篇文章对IOC容器创建流程的详细分析，相信大家对IOC有了一个全新的认识，但是我们还不知道Spring如何获取Bean实例的，本篇文章，我们就关于获取 Bean 实例的过程做一个比较详细的分析。

二、getBean(String name)：获取指定名称的bean

org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String)方法主要用于从bean工厂中获取指定名称的bean实例，如果获取不到，将会执行实例化、属性填充、初始化等一系列过程。

首先来看看getBean(String name)方法的定义：

// org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String)
public Object getBean(String name) throws BeansException {
    // 真正获取bean的方法
    return doGetBean(name, null, null, false);
}

getBean()方法内部通过doGetBean()执行真正获取bean，大体过程如下：

第一步：转换bean的名称，包括去除FactoryBean引用前缀“&”，如果是别名就需要找到它最终指向的beanName；
第二步：尝试从缓存中获取对应的bean；
第三步：返回beanName对应的实例对象，内部包含对FactoryBean的处理；
第四步：如果在当前工厂中获取不到bean实例，则获取到父容器，如果不存在当前beanName对应的bean定义信息，则尝试从父容器获取对应的bean；
第五步：将指定的 bean 标记为已创建（或即将创建）；
第六步：返回bean定义信息；
第七步：获取到当前bean依赖的bean名称集合，保证当前bean依赖的bean的初始化；
第八步：尝试从缓存中获取对应的bean实例，获取不到的话，则执行singletonFactory的回调 -> createBean()创建bean实例，并添加到缓存中；
第九步：检查所需类型是否与实际 bean 实例的类型匹配；
第十步：返回上述创建好的bean实例对象；

doGetBean()方法源码如下：

protected  T doGetBean(String name, @Nullable Class requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
    // 1、第一步：转换bean的名称，包括去除FactoryBean引用前缀“&”；如果是别名就需要找到最终指向的beanName
    String beanName = transformedBeanName(name);
    Object bean;

    // 2、第二步：尝试从缓存中获取对应的bean（解决循环依赖的方法）
    Object sharedInstance = getSingleton(beanName);
    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 + "'");
            }
        }
        // 如果存在手动注册的单例
        // 3、第三步：返回beanName对应的实例对象，内部包含对FactoryBean的处理
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
    else {  // 如果不存在手动注册的单例
        // Fail if we're already creating this bean instance:
        // We're assumably within a circular reference.

        // Spring容器将每一个正在创建的bean标识符放在一个“当前创建bean池”中，bean在创建过程中将一直保持在这个池中，
        // 如果在创建bean过程中发现自己已经在“当前创建bean池”中，将抛出BeanCurrentlyInCreationException异常，表示发生了循环依赖。
        // bean创建完毕后，将会从“当前创建bean池”中移除掉
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        // Check if bean definition exists in this factory.

        // 4、第四步：获取到父容器，如果不存在当前beanName对应的bean定义信息，则尝试从父容器获取对应的bean
        // 获取父容器
        BeanFactory parentBeanFactory = getParentBeanFactory();
        // 如果存在父容器，并且在当前工厂中不存在当前beanName对应的Bean定义信息，则尝试从父容器中获取bean实例
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // Not found -> check parent.
            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 if (requiredType != null) {
                // No args -> delegate to standard getBean method.
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
            else {
                return (T) parentBeanFactory.getBean(nameToLookup);
            }
        }

        // 5、第五步：将指定的 bean 标记为已创建（或即将创建）
        if (!typeCheckOnly) {
            // 如果不是仅仅做类型检测，则将指定的 bean 标记为已创建（或即将创建）
            // private final Set alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256))
            // 也就是将beanName存入上述alreadyCreated集合中
            markBeanAsCreated(beanName);
        }

        try {
            // 6、第六步：返回bean定义信息
            RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            // 校验bean定义信息，如果是抽象的，则抛异常BeanIsAbstractException
            checkMergedBeanDefinition(mbd, beanName, args);

            // 7、第七步：获取到当前bean依赖的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 + "'");
                    }
                    // 如果BeanDefinition有依赖,就先把依赖关系注册到容器的dependentBeanMap缓存，再递归加载依赖的bean
                    registerDependentBean(dep, beanName);
                    try {
                        // 先实例化当前bean依赖的其他bean
                        getBean(dep);
                    } catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                                        "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                    }
                }
            }

            
            // 单例bean的创建
            if (mbd.isSingleton()) {  //单例作用域
                // 第二个参数是一个ObjectFactory，是一个函数式接口，当调用ObjectFactory的getObject()方法的时候，实际上调用的是createBean(beanName, mbd, args)
                // 也就是说在getSingleton()方法内部调用ObjectFactory的getObject()方法的时候，会回调到这里的createBean(beanName, mbd, args)创建bean，接着才会调用下面的getObjectForBeanInstance()方法

                // 8、第八步：尝试从缓存中获取对应的bean实例，获取不到的话，则执行singletonFactory的回调 -> createBean()创建bean
                sharedInstance = getSingleton(beanName, () -> {
                    try {

                        // 创建bean对象
                        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
                        destroySingleton(beanName);
                        throw ex;
                    }
                });
                // 返回beanName对应的实例对象
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }
            else if (mbd.isPrototype()) {  //多例bean的创建
                Object prototypeInstance = null;
                try {
                    // 多例bean创建前的操作：保存beanName到prototypesCurrentlyInCreation缓存中（为了防止循环依赖）
                    // private final ThreadLocal

Spring getBean()源码笔记

一、概要 通过前面几篇文章对IOC容器创建流程的详细分析，相信大家对IOC有了一个全新的认识，但是我们还不知道Spring如何获取Bean实例的，本篇文章，我们就关于获取 Bean 实例的过程做一个比较详细的分析。

Java相关栏目本月热门文章

一、概要
通过前面几篇文章对IOC容器创建流程的详细分析，相信大家对IOC有了一个全新的认识，但是我们还不知道Spring如何获取Bean实例的，本篇文章，我们就关于获取 Bean 实例的过程做一个比较详细的分析。