【spring源码分析】IOC容器初始化（十一）

前言：前面分析了doCreateBean中的createBeanInstance函数，接下来分析其剩余流程。

---

首先贴上doCreateBean函数：

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

        // Instantiate the bean.
        // BeanWrapper是对Bean的包装，其接口中所定义的功能很简单包括设置获取被包装的对象、获取被包装bean的属性描述器
        BeanWrapper instanceWrapper = null;
        // 如果是单例模型，则从未完成的FactoryBean缓存中删除
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        // 使用合适的实例化策略来创建新的实例：工厂方法、构造函数自动注入、简单初始化
        if (instanceWrapper == null) {
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        // 包装的对象实例
        final Object bean = instanceWrapper.getWrappedInstance();
        // 包装的实例对象的类型
        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 {
                    // 后置处理修改BeanDefinition
                    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.
        // 解决单例模式的循环依赖         // 单例模式               运行循环依赖
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));// 当前单例bean是否正在被创建
        if (earlySingletonExposure) {
            if (logger.isDebugEnabled()) {
                logger.debug("Eagerly caching bean '" + beanName +
                                     "' to allow for resolving potential circular references");
            }
            // 提前将创建的bean实例加入到singletonFactories中
            // 为了后期避免循环依赖
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }

        // Initialize the bean instance.
        // 开始初始化bean实例对象
        Object exposedObject = bean;
        try {
            // 对bean进行填充，主要是进行属性注入，其中，可能存在依赖于其他bean的属性，则会递归初始化依赖bean
            populateBean(beanName, mbd, instanceWrapper);
            // 进行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) {
            // 获取earlySingletonReference
            Object earlySingletonReference = getSingleton(beanName, false);
            // 只有在循环依赖的情况下，earlySingletonReference才不会为null
            if (earlySingletonReference != null) {
                // 如果exposedObject没有在初始化方法中改变，也就是没有被增强
                if (exposedObject == bean) {
                    exposedObject = earlySingletonReference;
                } else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { // 处理依赖
                    String[] dependentBeans = getDependentBeans(beanName);
                    Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
                    for (String dependentBean : dependentBeans) {
                        if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                            actualDependentBeans.add(dependentBean);
                        }
                    }
                    if (!actualDependentBeans.isEmpty()) {
                        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 " +
                                                                           "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
                    }
                }
            }
        }

        // Register bean as disposable.
        try {
            // 注册bean
            registerDisposableBeanIfNecessary(beanName, bean, mbd);
        } catch (BeanDefinitionValidationException ex) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
        }

        return exposedObject;
    }

分析：

• 首先判断是否有后置处理器，如果存在在先执行后置处理器(applyMergedBeanDefinitionPostProcessors)。
• 接下来是为处理循环依赖做前期准备，这部分后面会单独进行分析。
• 开始初始化bean对象，首先对bean进行填充，然后进行初始化。
• 处理循环依赖。
• 注册bean对象。

AbstractAutowireCapableBeanFactory#populateBean

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

        // 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.
        // 在设置属性之前给InstantiationAwareBeanPostProcessors最后一次改变bean的机会
        boolean continueWithPropertyPopulation = true;

        // bean不是合成的，即未由应用程序本身定义
        // 是否持有InstantiationAwareBeanPostProcessors
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            // 迭代所有的BeanPostProcessor
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                // 如果为InstantiationAwareBeanPostProcessors
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    // 返回值为是否继续填充bean
                    // postProcessAfterInstantiation:如果应该在bean上面设置属性，则返回true，否则返回false
                    // 一般情况下，应该返回true
                    // 返回false的话，将会阻止此bean实例上调用任何后续的InstantiationAwareBeanPostProcessors实例
                    if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                        continueWithPropertyPopulation = false;
                        break;
                    }
                }
            }
        }

        // 如果后续处理器发出停止填充命令，则终止后续操作
        if (!continueWithPropertyPopulation) {
            return;
        }

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

        // 自动注入
        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
                mbd.getResolvedAutowireMode() == RootBeanDefinition.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() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
                autowireByName(beanName, mbd, bw, newPvs);
            }

            // 根据属性类型自动注入
            // Add property values based on autowire by type if applicable.
            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
                autowireByType(beanName, mbd, bw, newPvs);
            }

            pvs = newPvs;
        }

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

        // BeanPostProcessor处理
        if (hasInstAwareBpps || needsDepCheck) {
            if (pvs == null) {
                pvs = mbd.getPropertyValues();
            }
            // 从BeanWrapper中提取PropertyDescriptor结果集
            PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
            if (hasInstAwareBpps) {
                for (BeanPostProcessor bp : getBeanPostProcessors()) {
                    if (bp instanceof InstantiationAwareBeanPostProcessor) {
                        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                        pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                        if (pvs == null) {
                            return;
                        }
                    }
                }
            }
            // 依赖检查
            if (needsDepCheck) {
                checkDependencies(beanName, mbd, filteredPds, pvs);
            }
        }

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

