本人本科毕业，21届毕业生，一年工作经验，简历专业技能如下，现根据简历，并根据所学知识复习准备面试。

记录日期：2022.1.4

大部分知识点只做大致介绍，具体内容根据推荐博文链接进行详细复习。

框架原理 - Spring（十三）之Spring IOC 源码finishBeanFactoryInitialization()

AbstractApplicationContext#finishBeanFactoryInitialization()

这里会负责初始化所有的 singleton beans。

在这个方法中，主要做了以下操作：

1. 将之前解析的 BeanDefinition 进一步处理，将有父 BeanDefinition 的进行合并，获得 MergedBeanDefinition
2. 尝试从缓存获取 bean 实例
3. 处理特殊的 bean —— FactoryBean 的创建
4. 创建 bean 实例
5. 循环引用的处理
6. bean 实例属性填充
7. bean 实例的初始化
8. BeanPostProcessor 的各种扩展应用

后面的叙述中，会使用初始化或预初始化来代表这个阶段。主要是 Spring 需要在这个阶段完成所有的 singleton beans 的实例化。

到此为止前， BeanFactory 已经创建完成，并且所有的实现了 BeanFactoryPostProcessor 接口的 Bean 都已经初始化并且其中的 postProcessBeanFactory(factory) 方法已经得到执行了。所有实现了 BeanPostProcessor 接口的 Bean 也都完成了初始化。

剩下的就是初始化其他还没被初始化的 singleton beans 了，我们知道它们是单例的，如果没有设置懒加载，那么 Spring 会在接下来初始化所有的 singleton beans。

// 初始化剩余的 singleton beans
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
   
    // 【翻译注释】为此上下文初始化转换服务
    // 判断是否有bdName为conversionService的beanName(实现ConversionService接口)，有的话注册为格式转换器服务类
    // 初始化的动作包装在 beanFactory.getBean(...) 中
    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
        beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
   
        beanFactory.setConversionService(
            beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    }

    /* 【注释翻译】 如果之前没有注册BeanFactoryPostProcessor（如PropertySourcesPlaceHolderConfigurerBean）， 请注册默认嵌入值解析程序：此时，主要用于注释属性值中的解析。 */
    if (!beanFactory.hasEmbeddedValueResolver()) {
   
        beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    }

    // 【注释翻译】尽早初始化LoadTimeWeaverAware bean，以便尽早注册其转换器
    // 先初始化 实现LoadTimeWeaverAware 接口的 Bean
    // 一般用于织入第三方模块，在 class 文件载入 JVM 的时候动态织入，这里不展开说
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
   
        getBean(weaverAwareName);
    }

    // 【注释翻译】停止使用临时类加载器进行类型匹配
    beanFactory.setTempClassLoader(null);

    // 【注释翻译】允许缓存所有bean定义元数据，不需要进一步更改
    // 没什么别的目的，因为到这一步的时候，Spring 已经开始预初始化 singleton beans 了，
    // 肯定不希望这个时候还出现 bean 定义解析、加载、注册。
    beanFactory.freezeConfiguration();

    // 【注释翻译】实例化所有剩余的（非惰性初始化）单例
    // 开始初始化剩下的
    beanFactory.preInstantiateSingletons();
}

ConversionService

代码块如下：

if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
    beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
   
    beanFactory.setConversionService(
        beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}

这里是结合spring MVC使用的，类似页面传递String类型的时间格式到后台可以格式化为Date类型。

容器初始化完成后，默认是没有格式转换器的。

Spring 内部有个DefaultConversionService，但是没有注册进容器，所以 Spring 找不到。
可以通过配置注入容器，然后 Spring 在这一步就会找到DefaultConversionService并注册到conversionService，如下：

@Bean
public ConversionService conversionService(){
   
    DefaultConversionService ConversionService = new DefaultConversionService();
    return ConversionService;
}

DefaultConversionService会注册很多spring自带的格式转换器，包括时间，集合等…

LoadTimeWeaverAware

代码块如下：

String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
   
    getBean(weaverAwareName);
}

这里会提前实例化LoadTimeWeaverAware类型的bean，this.getBean(bdName)方***进行实例化bean，后面具体分析。

beanFactory.preInstantiateSingletons()【重点】

DefaultListableBeanFactory.preInstantiateSingletons()方法实现如下：

public void preInstantiateSingletons() throws BeansException {
   
    if (logger.isTraceEnabled()) {
   
        logger.trace("Pre-instantiating singletons in " + this);
    }

    /* 【注释翻译】 迭代副本以允许init方法注册新的bean定义。 虽然这可能不是常规工厂引导的一部分，但它在其他方面工作正常。 */
    // this.beanDefinitionNames就是之前注册bean的时候添加的beanName集合
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

    // 【注释翻译】触发所有非惰性单例bean的初始化......
    // 触发所有的非懒加载的 singleton beans 的初始化操作
    for (String beanName : beanNames) {
   
        // 合并父 Bean 中的配置，注意 <bean id="" class="" parent="" /> 中的 parent，这个一般用的不多
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        // 非抽象、非懒加载的 singletons。(如果配置了 'abstract = true'，那是不需要初始化的)
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
   
            // 处理 FactoryBean
            if (isFactoryBean(beanName)) {
   
                // FACTORY_BEAN_PREFIX = "&"
                // FactoryBean 的话，在 beanName 前面加上 ‘&’ 符号。再调用 getBean
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                if (bean instanceof FactoryBean) {
   
                    FactoryBean<?> factory = (FactoryBean<?>) bean;
                    // 判断当前 FactoryBean 是否是 SmartFactoryBean 的实现
                    // 即 判断这个FactoryBean是否希望急切的初始化
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
   
                        isEagerInit = AccessController.doPrivileged(
                            (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
                            getAccessControlContext());
                    }
                    else {
   
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                       ((SmartFactoryBean<?>) factory).isEagerInit());
                    }
                    if (isEagerInit) {
   
                        // 如果希望急切的初始化，则通过beanName获取bean实例
                        getBean(beanName);
                    }
                }
            }
            else {
   
                // 对于普通的 Bean，只要调用 getBean(beanName) 这个方法就可以进行初始化了
                getBean(beanName);
            }
        }
    }

    // 【翻译注释】触发所有适用bean的初始化后回调......
    // 到这里说明所有的非懒加载的 singleton beans 已经完成了初始化
    // 如果我们定义的 bean 是实现了 SmartInitializingSingleton 接口的，那么在这里得到回调
    for (String beanName : beanNames) {
   
        // 拿到beanName对应的bean实例
        Object singletonInstance = getSingleton(beanName);
        // 判断singletonInstance是否实现了SmartInitializingSingleton接口
        if (singletonInstance instanceof SmartInitializingSingleton) {
   
            StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
                .tag("beanName", beanName);
            SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
            // 触发SmartInitializingSingleton实现类的afterSingletonsInstantiated方法
            if (System.getSecurityManager() != null) {
   
                AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
   
                    smartSingleton.afterSingletonsInstantiated();
                    return null;
                }, getAccessControlContext());
            }
            else {
   
                smartSingleton.afterSingletonsInstantiated();
            }
            smartInitialize.end();
        }
    }
}

getMergedLocalBeanDefinition(beanName)

获取 beanName 对应的 MergedBeanDefinition。

protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
   
    // 【翻译注释】首先快速检查并发映射，以最小化锁定。
    // 1. 检查beanName对应的MergedBeanDefinition是否存在于缓存中
    RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
    if (mbd != null && !mbd.stale) {
   
        // 2. 如果存在于缓存中则直接返回
        return mbd;
    }
    /* 3. 如果不存在于缓存中 3.1 getBeanDefinition(beanName): 获取beanName对应的BeanDefinition，从beanDefinitionMap缓存中获取 3.2 getMergedBeanDefinition(): 根据beanName和对应的BeanDefinition，获取MergedBeanDefinition */
    return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}

getMergedBeanDefinition()

根据 beanName 和 beanName 对应的 BeanDefinition，获取 MergedBeanDefinition。

protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
    throws BeanDefinitionStoreException {
   

    return getMergedBeanDefinition(beanName, bd, null);
}

protected RootBeanDefinition getMergedBeanDefinition(
    String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
    throws BeanDefinitionStoreException {
   
	
    // 1. 加锁再进行操作
    synchronized (this.mergedBeanDefinitions) {
   
        // 用于存储bd的MergedBeanDefinition，也就是该方法的结果
        RootBeanDefinition mbd = null;
        RootBeanDefinition previous = null;

        // Check with full lock now in order to enforce the same merged instance.
        if (containingBd == null) {
   
            // 2. 检查beanName对应的MergedBeanDefinition是否存在于缓存中，这里差不多是一个双重校验的意思
            mbd = this.mergedBeanDefinitions.get(beanName);
        }

        // 3. 如果beanName对应的MergedBeanDefinition不存在于缓存中
        if (mbd == null || mbd.stale) {
   
            previous = mbd;
            if (bd.getParentName() == null) {
   
                // Use copy of given root bean definition.
                /* 4. 如果bd的parentName为空，代表bean没有父定义，无需与父定义进行合并操作， 也就是bean的MergedBeanDefinition就是bean本身（可能需要转成RootBeanDefinition） */
                if (bd instanceof RootBeanDefinition) {
   
                    // 4.1 如果bd的类型为RootBeanDefinition，则bd的MergedBeanDefinition就是bd本身，则直接克隆一个副本
                    mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
                }
                else {
   
                    // 4.2 否则，将bd作为参数，构建一个RootBeanDefinition
                    // 正常使用下，BeanDefinition在被加载后是GenericBeanDefinition或ScannedGenericBeanDefinition
                    mbd = new RootBeanDefinition(bd);
                }
            }
            else {
   
                // Child bean definition: needs to be merged with parent.
                // 5. 否则，bd存在父定义，需要与父定义合并
                BeanDefinition pbd;
                try {
   
                    String parentBeanName = transformedBeanName(bd.getParentName());
                    // 5.1 如果父定义的beanName与该bean的beanName不同
                    if (!beanName.equals(parentBeanName)) {
   
                        // 5.2 获取父定义的MergedBeanDefinition（因为父定义也可能有父定义，也就是bd的爷爷定义...）
                        pbd = getMergedBeanDefinition(parentBeanName);
                    }
                    else {
   
                        // 5.4 如果父定义的beanName与bd的beanName相同，则拿到父BeanFactory
                        // 只有在存在父BeanFactory的情况下，才允许父定义beanName与自己相同，否则就是将自己设置为父定义
                        BeanFactory parent = getParentBeanFactory();
                        if (parent instanceof ConfigurableBeanFactory) {
   
                            // // 5.5 如果父BeanFactory是ConfigurableBeanFactory，则通过父BeanFactory获取父定义的MergedBeanDefinition
                            pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
                        }
                        else {
   
                            // 5.6 如果父BeanFactory不是ConfigurableBeanFactory，则抛异常
                            throw new NoSuchBeanDefinitionException(parentBeanName,
                                                                    "Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
                                                                    "': cannot be resolved without a ConfigurableBeanFactory parent");
                        }
                    }
                }
                catch (NoSuchBeanDefinitionException ex) {
   
                    throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
                                                           "Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
                }
                // Deep copy with overridden values.
                // 5.7 使用父定义pbd构建一个新的RootBeanDefinition对象（深拷贝）
                mbd = new RootBeanDefinition(pbd);
                // 5.8 使用bd覆盖父定义
                mbd.overrideFrom(bd);
            }

            // Set default singleton scope, if not configured before.
            // 6.如果没有配置scope，则设置成默认的singleton
            if (!StringUtils.hasLength(mbd.getScope())) {
   
                mbd.setScope(SCOPE_SINGLETON);
            }

            // A bean contained in a non-singleton bean cannot be a singleton itself.
            // Let's correct this on the fly here, since this might be the result of
            // parent-child merging for the outer bean, in which case the original inner bean
            // definition will not have inherited the merged outer bean's singleton status.
            // 7.如果containingBd不为空 && containingBd不为singleton && mbd为singleton，则将mdb的scope设置为containingBd的scope
            if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
   
                mbd.setScope(containingBd.getScope());
            }

            // Cache the merged bean definition for the time being
            // (it might still get re-merged later on in order to pick up metadata changes)
            // 8.将beanName与mbd放到mergedBeanDefinitions缓存，以便之后可以直接使用
            if (containingBd == null && isCacheBeanMetadata()) {
   
                this.mergedBeanDefinitions.put(beanName, mbd);
            }
        }
        if (previous != null) {
   
            copyRelevantMergedBeanDefinitionCaches(previous, mbd);
        }
        // 9.返回MergedBeanDefinition
        return mbd;
    }
}

