【Spring 笔记】创建 Bean 相关整理（下）

文前说明

作为码农中的一员，需要不断的学习，我工作之余将一些分析总结和学习笔记写成博客与大家一起交流，也希望采用这种方式记录自己的学习之旅。

本文仅供学习交流使用，侵权必删。
不用于商业目的，转载请注明出处。

接上一篇 【Spring 笔记】创建 Bean 相关整理（上）

2.1.4.2 MergedBeanDefinitionPostProcessor

• 用于将 merged BeanDefinition 暴露出来的回调。

public interface MergedBeanDefinitionPostProcessor extends BeanPostProcessor {
    //在bean实例化完毕后调用 可以用来修改merged BeanDefinition的一些properties 或者用来给后续回调中缓存一些meta信息使用
    //这个算是将merged BeanDefinition暴露出来的一个回调
    void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class beanType, String beanName);
}

2.1.4.3 循环依赖处理

• 循环依赖并不仅仅只是在 doCreateBean() 方法中处理，在整个加载 bean 的过程中都有涉及。

循环依赖

• 循环依赖，其实就是循环引用，两个或者两个以上的 bean 互相引用对方，最终形成一个闭环，如 A 依赖 B，B 依赖 C，C 依赖 A，是一个 死循环 的过程。
• Spring 循环依赖的场景有两种。
  • 构造器的循环依赖。
  • field 属性的循环依赖。
• 对于构造器的循环依赖，Spring 直接抛出 BeanCurrentlyInCreationException 异常表示循环依赖。
• Spring 只解决 scope 为 singleton 的循环依赖，对于 scope 为 prototype 的 bean 直接抛出 BeanCurrentlyInCreationException 异常。

2.1.4.3.1 解决循环依赖

getSingleton

• doGetBean() 方法中，首先会根据 beanName 从单例 bean 缓存中获取，如果不为空则直接返回。

// AbstractBeanFactory.java
Object sharedInstance = getSingleton(beanName);

• getSingleton() 方法，从单例缓存中获取。
  • 该方法是从三个缓存中获取，分别是 singletonObjects、earlySingletonObjects 和 singletonFactories。

// DefaultSingletonBeanRegistry.java
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 1. 从单例缓冲中加载 bean
    Object singletonObject = this.singletonObjects.get(beanName);
    // 缓存中的 bean 为空，且当前 bean 正在创建
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        // 加锁
        synchronized (this.singletonObjects) {
            // 2. 从 earlySingletonObjects 获取
            singletonObject = this.earlySingletonObjects.get(beanName);
            // earlySingletonObjects 中没有，且允许提前创建
            if (singletonObject == null && allowEarlyReference) {
                // 3. 从 singletonFactories 中获取对应的 ObjectFactory
                ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    // 获得 bean
                    singletonObject = singletonFactory.getObject();
                    // 添加 bean 到 earlySingletonObjects 中
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    // 从 singletonFactories 中移除对应的 ObjectFactory
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return singletonObject;
}

缓存	说明	缓存级别
singletonObjects	单例对象的 Cache。	一级
earlySingletonObjects	提前曝光的单例对象的 Cache。	二级
singletonFactories	单例对象工厂的 Cache。	三级

// DefaultSingletonBeanRegistry.java
/**
 * Cache of singleton objects: bean name to bean instance.
 *
 * 存放的是单例 bean 的映射。
 *
 * 对应关系为 bean name --> bean instance
 */
private final Map singletonObjects = new ConcurrentHashMap<>(256);

/**
 * Cache of singleton factories: bean name to ObjectFactory.
 *
 * 存放的是【早期】的单例 bean 的映射。
 *
 * 对应关系也是 bean name --> bean instance。
 *
 * 它与 {@link #singletonObjects} 的区别区别在，于 earlySingletonObjects 中存放的 bean 不一定是完整的。
 *
 * 从 {@link #getSingleton(String)} 方法中，中我们可以了解，bean 在创建过程中就已经加入到 earlySingletonObjects 中了，
 * 所以当在 bean 的创建过程中就可以通过 getBean() 方法获取。
 * 这个 Map 也是解决【循环依赖】的关键所在。
 **/
private final Map> singletonFactories = new HashMap<>(16);

/**
 * Cache of early singleton objects: bean name to bean instance.
 *
 * 存放的是 ObjectFactory 的映射，可以理解为创建单例 bean 的 factory 。
 *
 * 对应关系是 bean name --> ObjectFactory
 */
private final Map earlySingletonObjects = new HashMap<>(16);

• Spring 解决 singleton bean 的核心就在于提前曝光 bean 。
  • 通过 isSingletonCurrentlyInCreation() 方法判断当前 singleton bean 是否处于创建中。
  • bean 处于创建中，初始化但是还没有完成初始化，这样的过程和 Spring 解决 bean 循环依赖的理念相辅相成。
• getSingleton() 方法的调用流程。
  • 步骤 1，从一级缓存 singletonObjects 获取。
  • 步骤 2，如果没有且当前指定的 beanName 正在创建，就再从二级缓存 earlySingletonObjects 中获取。
  • 步骤 3，如果还是没有获取到且允许 singletonFactories 通过 getObject() 获取，则从三级缓存 singletonFactories 获取。如果获取到，则通过其 getObject() 方法，获取对象，并将其加入到二级缓存 earlySingletonObjects 中，并从三级缓存 singletonFactories 删除。

// DefaultSingletonBeanRegistry.java
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);