分析：

该函数的主要作用是将BeanDefinition中的属性值赋值给BeanWrapper对象。

• 如果BeanWrapper为null，并且有属性值，则抛出异常，否则直接返回。
• 如果存在PostProcessor，则在这里给其最后一次改变bean的机会。
• 如果在后置处理器组织bean实例继续初始化，则直接返回。
• 获取bean的PropertyValues属性，根据不同情况进行属性注入：根据属性名称或根据属性类型。
• 再次进行后置处理，这里主要对属性值进行操作。
• 进行依赖检查。
• 调用applyPropertyValues方法将属性填充到BeanWrapper中。

自动注入

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

AbstractAutowireCapableBeanFactory#autowireByName

protected void autowireByName(
            String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
        // 获取bean对象中的非简单属性
        // 非简单属性：类型为对象类型的属性，但这里并不是将所有的对象类型都会找到，比如8个原始类型，String类型、Number类型、Date类型等会被忽略
        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);
                // 属性依赖注入
                registerDependentBean(propertyName, beanName);
                if (logger.isDebugEnabled()) {
                    logger.debug("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");
                }
            }
        }
    }

分析：

该函数为根据属性名称完成自动依赖注入。

• 首先获取bean对象的非简单属性。非简单属性：类型为对象类型的属性，但并不是将所有的对象类型都会找到，比如8个原始类型：String、Number等类型都会被忽略。
• 循环遍历属性名，然后为指定名称的属性赋值。
• 然后进行属性依赖注入。

AbstractAutowireCapableBeanFactory#unsatisfiedNonSimpleProperties

protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) {
        // 创建结果集
        Set<String> 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);
    }

分析：

过滤条件：有可写方法、依赖检测中没有被忽略、pvs中不包含该属性名、不为简单类型。

过滤结果：获取需要依赖注入的属性。

BeanUtils#isSimpleValueType

    public static boolean isSimpleValueType(Class<?> clazz) {
        return (ClassUtils.isPrimitiveOrWrapper(clazz) ||
                Enum.class.isAssignableFrom(clazz) ||
                CharSequence.class.isAssignableFrom(clazz) ||
                Number.class.isAssignableFrom(clazz) ||
                Date.class.isAssignableFrom(clazz) ||
                URI.class == clazz || URL.class == clazz ||
                Locale.class == clazz || Class.class == clazz);
    }

分析：

该方法就是获取简单类型的对象。

MutablePropertyValues#add

   /**
     * 存储属性对象  PropertyValue：name->value
     */
private final List<PropertyValue> propertyValueList;

public MutablePropertyValues add(String propertyName, @Nullable Object propertyValue) {
        addPropertyValue(new PropertyValue(propertyName, propertyValue));
        return this;
    }

public MutablePropertyValues addPropertyValue(PropertyValue pv) {
        for (int i = 0; i < this.propertyValueList.size(); i++) {
            PropertyValue currentPv = this.propertyValueList.get(i);
            if (currentPv.getName().equals(pv.getName())) {
                pv = mergeIfRequired(pv, currentPv);
                setPropertyValueAt(pv, i);
                return this;
            }
        }
        this.propertyValueList.add(pv);
        return this;
    }