其中transformedBeanName方法，主要是将 name 真正解析成真正的 beanName，主要是去掉 FactoryBean 里的 “&” 前缀，和解析别名。

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

public static String transformedBeanName(String name) {
   
    Assert.notNull(name, "'name' must not be null");
    // 如果beanName不带有 "&" 前缀，则直接返回
    if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
   
        return name;
    }
    // 如果beanName带有 "&" 前缀，则去掉
    return transformedBeanNameCache.computeIfAbsent(name, beanName -> {
   
        do {
   
            beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
        }
        while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
        return beanName;
    });
}

public String canonicalName(String name) {
   
    String canonicalName = name;
    // Handle aliasing...
    String resolvedName;
    do {
   
        // 将别名解析成真正的beanName
        resolvedName = this.aliasMap.get(canonicalName);
        if (resolvedName != null) {
   
            canonicalName = resolvedName;
        }
    }
    while (resolvedName != null);
    return canonicalName;
}

引入：FactoryBean

一般情况下，Spring 通过反射机制利用 bean 的 class 属性指定实现类来实例化 bean。而 FactoryBean 是一种特殊的 bean，它是个工厂 bean，可以自己创建 bean 实例，如果一个类实现了 FactoryBean 接口，则该类可以自己定义创建实例对象的方法，只需要实现它的 getObject() 方法。

注：很多中间件都利用 FactoryBean 来进行扩展。

举例说明：

public class AppleFactoryBean implements FactoryBean<Apple> {
   

    @Override
    public Apple getObject() throws Exception {
   
        Apple apple = new Apple();
        apple.setName("bigApple");
        return apple;
    }

    @Override
    public Class<?> getObjectType() {
   
        return Apple.class;
    }

    @Override
    public boolean isSingleton() {
   
        return true;
    }
}

为了区分 FactoryBean 和 FactoryBean 创建的 bean 实例，Spring 使用了 & 前缀。假设我们的 beanName 为 apple，则 getBean("apple") 获得的是 AppleFactoryBean 通过 getObject() 方法创建的 bean 实例；而 getBean("&apple") 获得的是 AppleFactoryBean 本身。

引入：父BeanFactory

我们能看到getMergedBeanDefinition(beanName)方法是用来获取父定义的MergedBeanDefinition。

@Override
public BeanDefinition getMergedBeanDefinition(String name) throws BeansException {
   
    String beanName = transformedBeanName(name);
    // Efficiently check whether bean definition exists in this factory.
    if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
   
        return ((ConfigurableBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(beanName);
    }
    // Resolve merged bean definition locally.
    return getMergedLocalBeanDefinition(beanName);
}

父BeanFactory，意思是在 Spring 中可能存在多个 BeanFactory，多个 BeanFactory 可能存在 “父工厂” 与 “子工厂” 的关系。最常见的例子就是：Spring MVC 的 BeanFactory 和 Spring 的 BeanFactory，通常情况下，Spring 的 BeanFactory 是 “父工厂”，Spring MVC 的 BeanFactory 是 “子工厂”，在 Spring 中，子工厂可以使用父工厂的 BeanDefinition，因而，如果在当前 BeanFactory 中找不到，而又存在父工厂，则会去父工厂中查找。

getBean()

接下来重点讲一下getBean()这个方法了。

这个方法我们经常用来从 BeanFactory 中获取一个 Bean，而初始化的过程也封装到了这个方法里。

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

而实际上是调用了doGetBean()方法，下面来重点看一下它的代码.

spring对于实际操作的方法都喜欢加一个do前缀。

dogetBean()【重点】

dogetBean()方法的实现如下：

// 我们在剖析初始化 Bean 的过程，但是 getBean 方法我们经常是用来从容器中获取 Bean 用的，注意切换思路，
// 已经初始化过了就从容器中直接返回，否则就先初始化再返回
@SuppressWarnings("unchecked")
protected <T> T doGetBean(
    String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
    throws BeansException {
   

    /* 1. 获取一个 “正统的” beanName， 处理两种情况： 一个是前面说的 FactoryBean(前面带 ‘&’)； 一个是别名问题，因为这个方法是 getBean，获取 Bean 用的，你要是传一个别名进来，是完全可以的。 */ 
    String beanName = transformedBeanName(name);
   // 注意跟着它，它就是最终返回值
    Object beanInstance;

    // 【翻译注释】急切地检查手动注册的单例缓存
    // 2. 检查下是不是已经创建过了，即尝试从缓存中获取beanName对应的实例
    Object sharedInstance = getSingleton(beanName);
    // 这里说下 args，虽然看上去一点不重要。前面我们一路进来的时候都是 getBean(beanName)，
   	// 所以 args 其实是 null 的，但是如果 args 不为空的时候，那么意味着调用方不是希望获取 Bean，而是创建 Bean
    if (sharedInstance != null && args == null) {
   
        // 3. 如果beanName的实例存在于缓存中
        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.1 返回beanName对应的实例对象 下面这个方法： 如果是普通 Bean 的话，直接返回 sharedInstance， 如果是 FactoryBean 的话，返回它创建的那个实例对象 */
        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }

    else {
   
        // 【翻译注释】如果我们已经在创建这个bean实例，则失败：我们应该在一个循环引用中
        /* 4. scope为prototype的循环依赖校验： 如果beanName已经正在创建Bean实例中， 而此时我们又要再一次创建beanName的实例，则代表出现了循环依赖，需要抛出异常。 例子：如果存在A中有B的属性，B中有A的属性，那么当依赖注入的时候， 就会产生当A还未创建完的时候因为对于B的创建再次返回创建A，造成循环依赖 */
        if (isPrototypeCurrentlyInCreation(beanName)) {
   
            // 当前线程已经创建过了此 beanName 的 prototype 类型的 bean，那么抛异常
            throw new BeanCurrentlyInCreationException(beanName);
        }

        // 【翻译注释】检查此工厂中是否存在bean定义
        // 5. 检查一下这个 BeanDefinition 在容器中是否存在
        BeanFactory parentBeanFactory = getParentBeanFactory();
        // 5.1 如果parentBeanFactory存在，并且beanName在当前BeanFactory不存在Bean定义，则尝试从parentBeanFactory中获取bean实例
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
   
            // 【翻译注释】未找到 -> 检查父项。
            // 5.2 将别名解析成真正的beanName
            String nameToLookup = originalBeanName(name);
            // 5.3 尝试在parentBeanFactory中获取bean对象实例
            if (parentBeanFactory instanceof AbstractBeanFactory) {
   
                return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                    nameToLookup, requiredType, args, typeCheckOnly);
            }
            else if (args != null) {
   
                // 【翻译注释】委托给具有显式参数的父级。
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else if (requiredType != null) {
   
                // 【翻译注释】无参数 -> 委托给标准getBean方法
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
            else {
   
                return (T) parentBeanFactory.getBean(nameToLookup);
            }
        }

        if (!typeCheckOnly) {
   
            // 做个记录，标识bd正在实例化
            // 6. 如果不是仅仅做类型检测，而是创建bean实例，这里要将beanName放到alreadyCreated缓存
            markBeanAsCreated(beanName);
        }

       /* 到这里的话，要准备创建 Bean 了，对于 singleton 的 Bean 来说，容器中还没创建过此 Bean； 对于 prototype 的 Bean 来说，本来就是要创建一个新的 Bean。 */
        StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
            .tag("beanName", name);
        try {
   
            if (requiredType != null) {
   
                beanCreation.tag("beanType", requiredType::toString);
            }
            // 根据beanName获取bean
            // 7. 根据beanName重新获取MergedBeanDefinition（步骤6将MergedBeanDefinition删除了，这边获取一个新的）
            RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            // 7.1 检查MergedBeanDefinition
            checkMergedBeanDefinition(mbd, beanName, args);

            // 【翻译注释】保证当前bean所依赖的bean的初始化
            // 先初始化依赖的所有 Bean，这个很好理解。但是注意，这里的依赖指的是 depends-on 中定义的依赖
            // @DependsOn注解控制bean的加载顺序
            // 8.拿到当前bean依赖的bean名称集合，在实例化自己之前，需要先实例化自己依赖的bean
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
   
                // 8.1 遍历当前bean依赖的bean名称集合
                for (String dep : dependsOn) {
   
                    // 8.2 检查dep是否依赖于beanName，即检查是否存在循环依赖
                    if (isDependent(beanName, dep)) {
   
                        // 8.3 如果是循环依赖则抛异常
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                                        "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                    }
                    // 8.4 将dep和beanName的依赖关系注册到缓存中
                    registerDependentBean(dep, beanName);
                    try {
   
                        // 8.5 获取dep对应的bean实例，如果dep还没有创建bean实例，则创建dep的bean实例
                        getBean(dep);
                    }
                    catch (NoSuchBeanDefinitionException ex) {
   
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                                        "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                    }
                }
            }

            // 【翻译注释】创建bean实例
            // 9.针对不同的scope进行bean的创建
            // 9.1 scope为singleton的bean创建（新建了一个ObjectFactory，并且重写了getObject方法）
            if (mbd.isSingleton()) {
   
                sharedInstance = getSingleton(beanName, () -> {
   
                    try {
   
                        // 9.1.1 创建Bean实例
                        return createBean(beanName, mbd, args);
                    }
                    catch (BeansException ex) {
   
                        /* 【翻译注释】 显式地从单例缓存中删除实例： 创建过程可能会急切地将实例放在那里，以允许循环引用解析。 还要删除接收到对bean的临时引用的任何bean */
                        destroySingleton(beanName);
                        throw ex;
                    }
                });
                // 9.1.2 返回beanName对应的实例对象
                beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }
			// 9.2 scope为prototype的bean创建
            else if (mbd.isPrototype()) {
   
                // 【翻译注释】这是一个原型 -> 创建一个新实例。
                Object prototypeInstance = null;
                try {
   
                    // 9.2.1 创建实例前的操作（将beanName保存到prototypesCurrentlyInCreation缓存中）
                    beforePrototypeCreation(beanName);
                    // 9.2.2 创建Bean实例
                    prototypeInstance = createBean(beanName, mbd, args);
                }
                finally {
   
                    // 9.2.3 创建实例后的操作（将创建完的beanName从prototypesCurrentlyInCreation缓存中移除）
                    afterPrototypeCreation(beanName);
                }
                // 9.2.4 返回beanName对应的实例对象
                beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }
        	// 9.3 其他scope的bean创建，可能是request之类的
            else {
   
                // 9.3.1 根据scopeName，从缓存拿到scope实例
                String scopeName = mbd.getScope();
                // 如果没有配置scope，则抛异常
                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 + "'");
                }
                try {
   
                    // 9.3.2 其他scope的bean创建（新建了一个ObjectFactory，并且重写了getObject方法）
                    Object scopedInstance = scope.get(beanName, () -> {
   
                        // 9.3.3 创建实例前的操作（将beanName保存到prototypesCurrentlyInCreation缓存中）
                        beforePrototypeCreation(beanName);
                        try {
   
                            // 9.3.4 创建bean实例
                            return createBean(beanName, mbd, args);
                        }
                        finally {
   
                            // 9.3.5 创建实例后的操作（将创建完的beanName从prototypesCurrentlyInCreation缓存中移除）
                            afterPrototypeCreation(beanName);
                        }
                    });
                    // 9.3.6 返回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()));
            // 如果创建bean实例过程中出现异常，则将beanName从alreadyCreated缓存中移除
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
        finally {
   
            beanCreation.end();
        }
    }
	   // 10. 最后，检查一下类型，不对的话就抛异常，对的话就返回
    return adaptBeanInstance(name, beanInstance, requiredType);
}

getObjectForBeanInstance()

在上述dogetBean()代码块 3.1 中。

返回beanName对应的实例对象。

• 如果是普通 Bean 的话，直接返回 sharedInstance。
• 如果是 FactoryBean 的话，返回它创建的那个实例对象。

protected Object getObjectForBeanInstance(
    Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
   

    // Don't let calling code try to dereference the factory if the bean isn't a factory.
    // 1.如果name以“&”为前缀
    // 这里说明要返回的是 FactoryBean
    if (BeanFactoryUtils.isFactoryDereference(name)) {
   
        // 1.1 如果是个空bean
        if (beanInstance instanceof NullBean) {
   
            return beanInstance;
        }
        // 1.2 如果beanInstance不是FactoryBean，则抛异常
        if (!(beanInstance instanceof FactoryBean)) {
   
            throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
        }
        if (mbd != null) {
   
            mbd.isFactoryBean = true;
        }
        return beanInstance;
    }

    // Now we have the bean instance, which may be a normal bean or a FactoryBean.
    // If it's a FactoryBean, we use it to create a bean instance, unless the
    // caller actually wants a reference to the factory.
    // 2. 如果beanInstance不是FactoryBean（也就是普通bean），则直接返回beanInstance
    if (!(beanInstance instanceof FactoryBean)) {
   
        return beanInstance;
    }

    // 3.走到这边，代表beanInstance是FactoryBean，但name不带有“&”前缀，表示想要获取的是FactoryBean创建的对象实例
    Object object = null;
    if (mbd != null) {
   
        mbd.isFactoryBean = true;
    }
    else {
   
        // 4.如果mbd为空，则尝试从factoryBeanObjectCache缓存中获取该FactoryBean创建的对象实例
        object = getCachedObjectForFactoryBean(beanName);
    }
    if (object == null) {
   
        // Return bean instance from factory.
        // 5.只有beanInstance是FactoryBean才能走到这边，因此直接强转
        FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
        // Caches object obtained from FactoryBean if it is a singleton.
        if (mbd == null && containsBeanDefinition(beanName)) {
   
            // 6.mbd为空，但是该bean的BeanDefinition在缓存中存在，则获取该bean的MergedBeanDefinitio
            mbd = getMergedLocalBeanDefinition(beanName);
        }
         7.mbd是否是合成的（这个字段比较复杂，mbd正常情况都不是合成的，也就是false，有兴趣的可以自己查阅资料看看）
        boolean synthetic = (mbd != null && mbd.isSynthetic());
        // 8.从FactoryBean获取对象实例
        object = getObjectFromFactoryBean(factory, beanName, !synthetic);
    }
    // 9.返回对象实例
    return object;
}

getObjectFromFactoryBean()

在上述getObjectForBeanInstance()代码块 8 中。

从 FactoryBean 获取对象实例。

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
   
    // 1.如果是单例，并且已经存在于单例对象缓存中
    if (factory.isSingleton() && containsSingleton(beanName)) {
   
        synchronized (getSingletonMutex()) {
   
            // 2.从FactoryBean创建的单例对象的缓存中获取该bean实例
            Object object = this.factoryBeanObjectCache.get(beanName);
            if (object == null) {
   
                // 3.调用FactoryBean的getObject方法获取对象实例
                object = doGetObjectFromFactoryBean(factory, beanName);
                // Only post-process and store if not put there already during getObject() call above
                // (e.g. because of circular reference processing triggered by custom getBean calls)
                Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
                // 4.如果该beanName已经在缓存中存在，则将object替换成缓存中的
                if (alreadyThere != null) {
   
                    object = alreadyThere;
                }
                else {
   
                    // 5. 如果需要执行这个bean的后置处理
                    if (shouldPostProcess) {
   
                        // 暂时返回未经处理的单例bean
                        if (isSingletonCurrentlyInCreation(beanName)) {
   
                            // Temporarily return non-post-processed object, not storing it yet..
                            return object;
                        }
                        // 5.1 检测是否是正在创建的单例bean，添加到singletonsCurrentlyInCreation中
                        beforeSingletonCreation(beanName);
                        try {
   
                            // 5.2 对bean实例进行后置处理，执行所有已注册的BeanPostProcessor的postProcessAfterInitialization方法
                            // 默认实现只是按原样返回给定对象，子类可以重写该方法
                            object = postProcessObjectFromFactoryBean(object, beanName);
                        }
                        catch (Throwable ex) {
   
                            throw new BeanCreationException(beanName,
                                                            "Post-processing of FactoryBean's singleton object failed", ex);
                        }
                        finally {
   
                            // 5.3 检测是否是正在创建的单例bean，，从singletonsCurrentlyInCreation移除
                            afterSingletonCreation(beanName);
                        }
                    }
                    // 6. 将beanName和object放到factoryBeanObjectCache缓存中
                    if (containsSingleton(beanName)) {
   
                        this.factoryBeanObjectCache.put(beanName, object);
                    }
                }
            }
            // 7.返回object对象实例
            return object;
        }
    }
    else {
   
        // 8.调用FactoryBean的getObject方法获取对象实例
        Object object = doGetObjectFromFactoryBean(factory, beanName);
        if (shouldPostProcess) {
   
            try {
   
                // 9.对bean实例进行后置处理，执行所有已注册的BeanPostProcessor的postProcessAfterInitialization方法
                object = postProcessObjectFromFactoryBean(object, beanName);
            }
            catch (Throwable ex) {
   
                throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
            }
        }
        // 10.返回object对象实例
        return object;
    }
}

doGetObjectFromFactoryBean()

在上述getObjectFromFactoryBean()代码块 3 、8中。

调用 FactoryBean 的getObject 方法获取对象实例。

private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {
   
    Object object;
    try {
   
        // 1.调用FactoryBean的getObject方法获取bean对象实例
        if (System.getSecurityManager() != null) {
   
            AccessControlContext acc = getAccessControlContext();
            try {
   
                // 1.1 带有权限验证的
                object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
            }
            catch (PrivilegedActionException pae) {
   
                throw pae.getException();
            }
        }
        else {
   
            // 1.2 不带有权限验证的
            object = factory.getObject();
        }
    }
    catch (FactoryBeanNotInitializedException ex) {
   
        throw new BeanCurrentlyInCreationException(beanName, ex.toString());
    }
    catch (Throwable ex) {
   
        throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
    }

    // Do not accept a null value for a FactoryBean that's not fully
    // initialized yet: Many FactoryBeans just return null then.
    // 2. getObject返回的是空值，并且该FactoryBean正在初始化中，则直接抛异常，不接受一个尚未完全初始化的FactoryBean的getObject返回的空值
    if (object == null) {
   
        if (isSingletonCurrentlyInCreation(beanName)) {
   
            throw new BeanCurrentlyInCreationException(
                beanName, "FactoryBean which is currently in creation returned null from getObject");
        }
        object = new NullBean();
    }
    // 3. 返回创建好的bean对象实例
    return object;
}

很简单的方法，就是直接调用 FactoryBean 的 getObject 方法来获取到对象实例。

postProcessObjectFromFactoryBean()

在上述getObjectFromFactoryBean()代码块 5.2 、9中。

/** * Post-process the given object that has been obtained from the FactoryBean. * The resulting object will get exposed for bean references. * <p>The default implementation simply returns the given object as-is. * Subclasses may override this, for example, to apply post-processors. * @param object the object obtained from the FactoryBean. * @param beanName the name of the bean * @return the object to expose * @throws org.springframework.beans.BeansException if any post-processing failed */
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) throws BeansException {
   
    return object;
}

默认是空实现的处理方法，但是空方法有什么好看的呢，当然看他的实现类啦。

这边走的是 AbstractAutowireCapableBeanFactory 里的方法。通过前面的介绍，我们知道创建的 BeanFactory 为 DefaultListableBeanFactory，而 DefaultListableBeanFactory 继承了 AbstractAutowireCapableBeanFactory，因此这边会走 AbstractAutowireCapableBeanFactory 的重写方法。

@Override
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
   
    return applyBeanPostProcessorsAfterInitialization(object, beanName);
}

@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
    throws BeansException {
   

    Object result = existingBean;
    // 1.遍历所有注册的BeanPostProcessor实现类，调用postProcessAfterInitialization方法
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
   
        // 2.在bean初始化后，调用postProcessAfterInitialization方法
        Object current = processor.postProcessAfterInitialization(result, beanName);
        if (current == null) {
   
            // 3.如果返回null，则不会调用后续的BeanPostProcessors
            return result;
        }
        result = current;
    }
    return result;
}