• 二级缓存存在的意义，就是缓存三级缓存中 ObjectFactory 的 getObject() 方法的执行结果，提早曝光的单例 Bean 对象。

addSingletonFactory

• 三级缓存 singletonFactories 和 二级缓存 earlySingletonObjects 中的值通过该方法增加。

// AbstractAutowireCapableBeanFactory.java
boolean earlySingletonExposure = (mbd.isSingleton() // 单例模式
        && this.allowCircularReferences // 运行循环依赖
        && isSingletonCurrentlyInCreation(beanName)); // 当前单例 bean 是否正在被创建
if (earlySingletonExposure) {
    if (logger.isTraceEnabled()) {
        logger.trace("Eagerly caching bean '" + beanName +
                "' to allow for resolving potential circular references");
    }
    // 提前将创建的 bean 实例加入到 singletonFactories 中
    // 这里是为了后期避免循环依赖
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

// DefaultSingletonBeanRegistry.java
protected void addSingletonFactory(String beanName, ObjectFactory singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized (this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) {
            this.singletonFactories.put(beanName, singletonFactory);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

• 当一个 Bean 满足三个条件时，则调用 addSingletonFactory() 方法，将它添加到缓存中，这三个条件如下。
  • 单例。
  • 运行提前暴露 bean。
  • 当前 bean 正在创建中。
• singletonFactories 是 Spring 解决 singleton bean 的诀窍所在。
  • 通过 allowEarlyReference 变量，判断是否允许从 singletonFactories 缓存中通过 getObject() 方法，拿到对象。
  • 这段代码发生在 createBeanInstance() 方法之后，此时 bean 已经被创建，但是它还没有进行属性填充和初始化，但对于其他依赖它的对象而言已经足够（可以根据对象引用定位到堆中对象），能够被识别出来，所以 Spring 在这个时候，选择将该对象 提前曝光。

addSingleton

• 类 DefaultSingletonBeanRegistry 中的 addSingleton() 方法，将 bean 添加至一级缓存，同时从二级、三级缓存中删除。

// DefaultSingletonBeanRegistry.java
protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
        this.singletonObjects.put(beanName, singletonObject);
        this.singletonFactories.remove(beanName);
        this.earlySingletonObjects.remove(beanName);
        this.registeredSingletons.add(beanName);
    }
}

---

• Spring 解决循环依赖的方案如下。
  • Spring 在创建 bean 的时候并不是等它完全完成，而是在创建过程中将创建中的 bean 的 ObjectFactory 提前曝光（即加入到 singletonFactories 缓存中）。一旦下一个 bean 创建的时候需要依赖 bean，则直接使用 ObjectFactory 的 getObject() 方法获取。
• 循环依赖 Spring 解决的过程如下。
  • 首先 A 完成初始化第一步并将自己提前曝光出来（通过 ObjectFactory 将自己提前曝光），在初始化的时候，发现依赖对象 B，尝试 get(B)，发现 B 没有被创建。
  • 然后开始 B 的创建流程，在 B 初始化的时候，发现依赖 C，C 没有被创建。
  • 开始 C 初始化进程，初始化过程中发现依赖 A，尝试 get(A)，由于 A 已经添加至缓存中（一般都是添加至三级缓存 singletonFactories），通过 ObjectFactory#getObject() 方法获得 A 对象，C 顺利完成初始化，然后将自己添加到一级缓存中。
  • 然后 B 拿到了 C 完成初始化，A 拿到 B 完成初始化。

2.1.4.4 属性填充

• 通过 populateBean() 方法，进行属性填充。

2.1.4.4.1 populateBean

// AbstractAutowireCapableBeanFactory.java
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    // 没有实例化对象
    if (bw == null) {
        // 有属性，则抛出 BeanCreationException 异常
        if (mbd.hasPropertyValues()) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
            // 没有属性，直接 return 返回
        } else {
            // Skip property population phase for null instance.
            return;
        }
    }

    // 1. 在设置属性之前给 InstantiationAwareBeanPostProcessors 最后一次改变 bean 的机会
    // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
    // state of the bean before properties are set. This can be used, for example,
    // to support styles of field injection.
    boolean continueWithPropertyPopulation = true;
    if (!mbd.isSynthetic()  // bean 不是"合成"的，即未由应用程序本身定义
            && hasInstantiationAwareBeanPostProcessors()) { // 是否持有 InstantiationAwareBeanPostProcessor
        // 迭代所有的 BeanPostProcessors
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) { // 如果为 InstantiationAwareBeanPostProcessor
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                // 返回值为是否继续填充 bean
                // postProcessAfterInstantiation：如果应该在 bean上面设置属性则返回 true，否则返回 false
                // 一般情况下，应该是返回true 。
                // 返回 false 的话，将会阻止在此 Bean 实例上调用任何后续的 InstantiationAwareBeanPostProcessor 实例。
                if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                    continueWithPropertyPopulation = false;
                    break;
                }
            }
        }
    }
    // 如果后续处理器发出停止填充命令，则终止后续操作
    if (!continueWithPropertyPopulation) {
        return;
    }

    // bean 的属性值
    PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

    // 2. 自动注入
    if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
        // 将 PropertyValues 封装成 MutablePropertyValues 对象
        // MutablePropertyValues 允许对属性进行简单的操作，并提供构造函数以支持Map的深度复制和构造。
        MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
        // Add property values based on autowire by name if applicable.
        // 根据名称自动注入
        if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
            autowireByName(beanName, mbd, bw, newPvs);
        }
        // Add property values based on autowire by type if applicable.
        // 根据类型自动注入
        if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
            autowireByType(beanName, mbd, bw, newPvs);
        }
        pvs = newPvs;
    }

    // 是否已经注册了 InstantiationAwareBeanPostProcessors
    boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
    // 是否需要进行【依赖检查】
    boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

    // 3. BeanPostProcessor 处理
    PropertyDescriptor[] filteredPds = null;
    if (hasInstAwareBpps) {
        if (pvs == null) {
            pvs = mbd.getPropertyValues();
        }
        // 遍历 BeanPostProcessor 数组
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                // 对所有需要依赖检查的属性进行后处理
                PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
                if (pvsToUse == null) {
                    // 从 bw 对象中提取 PropertyDescriptor 结果集
                    // PropertyDescriptor：可以通过一对存取方法提取一个属性
                    if (filteredPds == null) {
                        filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                    }
                    pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                    if (pvsToUse == null) {
                        return;
                    }
                }
                pvs = pvsToUse;
            }
        }
    }
    
    // 4. 依赖检查
    if (needsDepCheck) {
        if (filteredPds == null) {
            filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
        }
        // 依赖检查，对应 depends-on 属性
        checkDependencies(beanName, mbd, filteredPds, pvs);
    }

    // 5. 将属性应用到 bean 中
    if (pvs != null) {
        applyPropertyValues(beanName, mbd, bw, pvs);
    }
}