分析：

属性注入逻辑简单，就是通过propertyName进行对比，从这里也可以发现，如果存在相同的属性名会发生覆盖的情况，以最后的属性为主。

AbstractAutowireCapableBeanFactory#autowireByType

protected void autowireByType(
            String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

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

        Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
        // 获取非简单属性
        String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
        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);
                    }
                    // 遍历autowiredBeanNames数组
                    for (String autowiredBeanName : autowiredBeanNames) {
                        // 属性依赖注入
                        registerDependentBean(autowiredBeanName, beanName);
                        if (logger.isDebugEnabled()) {
                            logger.debug("Autowiring by type from bean name '" + beanName + "' via property '" +
                                                 propertyName + "' to bean named '" + autowiredBeanName + "'");
                        }
                    }
                    // 清空autowiredBeanNames数组
                    autowiredBeanNames.clear();
                }
            } catch (BeansException ex) {
                throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
            }
        }
    }

分析：

该方法根据属性类型完成自动注入依赖。

整体流程与根据属性名称自动注入差不多：

• 获取非简单属性名集合，开始遍历，过滤属于对象型的属性。
• 通过resolveDependency解析属性，找出正确的匹配（核心函数）。
• 属性注入，并进行依赖处理。

DefaultListableBeanFactory#resolveDependency

public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
                                    @Nullable Set<String> 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;
        }
    }

分析：

这里关注通用处理doResolveDependency：

// DefaultListableBeanFactory
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
                                      @Nullable Set<String> 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());
                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()));
                }
            }

            // 解析复合bean，其实就是对bean的属性进行解析
            // 包括：数组、Collection、Map类型
            Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
            if (multipleBeans != null) {
                return multipleBeans;
            }

            // 查找与类型相匹配的bean
            // 返回值构成：key=匹配的beanName，value=beanName对应的实例化bean
            Map<String, Object> 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).
                        return null;
                    }
                }
                instanceCandidate = matchingBeans.get(autowiredBeanName);
            } else {
                // We have exactly one match.
                Map.Entry<String, Object> 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);
        }
    }

分析：

• 首先尝试从工厂的快捷实现方式进行解析，如果存在，则直接返回。
• 支持@Value注解的解析。
• 解析复合Bean，数组、Map类型的属性。
• 然后找出类型相匹配的属性。

整体逻辑其实不复杂，可debug进行查看。

到此属性注入已分析得差不多了，接下来是对BeanPostProcessor的处理，后面再分析。这里先看applyPropertyValues函数，将属性注入到bean中。

AbstractAutowireCapableBeanFactory#applyPropertyValues

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<PropertyValue> 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<PropertyValue> 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);
        }
    }

分析：

上面的属性注入只是完成了属性的获取，将获取的属性封装在PropertyValues对象中，并没有应用到已经实例化的bean上，而applyPropertyValues方法就是完成这一操作的。

该函数主要判断属性是否需要进行转换，如果不需要，则直接进行注入即可，如果需要，则需要进行相应解析，然后进行属性注入，主要关注setProperty和resolveValueIfNecessary函数（后面再进行分析）。

bean初始化

AbstractAutowireCapableBeanFactory#initializeBean

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
        // 安全模式
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                // 激活Aware方法，对特殊bean处理：Aware、BeanClassLoaderAware、BeanFactoryAware
                invokeAwareMethods(beanName, bean);
                return null;
            }, getAccessControlContext());
        } else {
            //  非安全模式下激活Aware方法，对特殊bean处理：Aware、BeanClassLoaderAware、BeanFactoryAware
            invokeAwareMethods(beanName, bean);
        }

        // 后置处理器 before
        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }

        // 处理初始化方法
        try {
            invokeInitMethods(beanName, wrappedBean, mbd);
        } catch (Throwable ex) {
            throw new BeanCreationException(
                    (mbd != null ? mbd.getResourceDescription() : null),
                    beanName, "Invocation of init method failed", ex);
        }
        // 后置处理器 after
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }

        return wrappedBean;
    }