markBeanAsCreated()

让我们回看dogetBean()代码块的 6 中。

这边会将 beanName 对应的 MergedBeanDefinition 移除，然后在之后的代码重新获取，主要是为了使用最新的 MergedBeanDefinition 来进行创建操作。

protected void markBeanAsCreated(String beanName) {
   
    if (!this.alreadyCreated.contains(beanName)) {
   
        synchronized (this.mergedBeanDefinitions) {
    // 双重校验
            // 1.如果alreadyCreated缓存中不包含beanName
            if (!this.alreadyCreated.contains(beanName)) {
   
                // Let the bean definition get re-merged now that we're actually creating
                // the bean... just in case some of its metadata changed in the meantime.
                // 2.将beanName的MergedBeanDefinition从mergedBeanDefinitions缓存中移除，
                // 在之后重新获取MergedBeanDefinition，避免BeanDefinition在创建过程中发生变化
                clearMergedBeanDefinition(beanName);
                // 3.将beanName添加到alreadyCreated缓存中，代表该beanName的bean实例已经创建（或即将创建）
                this.alreadyCreated.add(beanName);
            }
        }
    }
}

isDependent()

让我们回看dogetBean()代码块的 8.2 中。

这边引入了一个缓存 dependentBeanMap：beanName -> 所有依赖 beanName 对应的 bean 的 beanName 集合。内容比较简单，就是检查依赖 beanName 的集合中是否包含 dependentBeanName，隔层依赖也算。例如：A 依赖了 B，B 依赖了 C，则 A 也算依赖了 C。

protected boolean isDependent(String beanName, String dependentBeanName) {
   
    synchronized (this.dependentBeanMap) {
   
        return isDependent(beanName, dependentBeanName, null);
    }
}

private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) {
   
	// 已经检查过的直接跳过 
    if (alreadySeen != null && alreadySeen.contains(beanName)) {
   
        return false;
    }
    // 1. 将别名解析为真正的名称
    String canonicalName = canonicalName(beanName);
    // 2. 拿到依赖canonicalName的beanName集合
    Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
    // 3. 如果dependentBeans为空，则两者必然还未确定依赖关系，返回false
    if (dependentBeans == null) {
   
        return false;
    }
    // 4. 如果dependentBeans包含dependentBeanName，则表示两者已确定依赖关系，返回true
    if (dependentBeans.contains(dependentBeanName)) {
   
        return true;
    }
    // 5. 循环检查，即检查依赖canonicalName的所有beanName是否存在被dependentBeanName依赖的（即隔层依赖）
    for (String transitiveDependency : dependentBeans) {
   
        if (alreadySeen == null) {
   
            alreadySeen = new HashSet<>();
        }
        // 6.已经检查过的添加到alreadySeen，避免重复检查
        alreadySeen.add(beanName);
        if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
   
            return true;
        }
    }
    return false;
}

registerDependentBean()

让我们回看dogetBean()代码块的 8.4 中。