• 方法的调用流程。
  • 步骤 1，根据 hasInstantiationAwareBeanPostProcessors 属性判断，是否需要在注入属性之前给 InstantiationAwareBeanPostProcessors 最后一次改变 bean 的机会。此过程可以控制 Spring 是否继续进行属性填充。
    • 统一存入到 PropertyValues 中，PropertyValues 用于描述 bean 的属性。
  • 步骤 2，根据注入类型AbstractBeanDefinition#getResolvedAutowireMode() 方法的返回值的不同来判断。
    • 根据名称自动注入（autowireByName()）。
    • 根据类型自动注入（autowireByType()）。
  • 步骤 3，进行 BeanPostProcessor 处理。
  • 步骤 4，依赖检测。
  • 步骤 5，将所有 PropertyValues 中的属性，填充到 BeanWrapper 中。

2.1.4.4.1.1 自动注入

• Spring 会根据注入类型（byName / byType）的不同，调用不同的方法来注入属性值。

// AbstractBeanDefinition.java
/**
 * 注入模式
 */
private int autowireMode = AUTOWIRE_NO;

public int getResolvedAutowireMode() {
    if (this.autowireMode == AUTOWIRE_AUTODETECT) { // 自动检测模式，获得对应的检测模式
        // Work out whether to apply setter autowiring or constructor autowiring.
        // If it has a no-arg constructor it's deemed to be setter autowiring,
        // otherwise we'll try constructor autowiring.
        Constructor[] constructors = getBeanClass().getConstructors();
        for (Constructor constructor : constructors) {
            if (constructor.getParameterCount() == 0) {
                return AUTOWIRE_BY_TYPE;
            }
        }
        return AUTOWIRE_CONSTRUCTOR;
    } else {
        return this.autowireMode;
    }
}