分析：

初始化Bean分为三大步骤：

• 激活Aware方法。
• 后置处理器应用(before/after)。
• 激活自定义的init方法。

激活Aware方法

// AbstractAutowireCapableBeanFactory
private void invokeAwareMethods(final String beanName, final Object bean) {
        if (bean instanceof Aware) {
            // BeanNameAware
            if (bean instanceof BeanNameAware) {
                ((BeanNameAware) bean).setBeanName(beanName);
            }
            // BeanClassLoaderAware
            if (bean instanceof BeanClassLoaderAware) {
                ClassLoader bcl = getBeanClassLoader();
                if (bcl != null) {
                    ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
                }
            }
            // BeanFactoryAware
            if (bean instanceof BeanFactoryAware) {
                ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
            }
        }
    }

分析： 

这里主要处理BeanNameAware、BeanClassLoaderAware、BeanFactoryAware，这里是对Aware接口的处理，后续再进行查漏补缺。

后置处理器应用

BeanPostProcessor 的作用是：如果我们想要在 Spring 容器完成 Bean 的实例化，配置和其他的初始化后添加一些自己的逻辑处理，那么就使用该接口，这个接口给与了用户充足的权限去更改或者扩展 Spring，是我们对 Spring 进行扩展和增强处理一个必不可少的接口。

// AbatractAutowireCapableBeanFactory
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
            throws BeansException {

        Object result = existingBean;
        // 遍历BeanPostProcessor数组
        for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
            // 处理
            Object current = beanProcessor.postProcessBeforeInitialization(result, beanName);
            if (current == null) {
                return result;
            }
            // 修改result
            result = current;
        }
        return result;
    }

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

        Object result = existingBean;
        // 遍历BeanPostProcessor
        for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
            // 进行处理
            // TODO: 2019/4/2 具体处理过程需详细查看，这里先走大流程
            Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
            // 返回为空，则返回传入的Object对象
            if (current == null) {
                return result;
            }
            // 修改result
            result = current;
        }
        return result;
    }

分析：

其实这里就是获取自定义的BeanPostProcessor，然后调用其postProcessBeforeInitialization和postProcessAfterInitialization方法进行自定义的业务处理。

激活自定义的init方法

// AbstractAutowireCapableBeanFactory
protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
            throws Throwable {

        // 首先先检查是否是InitializingBean，如果是，则需要调用afterPropertiesSet()
        boolean isInitializingBean = (bean instanceof InitializingBean);
        if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
            if (logger.isDebugEnabled()) {
                logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
            }
            // 安全模式
            if (System.getSecurityManager() != null) {
                try {
                    AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
                        ((InitializingBean) bean).afterPropertiesSet();
                        return null;
                    }, getAccessControlContext());
                } catch (PrivilegedActionException pae) {
                    throw pae.getException();
                }
            } else {
                // 属性初始化处理
                ((InitializingBean) bean).afterPropertiesSet();
            }
        }

        if (mbd != null && bean.getClass() != NullBean.class) {
            String initMethodName = mbd.getInitMethodName();
            if (StringUtils.hasLength(initMethodName) &&
                    !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                    !mbd.isExternallyManagedInitMethod(initMethodName)) {
                // 激活用户自定义的初始化方法
                invokeCustomInitMethod(beanName, bean, mbd);
            }
        }
    }

分析：

在bean标签中有一个init-method的属性，该方法的执行就是在这里。

首先检查bean是否为InitializingBean，如果是，则需要执行afterPropertiesSet方法，因为除了可以使用init-method来自定义初始化方法外，还可以实现InitializingBean接口，该接口只有一个afterPropertiesSet方法。

两者执行顺序是：先afterPropertiesSet方法，然后是init-method方法。

至此，初始化bean的过程除了循环依赖外，其他已经大致分析完成。

总结

本篇主要分析了创建bean实例的剩余流程，主要关注populateBean和initializeBean方法。

---

by Shawn Chen，2019.04.28，中午。