将``dep和beanName` 的依赖关系注册到缓存中。

这边又引入了一个跟 dependentBeanMap 类似的缓存，dependenciesForBeanMap：beanName -> beanName 对应的 bean 依赖的所有 bean 的 beanName 集合。

这两个缓存很容易搞混，举个简单例子：例如 B 依赖了 A，则 dependentBeanMap 缓存中应该存放一对映射：其中 key 为 A，value 为含有 B 的 Set；而 dependenciesForBeanMap 缓存中也应该存放一对映射：其中 key 为：B，value 为含有 A 的 Set。

public void registerDependentBean(String beanName, String dependentBeanName) {
   
    // 1. 解析别名
    String canonicalName = canonicalName(beanName);

    synchronized (this.dependentBeanMap) {
   
        // 2. 拿到依赖canonicalName的beanName集合，如果不存在则创建集合
        Set<String> dependentBeans =
            this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
        // 3. 如果dependentBeans包含dependentBeanName，则表示依赖关系已经存在，直接返回
        // 如果不包含，则添加成功
        if (!dependentBeans.add(dependentBeanName)) {
   
            return;
        }
    }
	// 同上，在dependenciesForBeanMap中也注册一遍
    synchronized (this.dependenciesForBeanMap) {
   
        Set<String> dependenciesForBean =
            this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
        dependenciesForBean.add(canonicalName);
    }
}

getSingleton()

让我们回看dogetBean()代码块的 9.1 中。

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
   
    Assert.notNull(beanName, "Bean name must not be null");
    // 1. 加锁，避免重复创建单例对象
    synchronized (this.singletonObjects) {
   
        // 2. 首先检查beanName对应的bean实例是否在缓存中存在，如果已经存在，则直接返回
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
   
            // 3. beanName对应的bean实例不存在于缓存中，则进行Bean的创建
            if (this.singletonsCurrentlyInDestruction) {
   
                // 4.当bean工厂的单例处于destruction状态时，不允许进行单例bean创建，抛出异常
                throw new BeanCreationNotAllowedException(beanName,
                                                          "Singleton bean creation not allowed while singletons of this factory are in destruction " +
                                                          "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
            }
            if (logger.isDebugEnabled()) {
   
                logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
            }
            // 5.创建单例前的操作
            beforeSingletonCreation(beanName);
            boolean newSingleton = false;
            // suppressedExceptions用于记录异常相关信息
            boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
            if (recordSuppressedExceptions) {
   
                this.suppressedExceptions = new LinkedHashSet<>();
            }
            try {
   
                // 6.执行singletonFactory的getObject方法获取bean实例
                singletonObject = singletonFactory.getObject();
                // 标记为新的单例对象
                newSingleton = true;
            }
            catch (IllegalStateException ex) {
   
                // Has the singleton object implicitly appeared in the meantime ->
                // if yes, proceed with it since the exception indicates that state.
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
   
                    throw ex;
                }
            }
            catch (BeanCreationException ex) {
   
                if (recordSuppressedExceptions) {
   
                    for (Exception suppressedException : this.suppressedExceptions) {
   
                        ex.addRelatedCause(suppressedException);
                    }
                }
                throw ex;
            }
            finally {
   
                if (recordSuppressedExceptions) {
   
                    this.suppressedExceptions = null;
                }
                // 7.创建单例后的操作
                afterSingletonCreation(beanName);
            }
            if (newSingleton) {
   
                // 8.如果是新的单例对象，将beanName和对应的bean实例添加到缓存中（singletonObjects、registeredSingletons）
                addSingleton(beanName, singletonObject);
            }
        }
        // 9.返回创建出来的单例对象
        return singletonObject;
    }
}

其中beforeSingletonCreation和afterSingletonCreation也是一个前后置操作，是相互对应的，简单看一下它们两者的实现：

inCreationCheckExclusions 是要在创建检查排除掉的 beanName 集合，正常为空，可以不管。这边主要是引入了 singletonsCurrentlyInCreation 缓存：当前正在创建的 bean 的 beanName 集合。在 beforeSingletonCreation 方法中，通过添加 beanName 到该缓存，可以预防出现构造器循环依赖的情况。

protected void beforeSingletonCreation(String beanName) {
   
    // 先校验beanName是否为要在创建检查排除掉的（inCreationCheckExclusions缓存），如果不是，
    // 则将beanName加入到正在创建bean的缓存中（Set），如果beanName已经存在于该缓存，会返回false抛出异常（这种情况出现在构造器的循环依赖）
    if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
   
        throw new BeanCurrentlyInCreationException(beanName);
    }
}
 
protected void afterSingletonCreation(String beanName) {
   
    // 先校验beanName是否为要在创建检查排除掉的（inCreationCheckExclusions缓存），如果不是，
    // 则将beanName从正在创建bean的缓存中（Set）移除，如果beanName不存在于该缓存，会返回false抛出异常
    if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
   
        throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
    }
}

getSingleton 方法是解决循环引用的核心代码。解决逻辑的第一句话：“我们先用构造函数创建一个 “不完整” 的 bean 实例”，从这句话可以看出，构造器循环依赖是无法解决的，因为当构造器出现循环依赖，我们连 “不完整” 的 bean 实例都构建不出来。Spring 能解决的循环依赖有：通过 setter 注入的循环依赖、通过属性注入的循环依赖。

addSingleton()

让我们来看getSingleton()代码块的 8 中。

如果是新的单例对象，将beanName和对应的bean实例添加到缓存中。

protected void addSingleton(String beanName, Object singletonObject) {
   
    synchronized (this.singletonObjects) {
   
        // 1.添加到单例对象缓存
        this.singletonObjects.put(beanName, singletonObject);
        // 2.将单例工厂缓存移除（已经不需要）
        this.singletonFactories.remove(beanName);
        // 3.将早期单例对象缓存移除（已经不需要）
        this.earlySingletonObjects.remove(beanName);
        // 4.添加到已经注册的单例对象缓存
        this.registeredSingletons.add(beanName);
    }
}

beforePrototypeCreation() 和 afterPrototypeCreation()

让我们来看dogetBean()代码块的 9.2.1和 9.3.1 中。

该方法和getSingleton()中的两个方法类似。主要是在进行 bean 实例的创建前，将 beanName 添加到 prototypesCurrentlyInCreation 缓存；bean 实例创建后，将 beanName 从 prototypesCurrentlyInCreation 缓存中移除。这边 prototypesCurrentlyInCreation 存放的类型为 Object，在只有一个 beanName 的时候，直接存该 beanName，也就是 String 类型；当有多个 beanName时，转成 Set 来存放。

private final ThreadLocal<Object> prototypesCurrentlyInCreation =
			new NamedThreadLocal<>("Prototype beans currently in creation");

@SuppressWarnings("unchecked")
protected void beforePrototypeCreation(String beanName) {
   
    // 1. 拿到当前线程中正在创建的prototype的bean的beanName集合
    Object curVal = this.prototypesCurrentlyInCreation.get();
    // 2. 如果为空，则将ThreadLocal设置成当前的beanName
    if (curVal == null) {
   
        this.prototypesCurrentlyInCreation.set(beanName);
    }
    // 3. 如果不为空，并且是String类型，则代表目前只有一个beanName，将之前和当前的一起封装成Set<String>，设置到ThreadLocal中
    else if (curVal instanceof String) {
   
        Set<String> beanNameSet = new HashSet<>(2);
        beanNameSet.add((String) curVal);
        beanNameSet.add(beanName);
        this.prototypesCurrentlyInCreation.set(beanNameSet);
    }
    // 4. 如果不为空，并且不是String，则必然是Set<String>类型，将当前的beanName加到Set中去
    else {
   
        Set<String> beanNameSet = (Set<String>) curVal;
        beanNameSet.add(beanName);
    }
}

@SuppressWarnings("unchecked")
protected void afterPrototypeCreation(String beanName) {
   
    // 1. 拿到当前线程中正在创建的prototype的bean的beanName集合
    Object curVal = this.prototypesCurrentlyInCreation.get();
    // 2. 如果是String类型，则代表目前只有一个beanName，则直接移除
    if (curVal instanceof String) {
   
        this.prototypesCurrentlyInCreation.remove();
    }
    // 3. 如果是Set类型，则从Set从移除beanName
    else if (curVal instanceof Set) {
   
        Set<String> beanNameSet = (Set<String>) curVal;
        beanNameSet.remove(beanName);
        if (beanNameSet.isEmpty()) {
   
            this.prototypesCurrentlyInCreation.remove();
        }
    }
}

createBean()【重点】

AbstractBeanFactory#createBean()是一个抽象模板方法。

protected abstract Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    throws BeanCreationException;

具体实现是由AbstractAutowireCapableBeanFactory#createBean()来完成的：

@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    throws BeanCreationException {
   

    if (logger.isTraceEnabled()) {
   
        logger.trace("Creating instance of bean '" + beanName + "'");
    }
    RootBeanDefinition mbdToUse = mbd;

    // Make sure bean class is actually resolved at this point, and
    // clone the bean definition in case of a dynamically resolved Class
    // which cannot be stored in the shared merged bean definition.
    // 1. 解析beanName对应的Bean的类型，例如：com.test.service.impl.UserServiceImpl
    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
   
        /* 如果resolvedClass存在，并且mdb的beanClass类型不是Class， 并且mdb的beanClass不为空（则代表beanClass存的是Class的name）, 则使用mdb深拷贝一个新的RootBeanDefinition副本， 并且将解析的Class赋值给拷贝的RootBeanDefinition副本的beanClass属性， 该拷贝副本取代mdb用于后续的操作。 */
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }

    // Prepare method overrides.
    try {
   
        // 2.验证及准备覆盖的方法（对override属性进行标记及验证）
        mbdToUse.prepareMethodOverrides();
    }
    catch (BeanDefinitionValidationException ex) {
   
        throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                                               beanName, "Validation of method overrides failed", ex);
    }

    try {
   
        // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
        // 3.实例化前的处理，给InstantiationAwareBeanPostProcessor一个机会返回代理对象来替代真正的bean实例，达到“短路”效果
        Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
        // 4.如果bean不为空，则会跳过Spring默认的实例化过程，直接使用返回的bean
        if (bean != null) {
   
            return bean;
        }
    }
    catch (Throwable ex) {
   
        throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                                        "BeanPostProcessor before instantiation of bean failed", ex);
    }

    try {
   
        // 5.创建Bean实例（真正创建Bean的方法）
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        if (logger.isTraceEnabled()) {
   
            logger.trace("Finished creating instance of bean '" + beanName + "'");
        }
        // 6.返回创建的Bean实例
        return beanInstance;
    }
    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
   
        // A previously detected exception with proper bean creation context already,
        // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
        throw ex;
    }
    catch (Throwable ex) {
   
        throw new BeanCreationException(
            mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
    }
}

resolveBeforeInstantiation()

我们来看 createBean() 代码块的 3 中。

@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
   
    Object bean = null;
    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
   
        // Make sure bean class is actually resolved at this point.
        // 1.mbd不是合成的，并且BeanFactory中存在InstantiationAwareBeanPostProcessor
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
   
            // 2.解析beanName对应的Bean实例的类型
            Class<?> targetType = determineTargetType(beanName, mbd);
            if (targetType != null) {
   
                // 3.实例化前的后置处理器应用（处理InstantiationAwareBeanPostProcessor）
                bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                if (bean != null) {
   
                    // 4.如果返回的bean不为空，会跳过Spring默认的实例化过程，
                    // 所以只能在这里调用BeanPostProcessor实现类的postProcessAfterInitialization方法
                    bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                }
            }
        }
        // 5.如果bean不为空，则将beforeInstantiationResolved赋值为true，代表在实例化之前已经解析
        mbd.beforeInstantiationResolved = (bean != null);
    }
    return bean;
}

applyBeanPostProcessorsBeforeInstantiation()

实例化前 BeanPostProcessor 的调用。

在实例化之前执行 InstantiationAwareBeanPostProcessor 的 postProcessBeforeInstantiation 方法，该方法可以返回 bean 实例的代理，从而跳过 Spring 默认的实例化过程。

@Nullable
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
   
    // 1. 遍历所有实现InstantiationAwareBeanPostProcessor接口的BeanPostProcessor
    for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
   
        // 2. 执行postProcessBeforeInstantiation方法，在Bean实例化前操作
        // 该方法可以返回一个构造完成的Bean实例，从而不会继续执行创建Bean实例的“正规的流程”，达到“短路”的效果。
        Object result = bp.postProcessBeforeInstantiation(beanClass, beanName);
        if (result != null) {
   
            // 3. 如果result不为空，也就是有后置处理器返回了bean实例对象，则会跳过Spring默认的实例化过程
            return result;
        }
    }
    return null;
}

其中调用了getBeanPostProcessorCache()，它其实就是一个用来区分实现不同接口的的缓存集合，因为此时的 BeanPostProcessor 都已经注册完成，为了防止多次遍历，直接提供缓存会更加高效。

// 返回预过滤后处理器的内部缓存，必要时重新构建
// 主要目的是为了减少遍历，快速获取对应实现类的BeanPostProcessor
BeanPostProcessorCache getBeanPostProcessorCache() {
   
    // 1. 获取当前容器中的beanPostProcessorCache
    BeanPostProcessorCache bpCache = this.beanPostProcessorCache;
    if (bpCache == null) {
   
        // 2. 如果为空则初始化
        bpCache = new BeanPostProcessorCache();
        // 3. 遍历之前注册完成的所有beanPostProcessors
        for (BeanPostProcessor bp : this.beanPostProcessors) {
   
            // 3.1 如果bp实现了InstantiationAwareBeanPostProcessor接口
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
   
                // 3.1.1 添加到instantiationAware集合中
                bpCache.instantiationAware.add((InstantiationAwareBeanPostProcessor) bp);
                // 3.1.2 如果bp还实现了SmartInstantiationAwareBeanPostProcessor接口
                if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
   
                    // 3.1.3 添加到smartInstantiationAware集合中
                    bpCache.smartInstantiationAware.add((SmartInstantiationAwareBeanPostProcessor) bp);
                }
            }
            // 3.2 如果bp实现了DestructionAwareBeanPostProcessor接口
            if (bp instanceof DestructionAwareBeanPostProcessor) {
   
                bpCache.destructionAware.add((DestructionAwareBeanPostProcessor) bp);
            }
            // 3.3 如果bp实现了MergedBeanDefinitionPostProcessor接口
            if (bp instanceof MergedBeanDefinitionPostProcessor) {
   
                bpCache.mergedDefinition.add((MergedBeanDefinitionPostProcessor) bp);
            }
        }
        // 初始化缓存完成
        this.beanPostProcessorCache = bpCache;
    }
    return bpCache;
}

static class BeanPostProcessorCache {
   

    final List<InstantiationAwareBeanPostProcessor> instantiationAware = new ArrayList<>();

    final List<SmartInstantiationAwareBeanPostProcessor> smartInstantiationAware = new ArrayList<>();

    final List<DestructionAwareBeanPostProcessor> destructionAware = new ArrayList<>();

    final List<MergedBeanDefinitionPostProcessor> mergedDefinition = new ArrayList<>();
}

doCreateBean()【重点】

我们来看 createBean() 代码块的 5 中。

这才是Spring真正创建bean实例的方法，代码前后关联紧密，需要多理解几遍。

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    throws BeanCreationException {
   

    // Instantiate the bean.
    // 1. 新建Bean包装类
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
   
        // 2. 如果是FactoryBean，则需要先移除未完成的FactoryBean实例的缓存
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
   
        // 3. 根据beanName、mbd、args，使用对应的策略创建Bean实例，并返回包装类BeanWrapper
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    // 4. 拿到创建好的Bean实例
    Object bean = instanceWrapper.getWrappedInstance();
    // 5. 拿到Bean实例的类型
    Class<?> beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
   
        mbd.resolvedTargetType = beanType;
    }

    // Allow post-processors to modify the merged bean definition.
    synchronized (mbd.postProcessingLock) {
   
        if (!mbd.postProcessed) {
   
            try {
   
                // 6. 应用后置处理器MergedBeanDefinitionPostProcessor，允许修改MergedBeanDefinition，
                // Autowired注解正是通过此方法实现注入类型的预解析
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            }
            catch (Throwable ex) {
   
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                                "Post-processing of merged bean definition failed", ex);
            }
            mbd.postProcessed = true;
        }
    }

    // Eagerly cache singletons to be able to resolve circular references
    // even when triggered by lifecycle interfaces like BeanFactoryAware.
    // 7.判断是否需要提早曝光实例：单例 && 允许循环依赖 && 当前bean正在创建中
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                                      isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
   
        if (logger.isTraceEnabled()) {
   
            logger.trace("Eagerly caching bean '" + beanName +
                         "' to allow for resolving potential circular references");
        }
        // addSingletonFactory() -> 8.提前曝光beanName的ObjectFactory，用于解决循环引用
        // getEarlyBeanReference() -> 8.1 应用后置处理器SmartInstantiationAwareBeanPostProcessor，允许返回指定bean的早期引用，若没有则直接返回bean
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }

    // Initialize the bean instance. 初始化bean实例
    Object exposedObject = bean;
    try {
   
        // 9. 对bean进行属性填充；其中，可能存在依赖于其他bean的属性，则会递归初始化依赖的bean实例
        populateBean(beanName, mbd, instanceWrapper);
        // 10.对bean进行初始化
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
    catch (Throwable ex) {
   
        if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
   
            throw (BeanCreationException) ex;
        }
        else {
   
            throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
        }
    }

    if (earlySingletonExposure) {
   
        // 11.如果允许提前曝光实例，则进行循环依赖检查
        Object earlySingletonReference = getSingleton(beanName, false);
        // 11.1 earlySingletonReference只有在当前解析的bean存在循环依赖的情况下才会不为空
        if (earlySingletonReference != null) {
   
            if (exposedObject == bean) {
   
                // 11.2 如果exposedObject没有在initializeBean方法中被增强，则不影响之前的循环引用
                exposedObject = earlySingletonReference;
            }
            /* 11.3 如果exposedObject在initializeBean方法中被增强 && 不允许在循环引用的情况下使用注入原始bean实例 && 当前bean有被其他bean依赖 */
            else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
   
                // 11.4 拿到依赖当前bean的所有bean的beanName数组
                String[] dependentBeans = getDependentBeans(beanName);
                Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
                for (String dependentBean : dependentBeans) {
   
                    // 11.5 尝试移除这些bean的实例，因为这些bean依赖的bean已经被增强了，他们依赖的bean相当于脏数据
                    if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
   
                        // 11.6 移除失败的添加到 actualDependentBeans
                        actualDependentBeans.add(dependentBean);
                    }
                }
                if (!actualDependentBeans.isEmpty()) {
   
                    // 11.7 如果存在移除失败的，则抛出异常，因为存在bean依赖了“脏数据”
                    throw new BeanCurrentlyInCreationException(beanName,
                    "Bean with name '" + beanName + "' has been injected into other beans [" +
                     StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                    "] in its raw version as part of a circular reference, but has eventually been " +
                    "wrapped. This means that said other beans do not use the final version of the " +
                    "bean. This is often the result of over-eager type matching - consider using " +
                    "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
                }
            }
        }
    }

    // Register bean as disposable.
    try {
   
        // 12.注册用于销毁的bean，执行销毁操作的有三种：自定义destroy方法、DisposableBean接口、DestructionAwareBeanPostProcessor
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
   
        throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }
	// 13.完成创建并返回
    return exposedObject;
}

createBeanInstance()

我们来看 doCreateBean() 代码块的 3 中。

创建实例的方法通常有以下几种：

1. 工厂方法
2. 构造函数自动装配（通常指带有参数的构造函数）
3. 简单实例化（默认的构造函数）
4. Supplier创建（本质上是 lambda表达式<函数式接口>）

其中工厂方法现在基本不使用了，不再解析；简单实例化过程比较简单，也不解析；Supplier创建不太常见吧，想了解的话稍微看一下Spring中 Supplier创建bean

本段落只对构造函数自动装配进行解析。

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
   
    // Make sure bean class is actually resolved at this point.
    // 解析bean的类型信息
    Class<?> beanClass = resolveBeanClass(mbd, beanName);

    // beanClass不为空 && beanClass不是公开类（不是public修饰） && 该bean不允许访问非公共构造函数和方法，则抛异常
    if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
   
        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                        "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
    }

    // 1. 从 BeanDefinition 信息中获取supplier接口方法，如果存在直接使用supplier函数式接口完成bean的初始化
    Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
    if (instanceSupplier != null) {
   
        return obtainFromSupplier(instanceSupplier, beanName);
    }
	// 2. 如果存在工厂方法则使用工厂方法实例化bean对象
    if (mbd.getFactoryMethodName() != null) {
   
        return instantiateUsingFactoryMethod(beanName, mbd, args);
    }

    // Shortcut when re-creating the same bean...
    // resolved 标识构造函数或工厂方法是否已经解析过
    boolean resolved = false;
    // autowireNecessary 标识是否需要自动注入（即是否需要解析构造函数参数）
    boolean autowireNecessary = false;
    if (args == null) {
   
        // 3. 加锁
        synchronized (mbd.constructorArgumentLock) {
   
            // 3.1 如果resolvedConstructorOrFactoryMethod缓存不为空，则将resolved标记为已解析
            if (mbd.resolvedConstructorOrFactoryMethod != null) {
   
                resolved = true;
                // 3.2 根据constructorArgumentsResolved判断是否需要自动注入
                autowireNecessary = mbd.constructorArgumentsResolved;
            }
        }
    }
    if (resolved) {
   
        // 4. 如果已经解析过，则使用resolvedConstructorOrFactoryMethod缓存里解析好的构造函数方法
        if (autowireNecessary) {
   
            // 4.1 需要自动注入，则执行构造函数自动注入
            return autowireConstructor(beanName, mbd, null, null);
        }
        else {
   
            // 4.2 否则使用默认的构造函数进行bean的实例化
            return instantiateBean(beanName, mbd);
        }
    }

    // Candidate constructors for autowiring?
    // 5. 应用后置处理器SmartInstantiationAwareBeanPostProcessor，拿到bean的候选构造函数
    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    // 如果推断出来了构造方法，则需要给构造方法赋值，也就是给构造方法参数赋值，也就是构造方法注入
	// 如果没有推断出来构造方法，但是autowiremode为AUTOWIRE_CONSTRUCTOR，则也可能需要给构造方法赋值，因为不确定是用无参的还是有参的构造方法
	// 如果通过BeanDefinition指定了构造方法参数值，那肯定就是要进行构造方法注入了
	// 如果调用getBean的时候传入了构造方法参数值，那肯定就是要进行构造方法注入了
    if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
        mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
   
        /* // 6. 如果ctors不为空 || mbd的注入方式为AUTOWIRE_CONSTRUCTOR || mbd定义了构造函数的参数值 || args不为空，则执行构造函数自动注入 */
        return autowireConstructor(beanName, mbd, ctors, args);
    }

    // Preferred constructors for default construction?
    ctors = mbd.getPreferredConstructors();
    if (ctors != null) {
   
        return autowireConstructor(beanName, mbd, ctors, null);
    }

    // No special handling: simply use no-arg constructor.
    // 7. 没有特殊处理，则使用默认的构造函数进行bean的实例化
    return instantiateBean(beanName, mbd);
}

determineConstructorsFromBeanPostProcessors()

我们来看 createBeanInstance() 代码块的 5 中。

调用 SmartInstantiationAwareBeanPostProcessor 的 determineCandidateConstructors 方法，该方法可以返回要用于 beanClass 的候选构造函数。使用 @Autowire 注解修饰构造函数，则该构造函数在这边会被 AutowiredAnnotationBeanPostProcessor 找到。

@Nullable
protected Constructor<?>[] determineConstructorsFromBeanPostProcessors(@Nullable Class<?> beanClass, String beanName) throws BeansException {
   

    if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {
   
        for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
   
            /* 调用SmartInstantiationAwareBeanPostProcessor的determineCandidateConstructors方法， 该方法可以返回要用于beanClass的候选构造函数 例如：使用@Autowire注解修饰构造函数，则该构造函数在这边会被AutowiredAnnotationBeanPostProcessor找到 */
            Constructor<?>[] ctors = bp.determineCandidateConstructors(beanClass, beanName);
            if (ctors != null) {
   
                // 如果ctors不为空，则不再继续执行其他的SmartInstantiationAwareBeanPostProcessor
                return ctors;
            }
        }
    }
    return null;
}

autowireConstructor()

参考博客文章：Spring推断构造方法(中)_

我们来看 createBeanInstance() 代码块的 6 中。

推断构造方法的代码逻辑顺序列举：

1. 初步确定构造方法和参数

使用constructorToUse变量存将要使用的构造方法，argsToUse变量存需要使用的构造方法参数值，ArgumentsHolder是对构造方法参数值的封装。首先判断getBean()方法调用时有没有指定构造方法参数，如果指定了，则优先使用指定的值作为构造方法的参数值；如果没有指定，则判断BeanDefinition中是否缓存了构造方法参数值。

2. 推断构造方法和方法参数：如果缓存中没有构造方法，或者没有得到可用的构造方法参数，则需要自行去推断获取。
   1. 推断使用默认无参构造方法
   2. 记录构造方法的最小参数个数
   3. 对构造方法进行排序
   4. 遍历构造方法进行筛选
   5. 寻找构造方法参数
   6. 寻找最佳的构造方法
   7. 生成实例

protected BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
             	@Nullable Constructor<?>[] ctors, @Nullable Object[] explicitArgs) {
   
    return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
}

// ConstructorResolver 构造方法
public ConstructorResolver(AbstractAutowireCapableBeanFactory beanFactory) {
   
    this.beanFactory = beanFactory;
    this.logger = beanFactory.getLogger();
}

// ConstructorResolver 127
public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
     			@Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) {
   
	// 定义bean包装类
    BeanWrapperImpl bw = new BeanWrapperImpl();
    this.beanFactory.initBeanWrapper(bw);

    // 最终用于实例化的构造函数
    Constructor<?> constructorToUse = null;
    // 最终用于实例化的参数Holder
    ArgumentsHolder argsHolderToUse = null;
    // 最终用于实例化的构造函数参数
    Object[] argsToUse = null;

    // 1.解析出要用于实例化的构造函数参数
    if (explicitArgs != null) {
   
        // 1.1 如果explicitArgs不为空，则构造函数的参数直接使用explicitArgs
        // 如果通过getBean方法调用时，显示指定了参数，则explicitArgs就不为null
        argsToUse = explicitArgs;
    }
    else {
   
        // 1.2 尝试从缓存中获取已经解析过的构造函数参数
        Object[] argsToResolve = null;
        synchronized (mbd.constructorArgumentLock) {
   
            // 1.2.1 拿到缓存中已解析的构造函数或工厂方法
            constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
            // 1.2.2 如果constructorToUse不为空 && mbd标记了构造函数参数已解析
            if (constructorToUse != null && mbd.constructorArgumentsResolved) {
   
                // Found a cached constructor...
                // 1.2.3 从缓存中获取已解析的构造函数参数
                argsToUse = mbd.resolvedConstructorArguments;
                if (argsToUse == null) {
   
                    /* 1.2.4 如果resolvedConstructorArguments为空，则从缓存中获取准备用于解析的构造函数参数， constructorArgumentsResolved为true时，resolvedConstructorArguments和 preparedConstructorArguments必然有一个缓存了构造函数的参数 */
                    argsToResolve = mbd.preparedConstructorArguments;
                }
            }
        }
        // 1.2.5 如果argsToResolve不为空，则对构造函数参数进行解析，
        // 如给定方法的构造函数 A(int,int)则通过此方法后就会把配置中的("1","1")转换为(1,1)
        if (argsToResolve != null) {
   
            argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve);
        }
    }

    // 2.如果没有确定要使用的构造方法，或者确定了构造方法但是所要传入的参数值没有确定
	/* 此时说明只有两种情况为null： 1、只有一个默认的无参构造方法； 2、有多个有参构造方法。 */
    if (constructorToUse == null || argsToUse == null) {
   
        // Take specified constructors, if any.
        // 2.1 如果没有指定构造方法，那就获取beanClass中的所有构造方法所谓候选者
        Constructor<?>[] candidates = chosenCtors;
        if (candidates == null) {
   
            Class<?> beanClass = mbd.getBeanClass();
            try {
   
                candidates = (mbd.isNonPublicAccessAllowed() ?
                              beanClass.getDeclaredConstructors() : beanClass.getConstructors());
            }
            catch (Throwable ex) {
   
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                                "Resolution of declared constructors on bean Class [" + beanClass.getName() +
                                                "] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
            }
        }
		// 2.2 如果只有一个候选构造方法，并且没有指定所要使用的构造方法参数值，并且该构造方法是无参的，那就直接用这个无参构造方法进行实例化了
        if (candidates.length == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
   
            Constructor<?> uniqueCandidate = candidates[0];
            if (uniqueCandidate.getParameterCount() == 0) {
   
                synchronized (mbd.constructorArgumentLock) {
   
                    // 2.3 将构造方法以及参数(空数组)进行缓存，防止后面不必要的构造推断
                    mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
                    mbd.constructorArgumentsResolved = true;
                    mbd.resolvedConstructorArguments = EMPTY_ARGS;
                }
                bw.setBeanInstance(instantiate(beanName, mbd, uniqueCandidate, EMPTY_ARGS));
                return bw;
            }
        }

        // Need to resolve the constructor.
        // 2.1 检查是否需要进行构造注入自动装配：候选的构造方法不为空 || 指定注入方式为构造注入时
        /* 候选的构造方法不为空包含两种情况： 1、有加了@Autowired的构造方法 2、只有一个多参的构造方法，对于这两种情况，都需要进行构造注入 */
        boolean autowiring = (chosenCtors != null ||
                              mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
        
        ConstructorArgumentValues resolvedValues = null;

        // 3. 确定要选择的构造方法的参数个数的最小值，后续判断候选构造方法的参数个数如果小于minNrOfArgs，则直接pass掉
        int minNrOfArgs;
        if (explicitArgs != null) {
   
            // 3.1 如果直接传了构造方法参数值，那么所用的构造方法的参数个数肯定不能少于传了的构造方法参数值长度
            minNrOfArgs = explicitArgs.length;
        }
        else {
   
            // 3.2 获得mbd的构造函数的参数值（indexedArgumentValues：带index的参数值；genericArgumentValues：通用的参数值）
            ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
            // 3.3 创建ConstructorArgumentValues对象resolvedValues，用于承载解析后的构造函数参数的值
            resolvedValues = new ConstructorArgumentValues();
            // 3.4 解析mbd的构造函数的参数，并返回参数个数
            minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
            // 注：这边解析mbd中的构造函数参数值，主要是处理我们通过xml方式定义的构造函数注入的参数，
            // 但是如果我们是通过@Autowire注解直接修饰构造函数，则mbd是没有这些参数值的
        }
		// 4. 对候选构造方法进行排序，public的方法排在最前面，都是public的情况下参数个数越多越靠前
        AutowireUtils.sortConstructors(candidates);
        int minTypeDiffWeight = Integer.MAX_VALUE;
        Set<Constructor<?>> ambiguousConstructors = null;
        Deque<UnsatisfiedDependencyException> causes = null;

        // 5. 遍历每个构造方法，进行筛选
        for (Constructor<?> candidate : candidates) {
   
            // 参数个数
            int parameterCount = candidate.getParameterCount();
			// 5.1 本次遍历时，之前已经选出来了所要用的构造方法和入参对象，并且入参对象个数比当前遍历到的这个构造方法的参数个数多，则不用再遍历，退出循环
            if (constructorToUse != null && argsToUse != null && argsToUse.length > parameterCount) {
   
                // Already found greedy constructor that can be satisfied ->
                // do not look any further, there are only less greedy constructors left.
                break;
            }
            // 5.2 如果参数个数小于所要求的参数个数，则遍历下一个，这里考虑的是同时存在public和非public的构造方法
            if (parameterCount < minNrOfArgs) {
   
                continue;
            }

            ArgumentsHolder argsHolder;
            Class<?>[] paramTypes = candidate.getParameterTypes();
            // 没有通过getBean()指定构造方法参数值
            // 5.3 resolvedValues不为空
            if (resolvedValues != null) {
   
                // 存在参数则根据参数值来匹配参数类型
                try {
   
                    // 5.3.1 获取当前遍历的构造函数的参数名称
                    // 5.3.1.1 如果在构造方法上使用了@ConstructorProperties，那么就直接取定义的值作为构造方法的参数名
                    String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, parameterCount);
                    // 获取构造方法参数名
                    if (paramNames == null) {
   
                        // 5.3.1.2 获取参数名称解析器
                        ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
                        if (pnd != null) {
   
                            // 5.3.1.3 使用参数名称解析器获取当前遍历的构造函数的参数名称
                            paramNames = pnd.getParameterNames(candidate);
                        }
                    }
                    // 5.3.2 创建一个参数数组以调用构造函数或工厂方法，
                    // 主要是通过参数类型和参数名解析构造函数或工厂方法所需的参数（如果参数是其他bean，则会解析依赖的bean）
                    argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames, getUserDeclaredConstructor(candidate), autowiring, candidates.length == 1);
                }
                catch (UnsatisfiedDependencyException ex) {
   
                    // 5.3.3 当前正在遍历的构造方法找不到可用的入参对象，记录一下
                    if (logger.isTraceEnabled()) {
   
                        logger.trace("Ignoring constructor [" + candidate + "] of bean '" + beanName + "': " + ex);
                    }
                    // Swallow and try next constructor.
                    if (causes == null) {
   
                        causes = new ArrayDeque<>(1);
                    }
                    causes.add(ex);
                    continue;
                }
            }
            else {
   
                // Explicit arguments given -> arguments length must match exactly.
                // 5.4 resolvedValues为空，则explicitArgs不为空，即给出了显式参数
                // 5.4.1 如果当前遍历的构造函数参数个数与explicitArgs长度不相同，则跳过该构造函数
                if (parameterCount != explicitArgs.length) {
   
                    continue;
                }
                // 5.4.2 使用显式给出的参数构造ArgumentsHolder
                argsHolder = new ArgumentsHolder(explicitArgs);
            }

            // 5.5 根据mbd的解析构造函数模式（true: 宽松模式(默认)，false：严格模式），
            // 将argsHolder的参数和paramTypes进行比较，计算paramTypes的类型差异权重值
            int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
                                  argsHolder.getTypeDifferenceWeight(paramTypes) : 		
                                  argsHolder.getAssignabilityWeight(paramTypes));
            // Choose this constructor if it represents the closest match.
            // 5.6 类型差异权重值越小,则说明构造函数越匹配，则选择此构造函数
            if (typeDiffWeight < minTypeDiffWeight) {
   
                // 将要使用的参数都替换成差异权重值更小的
                constructorToUse = candidate;
                argsHolderToUse = argsHolder;
                argsToUse = argsHolder.arguments;
                minTypeDiffWeight = typeDiffWeight;
                // 如果出现权重值更小的候选者，则将ambiguousConstructors清空，允许之前存在权重值相同的候选者
                ambiguousConstructors = null;
            }
            // 5.7 如果存在两个候选者的权重值相同，并且是当前遍历过权重值最小的
            else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
   
                // 5.8 将这两个候选者都添加到ambiguousConstructors
                if (ambiguousConstructors == null) {
   
                    ambiguousConstructors = new LinkedHashSet<>();
                    ambiguousConstructors.add(constructorToUse);
                }
                ambiguousConstructors.add(candidate);
            }
        }
		// 6. 如果没有可用的构造方法，就取记录的最后一个异常并抛出
        if (constructorToUse == null) {
   
            if (causes != null) {
   
                UnsatisfiedDependencyException ex = causes.removeLast();
                for (Exception cause : causes) {
   
                    this.beanFactory.onSuppressedException(cause);
                }
                throw ex;
            }
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                            "Could not resolve matching constructor on bean class [" + mbd.getBeanClassName() + "] " +
                                            "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
        }
        // 7. 如果有可用的构造方法，但是有多个
        else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) {
   
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                            "Ambiguous constructor matches found on bean class [" + mbd.getBeanClassName() + "] " +
                                            "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
                                            ambiguousConstructors);
        }
		// 8. 如果没有通过getBean方法传入参数，并且找到了构造方法以及要用的入参对象则缓存
        if (explicitArgs == null && argsHolderToUse != null) {
   
            argsHolderToUse.storeCache(mbd, constructorToUse);
        }
    }

    Assert.state(argsToUse != null, "Unresolved constructor arguments");
    bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
    return bw;
}

resolveConstructorArguments()

我们来看 autowireConstructor() 代码块的 3.4 中。

解析 mbd 的构造函数的参数，并返回参数个数。

private int resolveConstructorArguments(String beanName, RootBeanDefinition mbd, BeanWrapper bw,
		ConstructorArgumentValues cargs, ConstructorArgumentValues resolvedValues) {
   
 
    // 1.构建bean定义值解析器
    TypeConverter customConverter = this.beanFactory.getCustomTypeConverter();
    TypeConverter converter = (customConverter != null ? customConverter : bw);
    BeanDefinitionValueResolver valueResolver =
            new BeanDefinitionValueResolver(this.beanFactory, beanName, mbd, converter);
 
    // 2.minNrOfArgs初始化为indexedArgumentValues和genericArgumentValues的的参数个数总和
    int minNrOfArgs = cargs.getArgumentCount();
    // 3.遍历解析带index的参数值
    for (Map.Entry<Integer, ConstructorArgumentValues.ValueHolder> entry : cargs.getIndexedArgumentValues().entrySet()) {
   
        int index = entry.getKey();
        if (index < 0) {
   
            // index从0开始，不允许小于0
            throw new BeanCreationException(mbd.getResourceDescription(),
                                            beanName,
                    						"Invalid constructor argument index: " + index);
        }
        // 3.1 如果index大于minNrOfArgs，则修改minNrOfArgs
        if (index > minNrOfArgs) {
   
            // index是从0开始，并且是有序递增的，所以当有参数的index=5时，代表该方法至少有6个参数
            minNrOfArgs = index + 1;
        }
        ConstructorArgumentValues.ValueHolder valueHolder = entry.getValue();
        // 3.2 解析参数值
        if (valueHolder.isConverted()) {
   
            // 3.2.1 如果参数值已经转换过，则直接将index和valueHolder添加到resolvedValues的indexedArgumentValues属性
            resolvedValues.addIndexedArgumentValue(index, valueHolder);
        } else {
   
            // 3.2.2 如果值还未转换过，则先进行转换
            Object resolvedValue =
                    valueResolver.resolveValueIfNecessary("constructor argument", valueHolder.getValue());
            // 3.2.3 使用转换后的resolvedValue构建新的ValueHolder
            ConstructorArgumentValues.ValueHolder resolvedValueHolder =
                    new ConstructorArgumentValues.ValueHolder(resolvedValue,
                                                              valueHolder.getType(),
                                                              valueHolder.getName());
            // 3.2.4 将转换前的valueHolder保存到新的ValueHolder的source属性
            resolvedValueHolder.setSource(valueHolder);
            // 3.2.5 将index和新的ValueHolder添加到resolvedValues的indexedArgumentValues属性
            resolvedValues.addIndexedArgumentValue(index, resolvedValueHolder);
        }
    }
 
    // 4.遍历解析通用参数值（不带index）
    for (ConstructorArgumentValues.ValueHolder valueHolder : cargs.getGenericArgumentValues()) {
   
        if (valueHolder.isConverted()) {
   
            // 4.1 如果参数值已经转换过，则直接将valueHolder添加到resolvedValues的genericArgumentValues属性
            resolvedValues.addGenericArgumentValue(valueHolder);
        } else {
   
            // 4.2 如果值还未转换过，则先进行转换
            Object resolvedValue =
                    valueResolver.resolveValueIfNecessary("constructor argument",
                                                          valueHolder.getValue());
            // 4.3 使用转换后的resolvedValue构建新的ValueHolder
            ConstructorArgumentValues.ValueHolder resolvedValueHolder =
                    new ConstructorArgumentValues.ValueHolder(resolvedValue,
                                                              valueHolder.getType(),
                                                              valueHolder.getName());
            // 4.4 将转换前的valueHolder保存到新的ValueHolder的source属性
            resolvedValueHolder.setSource(valueHolder);
            // 4.5 将新的ValueHolder添加到resolvedValues的genericArgumentValues属性
            resolvedValues.addGenericArgumentValue(resolvedValueHolder);
        }
    }
    // 5.返回构造函数参数的个数
    return minNrOfArgs;
}

createArgumentArray()

我们来看 autowireConstructor() 代码块的 5.3.2 中。

创建一个参数数组以调用构造函数或工厂方法，主要是通过参数类型和参数名解析构造函数或工厂方法所需的参数（如果参数是其他 bean，则会解析依赖的 bean）。

private ArgumentsHolder createArgumentArray(
    String beanName, RootBeanDefinition mbd, @Nullable ConstructorArgumentValues resolvedValues,
    BeanWrapper bw, Class<?>[] paramTypes, @Nullable String[] paramNames, Executable executable,
    boolean autowiring, boolean fallback) throws UnsatisfiedDependencyException {
   

    TypeConverter customConverter = this.beanFactory.getCustomTypeConverter();
    // 获取类型转换器
    TypeConverter converter = (customConverter != null ? customConverter : bw);

    // 新建一个ArgumentsHolder来存放匹配到的参数
    ArgumentsHolder args = new ArgumentsHolder(paramTypes.length);
    Set<ConstructorArgumentValues.ValueHolder> usedValueHolders = new HashSet<>(paramTypes.length);
    Set<String> autowiredBeanNames = new LinkedHashSet<>(4);

    // 1. 遍历参数类型数组
    for (int paramIndex = 0; paramIndex < paramTypes.length; paramIndex++) {
   
        // 拿到当前遍历的参数类型
        Class<?> paramType = paramTypes[paramIndex];
        // 拿到当前遍历的参数名
        String paramName = (paramNames != null ? paramNames[paramIndex] : "");
        // 【翻译注释】尝试查找匹配的构造函数参数值，无论是索引的还是泛型的
        // 2. 查找当前遍历的参数，是否在mdb对应的bean的构造函数参数中存在index、类型和名称匹配的
        ConstructorArgumentValues.ValueHolder valueHolder = null;
        if (resolvedValues != null) {
   
            valueHolder = resolvedValues.getArgumentValue(paramIndex, paramType, paramName, usedValueHolders);
            // If we couldn't find a direct match and are not supposed to autowire,
            // let's try the next generic, untyped argument value as fallback:
            // it could match after type conversion (for example, String -> int).
            // 3.如果我们找不到直接匹配并且不应该自动装配，那么让我们尝试下一个通用的无类型参数值作为降级方法：它可以在类型转换后匹配（例如，String - > int）。
            if (valueHolder == null && (!autowiring || paramTypes.length == resolvedValues.getArgumentCount())) {
   
                valueHolder = resolvedValues.getGenericArgumentValue(null, null, usedValueHolders);
            }
        }
        if (valueHolder != null) {
   
            // 4.valueHolder不为空，存在匹配的参数
            // We found a potential match - let's give it a try.
            // Do not consider the same value definition multiple times!
            // 将valueHolder添加到usedValueHolders
            usedValueHolders.add(valueHolder);
            // 原始属性值
            Object originalValue = valueHolder.getValue();
            // 转换后的属性值
            Object convertedValue;
            if (valueHolder.isConverted()) {
   
                // 4.1 如果valueHolder已经转换过
                // 4.1.1 则直接获取转换后的值
                convertedValue = valueHolder.getConvertedValue();
                // 4.1.2 将convertedValue作为args在paramIndex位置的预备参数
                args.preparedArguments[paramIndex] = convertedValue;
            }
            else {
   
                // 4.2 如果valueHolder还未转换过
                // 4.2.1 获取对应构造参数或工厂方法对应索引的方法参数
                MethodParameter methodParam = MethodParameter.forExecutable(executable, paramIndex);
                try {
   
                	// 4.2.2 将方法对应索引的原始值转换为paramType类型的值
                    convertedValue = converter.convertIfNecessary(originalValue, paramType, methodParam);
                }
                catch (TypeMismatchException ex) {
   
					// 如果类型转换失败，抛出TypeMismatchException
                    throw new UnsatisfiedDependencyException(
                        mbd.getResourceDescription(), beanName, new InjectionPoint(methodParam),
                        "Could not convert argument value of type [" +
                        ObjectUtils.nullSafeClassName(valueHolder.getValue()) +
                        "] to required type [" + paramType.getName() + "]: " + ex.getMessage());
                }
                // 4.2.3 拿到原始参数值
                Object sourceHolder = valueHolder.getSource();
                if (sourceHolder instanceof ConstructorArgumentValues.ValueHolder) {
   
                    // 4.2.4 
                    Object sourceValue = ((ConstructorArgumentValues.ValueHolder) sourceHolder).getValue();
                    // 4.2.5 args标记为需要解析
                    args.resolveNecessary = true;
                    // 4.2.6 将convertedValue作为args在paramIndex位置的预备参数
                    args.preparedArguments[paramIndex] = sourceValue;
                }
            }
            args.arguments[paramIndex] = convertedValue;
            args.rawArguments[paramIndex] = originalValue;
        }
        else {
   
            // 5.valueHolder为空，不存在匹配的参数
            // 5.1 将方法（此处为构造函数）和参数索引封装成MethodParameter
            MethodParameter methodParam = MethodParameter.forExecutable(executable, paramIndex);
            // No explicit match found: we're either supposed to autowire or
            // have to fail creating an argument array for the given constructor.
            // 5.2 找不到明确的匹配，并且不是自动装配，则抛出异常
            if (!autowiring) {
   
                throw new UnsatisfiedDependencyException(
                    mbd.getResourceDescription(), beanName, new InjectionPoint(methodParam),
                    "Ambiguous argument values for parameter of type [" + paramType.getName() +
                    "] - did you specify the correct bean references as arguments?");
            }
            try {
   
                // 5.3 如果是自动装配，则调用用于解析自动装配参数的方法，返回的结果为依赖的bean实例对象
                // 例如：@Autowire修饰构造函数，自动注入构造函数中的参数bean就是在这边处理
                Object autowiredArgument = resolveAutowiredArgument(
                    methodParam, beanName, autowiredBeanNames, converter, fallback);
                // 5.4 将通过自动装配解析出来的参数赋值给args
                args.rawArguments[paramIndex] = autowiredArgument;
                args.arguments[paramIndex] = autowiredArgument;
                args.preparedArguments[paramIndex] = autowiredArgumentMarker;
                args.resolveNecessary = true;
            }
            catch (BeansException ex) {
   
                // 5.5 如果自动装配解析失败，则会抛出异常
                throw new UnsatisfiedDependencyException(
                    mbd.getResourceDescription(), beanName, new InjectionPoint(methodParam), ex);
            }
        }
    }

    // 6.如果依赖了其他的bean，则注册依赖关系
    for (String autowiredBeanName : autowiredBeanNames) {
   
        this.beanFactory.registerDependentBean(autowiredBeanName, beanName);
        if (logger.isDebugEnabled()) {
   
            logger.debug("Autowiring by type from bean name '" + beanName +
                         "' via " + (executable instanceof Constructor ? "constructor" : "factory method") +
                         " to bean named '" + autowiredBeanName + "'");
        }
    }

    return args;
}

resolveAutowiredArgument()

我们来看 createArgumentArray() 代码块的 5.3 中。

如果是自动装配，则调用用于解析自动装配参数的方法，返回的结果为依赖的 bean 实例对象。

@Nullable
protected Object resolveAutowiredArgument(
    MethodParameter param,
    String beanName,
    @Nullable Set<String> autowiredBeanNames,
    TypeConverter typeConverter,
    boolean fallback) {
   

    Class<?> paramType = param.getParameterType();
    // 1.如果参数类型为InjectionPoint(Spring注入点类)
    if (InjectionPoint.class.isAssignableFrom(paramType)) {
   
        // 1.1 拿到当前的InjectionPoint（存储了当前正在解析依赖的方法参数信息，DependencyDescriptor）
        InjectionPoint injectionPoint = currentInjectionPoint.get();
        if (injectionPoint == null) {
   
            // 1.2 当前injectionPoint为空，则抛出异常：目前没有可用的InjectionPoint
            throw new IllegalStateException("No current InjectionPoint available for " + param);
        }
        // 1.3 返回当前的InjectionPoint
        return injectionPoint;
    }
    try {
   
        // 2.解析指定依赖，DependencyDescriptor：将MethodParameter的方法参数索引信息封装成DependencyDescriptor
        return this.beanFactory.resolveDependency(
            new DependencyDescriptor(param, true), beanName, autowiredBeanNames, typeConverter);
    }
    catch (NoUniqueBeanDefinitionException ex) {
   
        throw ex;
    }
    catch (NoSuchBeanDefinitionException ex) {
   
        if (fallback) {
   
            // 单个构造函数或工厂方法 -> 让我们返回一个空数组/集合，例如vararg或非空列表/集合/映射参数。
            if (paramType.isArray()) {
   
                return Array.newInstance(paramType.getComponentType(), 0);
            }
            else if (CollectionFactory.isApproximableCollectionType(paramType)) {
   
                return CollectionFactory.createCollection(paramType, 0);
            }
            else if (CollectionFactory.isApproximableMapType(paramType)) {
   
                return CollectionFactory.createMap(paramType, 0);
            }
        }
        throw ex;
    }
}

resolveDependency()

我们来看 resolveAutowiredArgument() 代码块的 2 中。

解析指定依赖，这边的 DependencyDescriptor 主要是封装了依赖的方法和参数的信息

这块我们来看 DefaultListableBeanFactory 中的实现：

@Override
@Nullable
public Object resolveDependency(
    DependencyDescriptor descriptor,
    @Nullable String requestingBeanName,
    @Nullable Set<String> autowiredBeanNames,
    @Nullable TypeConverter typeConverter) throws BeansException {
   

    descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
    if (Optional.class == descriptor.getDependencyType()) {
   
        // 1.javaUtilOptionalClass类注入的特殊处理
        return createOptionalDependency(descriptor, requestingBeanName);
    }
    // 2.ObjectFactory类注入的特殊处理
    else if (ObjectFactory.class == descriptor.getDependencyType() ||
             ObjectProvider.class == descriptor.getDependencyType()) {
   
        return new DependencyObjectProvider(descriptor, requestingBeanName);
    }
    else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
   
        // 3.javaxInjectProviderClass类注入的特殊处理
        return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
    }
    else {
   
        // 4.通用类注入的处理
        // 4.1 如有必要，请获取延迟解析代理
        Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
            descriptor, requestingBeanName);
        if (result == null) {
   
            // 4.2 解析依赖关系，返回的result为创建好的依赖对象的bean实例
            result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
        }
        return result;
    }
}

doResolveDependency()

我们来看 resolveDependency() 代码块的 4.2 中。

解析依赖关系，返回的 result 为创建好的依赖对象的 bean 实例。

@Nullable
public Object doResolveDependency(
    DependencyDescriptor descriptor,
    @Nullable String beanName,
    @Nullable Set<String> autowiredBeanNames,
    @Nullable TypeConverter typeConverter) throws BeansException {
   

    // 1. 设置当前的descriptor(存储了方法参数等信息)为当前注入点
    InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
    try {
   
        // 2. 如果是ShortcutDependencyDescriptor，则直接通过getBean方法获取Bean实例，并返回；否则返回null
        /* 通过构造函数注入依赖的 bean 实例的整个过程是不会出现涉及到 ShortcutDependencyDescriptor 的。 ShortcutDependencyDescriptor 主要用于 @Autowire 注解， 在解析 @Autowire 注解的时候，当第一次注入依赖的 bean 实例后， 会将该依赖的 bean 的信息封装成 ShortcutDependencyDescriptor ， 放到缓存中去，下一次需要依赖注入该 bean 时，可以直接快速的拿到该 bean 实例。 */
        Object shortcut = descriptor.resolveShortcut(this);
        if (shortcut != null) {
   
            return shortcut;
        }
		
        // 3. 拿到descriptor包装的方法的参数类型（通过参数索引定位到具体的参数）
        Class<?> type = descriptor.getDependencyType();
        // 4. 用于支持spring中新增的注解@Value（确定给定的依赖项是否声明Value注解，如果有则拿到值）
        Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
        if (value != null) {
   
            if (value instanceof String) {
   
                String strVal = resolveEmbeddedValue((String) value);
                BeanDefinition bd = (beanName != null && containsBean(beanName) ?
                                     getMergedBeanDefinition(beanName) : null);
                value = evaluateBeanDefinitionString(strVal, bd);
            }
            TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
            // 4.1 如果使用了@Value注解，则将解析到的值转换成所需的类型并返回
            try {
   
                return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());
            }
            catch (UnsupportedOperationException ex) {
   
                // A custom TypeConverter which does not support TypeDescriptor resolution...
                return (descriptor.getField() != null ?
                        converter.convertIfNecessary(value, type, descriptor.getField()) :
                        converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
            }
        }
		// 5. 解析MultipleBean（下文的MultipleBean都是指类型为：Array、Collection、Map）
        Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
        if (multipleBeans != null) {
   
            // 5.1 如果确实是容器类型的属性，则直接返回解析结果
            return multipleBeans;
        }
		// 6. 查找与所需类型匹配的Bean实例（matchingBeans，key：beanName；value：匹配的bean实例，或者匹配的bean实例的类型）
        Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
        if (matchingBeans.isEmpty()) {
   
            // 6.1 如果require属性为true，而找到的匹配Bean却为空则抛出异常
            if (isRequired(descriptor)) {
   
                raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
            }
            // 6.2 如果require属性为false，而找到的匹配Bean却为空，则返回null
            return null;
        }

        String autowiredBeanName;
        Object instanceCandidate;

        if (matchingBeans.size() > 1) {
   
            // 7. 非MultipleBean，但是有多个候选者
            // 7.1 从多个候选者中选出最优的那个
            autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
            if (autowiredBeanName == null) {
   
                if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
   
                    return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
                }
                else {
   
                    // In case of an optional Collection/Map, silently ignore a non-unique case:
                    // possibly it was meant to be an empty collection of multiple regular beans
                    // (before 4.3 in particular when we didn't even look for collection beans).
                    return null;
                }
            }
            // 7.2 拿到autowiredBeanName对应的value（bean实例或bean实例类型）
            instanceCandidate = matchingBeans.get(autowiredBeanName);
        }
        else {
   
            // 8. 只找到了一个候选者，则直接使用该候选者
            // We have exactly one match.
            Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
            autowiredBeanName = entry.getKey();
            instanceCandidate = entry.getValue();
        }

        if (autowiredBeanNames != null) {
   
            // 9. 将依赖的beanName加到autowiredBeanNames中
            autowiredBeanNames.add(autowiredBeanName);
        }
        // 10. 如果instanceCandidate为Class，则instanceCandidate为bean实例的类型，执行descriptor.resolveCandidate方法，
        // 通过getBean方法获取bean实例并返回；如果instanceCandidate不是Class，则instanceCandidate为bean实例，直接返回该实例
        if (instanceCandidate instanceof Class) {
   
            instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
        }
        Object result = instanceCandidate;
        if (result instanceof NullBean) {
   
            if (isRequired(descriptor)) {
   
                raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
            }
            result = null;
        }
        if (!ClassUtils.isAssignableValue(type, result)) {
   
            throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
        }
        return result;
    }
    finally {
   
        // 11. 执行结束，将注入点修改成原来的注入点
        ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
    }
}

findAutowireCandidates()

我们来看 resolveDependency() 代码块的 6 中。

查找与所需类型匹配的Bean实例（名为matchingBeans的map，key：beanName；value：匹配的bean实例，或者匹配的bean实例的类型）

protected Map<String, Object> findAutowireCandidates(
    @Nullable String beanName, // bd的beanName
    Class<?> requiredType, // 要查找的bean的实际类型（可能是数组组件类型或集合元素类型）
    DependencyDescriptor descriptor // 描述要解决的依赖关系
) {
   
	// 1. 获取给定类型的所有beanName，包括在祖先工厂中定义的beanName
    String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
        this, requiredType, true, descriptor.isEager());
    Map<String, Object> result = CollectionUtils.newLinkedHashMap(candidateNames.length);
    // 2.首先从已经解析的依赖关系缓存中寻找是否存在我们想要的类型
    for (Map.Entry<Class<?>, Object> classObjectEntry : this.resolvableDependencies.entrySet()) {
   
        Class<?> autowiringType = classObjectEntry.getKey();
        // 2.1 autowiringType是否与requiredType相同，或者是requiredType的超类、超接口
        if (autowiringType.isAssignableFrom(requiredType)) {
   
            // 2.2 如果requiredType匹配，则从缓存中拿到相应的自动装配值（bean实例）
            Object autowiringValue = classObjectEntry.getValue();
            // 2.3 根据给定的所需类型解析给定的自动装配值
            autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
            if (requiredType.isInstance(autowiringValue)) {
   
                // 2.4 将autowiringValue放到结果集中，此时的value为bean实例
                result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);
                break;
            }
        }
    }
    // 3.遍历从容器中获取到的类型符合的beanName
    for (String candidate : candidateNames) {
   
        // isAutowireCandidate：判断是否有资格作为依赖注入的候选者
        // 3.1 如果不是自引用 && candidate有资格作为依赖注入的候选者
        if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {
   
            // 3.2 将候选者添加到result中
            addCandidateEntry(result, candidate, descriptor, requiredType);
        }
    }
    // 4.如果结果为空 && type不是MultipleBean（Array、Collection、Map），则使用降级匹配
    if (result.isEmpty()) {
   
        boolean multiple = indicatesMultipleBeans(requiredType);
        // Consider fallback matches if the first pass failed to find anything...
        // 4.1 使用降级匹配（跟正常匹配类似）
        DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch();
        for (String candidate : candidateNames) {
   
            if (!isSelfReference(beanName, candidate)
                && isAutowireCandidate(candidate, fallbackDescriptor)
                && (!multiple || getAutowireCandidateResolver().hasQualifier(descriptor))) {
   
                addCandidateEntry(result, candidate, descriptor, requiredType);
            }
        }
        if (result.isEmpty() && !multiple) {
   
            // Consider self references as a final pass...
            // but in the case of a dependency collection, not the very same bean itself.
            // 5.如果使用降级匹配结果还是空，则考虑自引用
            for (String candidate : candidateNames) {
   
                if (isSelfReference(beanName, candidate) &&
                    (!(descriptor instanceof MultiElementDescriptor) || !beanName.equals(candidate)) &&
                    isAutowireCandidate(candidate, fallbackDescriptor)) {
   
                    // 5.1 如果是自引用 && (descriptor不是MultiElementDescriptor || beanName不等于候选者)
                    // && candidate允许依赖注入，则将候选者添加到result中
                    addCandidateEntry(result, candidate, descriptor, requiredType);
                }
            }
        }
    }
    // 6.返回符合条件的候选者
    return result;
}