autowireByName

• 根据 属性名称，完成自动依赖注入。

// AbstractAutowireCapableBeanFactory.java
protected void autowireByName(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
    // 1. 对 Bean 对象中非简单属性
    String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
    // 遍历 propertyName 数组
    for (String propertyName : propertyNames) {
        // 如果容器中包含指定名称的 bean，则将该 bean 注入到 bean中
        if (containsBean(propertyName)) {
            // 递归初始化相关 bean
            Object bean = getBean(propertyName);
            // 为指定名称的属性赋予属性值
            pvs.add(propertyName, bean);
            // 2. 属性依赖注入
            registerDependentBean(propertyName, beanName);
            if (logger.isTraceEnabled()) {
                logger.trace("Added autowiring by name from bean name '" + beanName +
                        "' via property '" + propertyName + "' to bean named '" + propertyName + "'");
            }
        } else {
            if (logger.isTraceEnabled()) {
                logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
                        "' by name: no matching bean found");
            }
        }
    }
}

// AbstractAutowireCapableBeanFactory.java
protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) {
    // 创建 result 集合
    Set result = new TreeSet<>();
    PropertyValues pvs = mbd.getPropertyValues();
    // 遍历 PropertyDescriptor 数组
    PropertyDescriptor[] pds = bw.getPropertyDescriptors();
    for (PropertyDescriptor pd : pds) {
        if (pd.getWriteMethod() != null // 有可写方法
                && !isExcludedFromDependencyCheck(pd) // 依赖检测中没有被忽略
                && !pvs.contains(pd.getName()) // pvs 不包含该属性名
                && !BeanUtils.isSimpleProperty(pd.getPropertyType())) { // 不是简单属性类型
            result.add(pd.getName()); // 添加到 result 中
        }
    }
    return StringUtils.toStringArray(result);
}

• 方法的调用流程。
  • 步骤 1，获取该 bean 的 非简单属性（类型为对象类型的属性，但 8 个原始类型，String 类型 ，Number 类型、Date 类型、URL 类型、URI 类型等都会被忽略）。
    • 过滤条件 有可写方法、依赖检测中没有被忽略、不是简单属性类型。
    • 过滤结果 这里获取的就是需要依赖注入的属性。
  • 步骤 2，获取需要依赖注入的属性后，通过迭代、递归的方式初始化相关的 bean ，然后调用 registerDependentBean() 方法，完成注册依赖。

// DefaultSingletonBeanRegistry.java
/**
 * Map between dependent bean names: bean name to Set of dependent bean names.
 *
 * 保存的是依赖 beanName 之间的映射关系：beanName - > 依赖 beanName 的集合
 */
private final Map> dependentBeanMap = new ConcurrentHashMap<>(64);

/**
 * Map between depending bean names: bean name to Set of bean names for the bean's dependencies.
 *
 * 保存的是依赖 beanName 之间的映射关系：依赖 beanName - > beanName 的集合
 */
private final Map> dependenciesForBeanMap = new ConcurrentHashMap<>(64);

public void registerDependentBean(String beanName, String dependentBeanName) {
    // 获取 beanName
    String canonicalName = canonicalName(beanName);
    // 添加 > 到 dependentBeanMap 中
    synchronized (this.dependentBeanMap) {
        Set dependentBeans =
                this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
        if (!dependentBeans.add(dependentBeanName)) {
            return;
        }
    }
    // 添加 > 到 dependenciesForBeanMap 中
    synchronized (this.dependenciesForBeanMap) {
        Set dependenciesForBean =
                this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
        dependenciesForBean.add(canonicalName);
    }
}

autowireByType

• 根据 属性类型，完成自动依赖注入。

