Spring-IOC加载Bean【十四】bean对象的实例化-主流程

bean对象的实例化,如果没有代理对象，那么只能通过doCreateBean方法实现：

1
2
3

 //实际创建指定的bean。
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
return beanInstance;

1、doCreateBean

doCreateBean方法是真的好复杂：

//实际创建指定的bean。在这一点上，预创建处理已经发生，例如检查postProcessBeforeInstantiation回调。区分默认bean实例化、使用工厂方法和自动装配构造函数。
    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
            throws BeanCreationException {

        // 实例化bean。BeanWrapper：Spring底层javabean基础设施的中心接口。
        BeanWrapper instanceWrapper = null;
        //如果是单例模式
        if (mbd.isSingleton()) {
            //未完成的FactoryBean实例缓存中删除beanName
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) {
            //使用适当的实例化策略为指定的bean创建一个新实例:工厂方法、构造函数自动装配或简单实例化。
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        //返回由该对象包装的bean实例。
        final Object bean = instanceWrapper.getWrappedInstance();
        //返回包装bean实例的类型。
        Class<?> beanType = instanceWrapper.getWrappedClass();
        if (beanType != NullBean.class) {
            //resolvedTargetType:包可见字段，用于缓存给定bean定义的已确定类。
            mbd.resolvedTargetType = beanType;
        }

        // 允许后处理程序修改合并的bean定义。
        // 后处理字段的公共锁。
        synchronized (mbd.postProcessingLock) {
            //应用了MergedBeanDefinitionPostProcessor
            if (!mbd.postProcessed) {
                try {
                    //执行MergedBeanDefinitionPostProcessor
                    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                } catch (Throwable ex) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                            "Post-processing of merged bean definition failed", ex);
                }
                mbd.postProcessed = true;
            }
        }

        // 缓存单例，以便能够解析循环引用，即使是由生命周期接口(如BeanFactoryAware)触发的。
        // 解决单例模式的循环依赖
        // 单例模式 & 运行循环依赖 & 当前单例 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");
            }
            // 提前将创建的 bean 实例加入到ectFactory 中
            // 这里是为了后期避免循环依赖
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }

        // 开始初始化 bean 实例对象
        Object exposedObject = bean;
        try {
            //用bean定义中的属性值填充给定BeanWrapper中的bean实例。
            populateBean(beanName, mbd, instanceWrapper);
            //初始化给定的bean实例，应用工厂回调以及init方法和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) {
            //获取早期单例引用
            Object earlySingletonReference = getSingleton(beanName, false);
            if (earlySingletonReference != null) {
                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.");
                    }
                }
            }
        }

        // bean注册
        try {
            //将给定bean添加到此工厂的一次性bean列表中，注册其一次性bean接口和/或在工厂关闭时调用的给定销毁方法(如果适用)。
            // 只适用于单例。
            registerDisposableBeanIfNecessary(beanName, bean, mbd);
        } catch (BeanDefinitionValidationException ex) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
        }

        return exposedObject;
    }