// AbstractAutowireCapableBeanFactory.java
protected void autowireByType(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

    // 获取 TypeConverter 实例
    // 使用自定义的 TypeConverter，用于取代默认的 PropertyEditor 机制
    TypeConverter converter = getCustomTypeConverter();
    if (converter == null) {
        converter = bw;
    }

    Set autowiredBeanNames = new LinkedHashSet<>(4);
    // 获取非简单属性
    String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
    // 遍历 propertyName 数组
    for (String propertyName : propertyNames) {
        try {
            // 获取 PropertyDescriptor 实例
            PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
            // Don't try autowiring by type for type Object: never makes sense,
            // even if it technically is a unsatisfied, non-simple property.
            // 不要尝试按类型
            if (Object.class != pd.getPropertyType()) {
                // 探测指定属性的 set 方法
                MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
                // Do not allow eager init for type matching in case of a prioritized post-processor.
                boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance());
                DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
                // 解析指定 beanName 的属性所匹配的值，并把解析到的属性名称存储在 autowiredBeanNames 中
                // 当属性存在过个封装 bean 时将会找到所有匹配的 bean 并将其注入
                Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
                if (autowiredArgument != null) {
                    pvs.add(propertyName, autowiredArgument);
                }
                // 遍历 autowiredBeanName 数组
                for (String autowiredBeanName : autowiredBeanNames) {
                    // 属性依赖注入
                    registerDependentBean(autowiredBeanName, beanName);
                    if (logger.isTraceEnabled()) {
                        logger.trace("Autowiring by type from bean name '" + beanName + "' via property '" +
                                propertyName + "' to bean named '" + autowiredBeanName + "'");
                    }
                }
                // 清空 autowiredBeanName 数组
                autowiredBeanNames.clear();
            }
        } catch (BeansException ex) {
            throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
        }
    }
}

• 与根据名称自动注入类似，都是找到需要依赖注入的属性，然后通过迭代的方式寻找所匹配的 bean，最后调用 registerDependentBean() 方法，注册依赖。

resolveDependency

// DefaultListableBeanFactory.java

@Nullable
private static Class javaxInjectProviderClass;

static {
    try {
        javaxInjectProviderClass = ClassUtils.forName("javax.inject.Provider", DefaultListableBeanFactory.class.getClassLoader());
    } catch (ClassNotFoundException ex) {
        // JSR-330 API not available - Provider interface simply not supported then.
        javaxInjectProviderClass = null;
    }
}

@Override
@Nullable
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
        @Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
    // 初始化参数名称发现器，该方法并不会在这个时候尝试检索参数名称
    // getParameterNameDiscoverer 返回 parameterNameDiscoverer 实例，parameterNameDiscoverer 方法参数名称的解析器
    descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
    // 依赖类型为 Optional 类型
    if (Optional.class == descriptor.getDependencyType()) {
        return createOptionalDependency(descriptor, requestingBeanName);
    // 依赖类型为ObjectFactory、ObjectProvider
    } else if (ObjectFactory.class == descriptor.getDependencyType() ||
            ObjectProvider.class == descriptor.getDependencyType()) {
        return new DependencyObjectProvider(descriptor, requestingBeanName);
    // javaxInjectProviderClass 类注入的特殊处理
    } else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
        return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
    } else {
        // 为实际依赖关系目标的延迟解析构建代理
        // 默认实现返回 null
        Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, requestingBeanName);
        if (result == null) {
            // 通用处理逻辑
            result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
        }
        return result;
    }
}

// DefaultListableBeanFactory.java
@Nullable
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
    @Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
    // 注入点
    InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
    try {
        // 针对给定的工厂给定一个快捷实现的方式，例如考虑一些预先解析的信息
        // 在进入所有bean的常规类型匹配算法之前，解析算法将首先尝试通过此方法解析快捷方式。
        // 子类可以覆盖此方法
        Object shortcut = descriptor.resolveShortcut(this);
        if (shortcut != null) {
            // 返回快捷的解析信息
            return shortcut;
        }
        // 依赖的类型
        Class type = descriptor.getDependencyType();
        // 支持 Spring 的注解 @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());
            return (descriptor.getField() != null ?
                    converter.convertIfNecessary(value, type, descriptor.getField()) :
                    converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
        }
        // 解析复合 bean，其实就是对 bean 的属性进行解析
        // 包括：数组、Collection 、Map 类型
        Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
        if (multipleBeans != null) {
            return multipleBeans;
        }
        // 查找与类型相匹配的 bean
        // 返回值构成为：key = 匹配的 beanName，value = beanName 对应的实例化 bean
        Map matchingBeans = findAutowireCandidates(beanName, type, descriptor);
        // 没有找到，检验 @autowire  的 require 是否为 true
        if (matchingBeans.isEmpty()) {
            // 如果 @autowire 的 require 属性为 true ，但是没有找到相应的匹配项，则抛出异常
            if (isRequired(descriptor)) {
                raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
            }
            return null;
        }
        String autowiredBeanName;
        Object instanceCandidate;
        if (matchingBeans.size() > 1) {
            // 确认给定 bean autowire 的候选者
            // 按照 @Primary 和 @Priority 的顺序
            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).
                    // 在可选的Collection / Map的情况下，默默地忽略一个非唯一的情况：可能它是一个多个常规bean的空集合
                    return null;
                }
            }
            instanceCandidate = matchingBeans.get(autowiredBeanName);
        } else {
            // We have exactly one match.
            Map.Entry entry = matchingBeans.entrySet().iterator().next();
            autowiredBeanName = entry.getKey();
            instanceCandidate = entry.getValue();
        }
        if (autowiredBeanNames != null) {
            autowiredBeanNames.add(autowiredBeanName);
        }
        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 {
        ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
    }
}

2.1.4.4.1.2 属性填充

• 将获取的属性封装在 PropertyValues 的实例对象 pvs 中，应用到已经实例化的 bean 中（完成属性转换）。

applyPropertyValues

// AbstractAutowireCapableBeanFactory.java
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
    if (pvs.isEmpty()) {
        return;
    }

    // 设置 BeanWrapperImpl 的 SecurityContext 属性
    if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
        ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
    }

    // MutablePropertyValues 类型属性
    MutablePropertyValues mpvs = null;

    // 原始类型
    List original;
    // 获得 original
    if (pvs instanceof MutablePropertyValues) {
        mpvs = (MutablePropertyValues) pvs;
        // 属性值已经转换
        if (mpvs.isConverted()) {
            // Shortcut: use the pre-converted values as-is.
            try {
                // 为实例化对象设置属性值 ，依赖注入真真正正地实现在此！！！！！
                bw.setPropertyValues(mpvs);
                return;
            } catch (BeansException ex) {
                throw new BeanCreationException(
                        mbd.getResourceDescription(), beanName, "Error setting property values", ex);
            }
        }
        original = mpvs.getPropertyValueList();
    } else {
        // 如果 pvs 不是 MutablePropertyValues 类型，则直接使用原始类型
        original = Arrays.asList(pvs.getPropertyValues());
    }

    // 获取 TypeConverter = 获取用户自定义的类型转换
    TypeConverter converter = getCustomTypeConverter();
    if (converter == null) {
        converter = bw;
    }

    // 获取对应的解析器
    BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

    // Create a deep copy, resolving any references for values.
    List deepCopy = new ArrayList<>(original.size());
    boolean resolveNecessary = false;
    // 遍历属性，将属性转换为对应类的对应属性的类型
    for (PropertyValue pv : original) {
        // 属性值不需要转换
        if (pv.isConverted()) {
            deepCopy.add(pv);
        // 属性值需要转换
        } else {
            String propertyName = pv.getName();
            Object originalValue = pv.getValue(); // 原始的属性值，即转换之前的属性值
            Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue); // 转换属性值，例如将引用转换为IoC容器中实例化对象引用 ！！！！！ 对属性值的解析！！
            Object convertedValue = resolvedValue; // 转换之后的属性值
            boolean convertible = bw.isWritableProperty(propertyName) &&
                    !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);  // 属性值是否可以转换
            // 使用用户自定义的类型转换器转换属性值
            if (convertible) {
                convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
            }
            // Possibly store converted value in merged bean definition,
            // in order to avoid re-conversion for every created bean instance.
            // 存储转换后的属性值，避免每次属性注入时的转换工作
            if (resolvedValue == originalValue) {
                if (convertible) {
                    // 设置属性转换之后的值
                    pv.setConvertedValue(convertedValue);
                }
                deepCopy.add(pv);
            // 属性是可转换的，且属性原始值是字符串类型，且属性的原始类型值不是
            // 动态生成的字符串，且属性的原始值不是集合或者数组类型
            } else if (convertible && originalValue instanceof TypedStringValue &&
                    !((TypedStringValue) originalValue).isDynamic() &&
                    !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
                pv.setConvertedValue(convertedValue);
                deepCopy.add(pv);
            } else {
                resolveNecessary = true;
                // 重新封装属性的值
                deepCopy.add(new PropertyValue(pv, convertedValue));
            }
        }
    }
    // 标记属性值已经转换过
    if (mpvs != null && !resolveNecessary) {
        mpvs.setConverted();
    }

    // Set our (possibly massaged) deep copy.
    // 进行属性依赖注入，依赖注入的真真正正实现依赖的注入方法在此！！！
    try {
        bw.setPropertyValues(new MutablePropertyValues(deepCopy));
    } catch (BeansException ex) {
        throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Error setting property values", ex);
    }
}

• 属性值类型不需要转换时，不需要解析属性值，直接准备进行依赖注入。
• 属性值需要进行类型转换时，如对其他对象的引用等，首先需要解析属性值（resolveValueIfNecessary()），然后对解析后的属性值进行依赖注入。

resolveValueIfNecessary

//解析属性值，对注入类型进行转换 
public Object resolveValueIfNecessary(Object argName, Object value) {
    //对引用类型的属性进行解析
    if(value instanceof RuntimeBeanReference) {
        RuntimeBeanReference ref = (RuntimeBeanReference)value;
        //调用引用类型属性的解析方法  
        return this.resolveReference(argName, ref);
    } else if(value instanceof RuntimeBeanNameReference) { //对属性值是引用容器中另一个Bean名称的解析  
        String refName = ((RuntimeBeanNameReference)value).getBeanName();
        refName = String.valueOf(this.doEvaluate(refName));
         //从容器中获取指定名称的Bean 
        if(!this.beanFactory.containsBean(refName)) {
            throw new BeanDefinitionStoreException("Invalid bean name '" + refName + "' in bean reference for " + argName);
        } else {
            return refName;
        }
    } else if(value instanceof BeanDefinitionHolder) { //对Bean类型属性的解析，主要是Bean中的内部类  
        BeanDefinitionHolder bdHolder = (BeanDefinitionHolder)value;
        return this.resolveInnerBean(argName, bdHolder.getBeanName(), bdHolder.getBeanDefinition());
    } else if(value instanceof BeanDefinition) {
        BeanDefinition bd = (BeanDefinition)value;
        String innerBeanName = "(inner bean)#" + ObjectUtils.getIdentityHexString(bd);
        return this.resolveInnerBean(argName, innerBeanName, bd);
    } else if(value instanceof ManagedArray) {//对集合数组类型的属性解析 
        ManagedArray array = (ManagedArray)value;
          //获取数组的类型  
        Class elementType = array.resolvedElementType;
        if(elementType == null) {
        //获取数组元素的类型  
            String elementTypeName = array.getElementTypeName();
            if(StringUtils.hasText(elementTypeName)) {
                try {
                //使用反射机制创建指定类型的对象  
                    elementType = ClassUtils.forName(elementTypeName, this.beanFactory.getBeanClassLoader());
                    array.resolvedElementType = elementType;
                } catch (Throwable var9) {
                    throw new BeanCreationException(this.beanDefinition.getResourceDescription(), this.beanName, "Error resolving array type for " + argName, var9);
                }
            } else {
            //没有获取到数组的类型，也没有获取到数组元素的类型，则直接设置数  
           //组的类型为Object 
                elementType = Object.class;
            }
        }
         //创建指定类型的数组  
        return this.resolveManagedArray(argName, (List)value, elementType);
    } else if(value instanceof ManagedList) {//解析list类型的属性值  
        return this.resolveManagedList(argName, (List)value);
    } else if(value instanceof ManagedSet) { //解析set类型的属性值 
        return this.resolveManagedSet(argName, (Set)value);
    } else if(value instanceof ManagedMap) { //解析map类型的属性值 
        return this.resolveManagedMap(argName, (Map)value);
    } else if(value instanceof ManagedProperties) { //解析props类型的属性值，props其实就是key和value均为字符串的map  
        Properties original = (Properties)value;
        //创建一个拷贝，用于作为解析后的返回值  
        Properties copy = new Properties();

        Object propKey;
        Object propValue;
        for(Iterator var19 = original.entrySet().iterator(); var19.hasNext(); copy.put(propKey, propValue)) {
            Entry propEntry = (Entry)var19.next();
            propKey = propEntry.getKey();
            propValue = propEntry.getValue();
            if(propKey instanceof TypedStringValue) {
                propKey = this.evaluate((TypedStringValue)propKey);
            }

            if(propValue instanceof TypedStringValue) {
                propValue = this.evaluate((TypedStringValue)propValue);
            }
        }

        return copy;
    } else if(value instanceof TypedStringValue) {//解析字符串类型的属性值  
        TypedStringValue typedStringValue = (TypedStringValue)value;
        Object valueObject = this.evaluate(typedStringValue);

        try {
        //获取属性的目标类型  
            Class resolvedTargetType = this.resolveTargetType(typedStringValue);
             //对目标类型的属性进行解析，递归调用 。没有获取到属性的目标对象，则按Object类型返回  
            return resolvedTargetType != null?this.typeConverter.convertIfNecessary(valueObject, resolvedTargetType):valueObject;
        } catch (Throwable var10) {
            throw new BeanCreationException(this.beanDefinition.getResourceDescription(), this.beanName, "Error converting typed String value for " + argName, var10);
        }
    } else {
        return this.evaluate(value);
    }
}

resolveReference

• 解析引用类型。

//实现属性依赖注入功能
private void setPropertyValue(BeanWrapperImpl.PropertyTokenHolder tokens, PropertyValue pv) throws BeansException {
        //PropertyTokenHolder主要保存属性的名称、路径，以及集合的size等信息
    String propertyName = tokens.canonicalName;
    String actualName = tokens.actualName;
    Object propValue;
    //keys是用来保存集合类型属性的size  
    if(tokens.keys != null) {
     //将属性信息拷贝
        BeanWrapperImpl.PropertyTokenHolder getterTokens = new BeanWrapperImpl.PropertyTokenHolder(null);
        getterTokens.canonicalName = tokens.canonicalName;
        getterTokens.actualName = tokens.actualName;
        getterTokens.keys = new String[tokens.keys.length - 1];
        System.arraycopy(tokens.keys, 0, getterTokens.keys, 0, tokens.keys.length - 1);

        try {
         //获取属性值，该方法内部使用JDK的内省( Introspector)机制，调用属性//的getter(readerMethod)方法，获取属性的值  
            propValue = this.getPropertyValue(getterTokens);
        } catch (NotReadablePropertyException var21) {
            throw new NotWritablePropertyException(this.getRootClass(), this.nestedPath + propertyName, "Cannot access indexed value in property referenced in indexed property path '" + propertyName + "'", var21);
        }
        //获取集合类型属性的长度  
        String key = tokens.keys[tokens.keys.length - 1];
        if(propValue == null) {
            if(!this.isAutoGrowNestedPaths()) {
                throw new NullValueInNestedPathException(this.getRootClass(), this.nestedPath + propertyName, "Cannot access indexed value in property referenced in indexed property path '" + propertyName + "': returned null");
            }

            int lastKeyIndex = tokens.canonicalName.lastIndexOf(91);
            getterTokens.canonicalName = tokens.canonicalName.substring(0, lastKeyIndex);
            propValue = this.setDefaultValue(getterTokens);
        }

        Object convertedValue;
        Object newArray;
        Class requiredType;
        PropertyDescriptor pd;
        //注入array类型的属性值 
        if(propValue.getClass().isArray()) {
        //获取属性的描述符  
            pd = this.getCachedIntrospectionResults().getPropertyDescriptor(actualName);
             //获取数组的类型 
            requiredType = propValue.getClass().getComponentType();
            //获取数组的长度  
            int arrayIndex = Integer.parseInt(key);
            Object oldValue = null;

            try {
            //获取数组以前初始化的值  
                if(this.isExtractOldValueForEditor() && arrayIndex < Array.getLength(propValue)) {
                    oldValue = Array.get(propValue, arrayIndex);
                }
            //将属性的值赋值给数组中的元素
                convertedValue = this.convertIfNecessary(propertyName, oldValue, pv.getValue(), requiredType, TypeDescriptor.nested(this.property(pd), tokens.keys.length));
                int length = Array.getLength(propValue);
                if(arrayIndex >= length && arrayIndex < this.autoGrowCollectionLimit) {
                    Class componentType = propValue.getClass().getComponentType();
                    newArray = Array.newInstance(componentType, arrayIndex + 1);
                    System.arraycopy(propValue, 0, newArray, 0, length);
                    this.setPropertyValue(actualName, newArray);
                    propValue = this.getPropertyValue(actualName);
                }

                Array.set(propValue, arrayIndex, convertedValue);
            } catch (IndexOutOfBoundsException var20) {
                throw new InvalidPropertyException(this.getRootClass(), this.nestedPath + propertyName, "Invalid array index in property path '" + propertyName + "'", var20);
            }
        } else {
            Object convertedValue;
            if(propValue instanceof List) {//注入list类型的属性值
                pd = this.getCachedIntrospectionResults().getPropertyDescriptor(actualName);
                 //获取list集合的类型 
                requiredType = GenericCollectionTypeResolver.getCollectionReturnType(pd.getReadMethod(), tokens.keys.length);
                List