Spring 5 源码解析- BeanFactory#getBean() 方法分析 - 04

         业务系统通过直接或间接调用  BeanFactory#getBean(String) 获取bean 实例化后的对象。先从 BeanDefinition 配置中获取类类型信息，然后通过反射创建对象。创建对象后，填充属性信息，执行 Aware 接口对应的方法，执行 BeanPostProcessor#postProcessBeforeInitialization 方法，调用配置的 init-method 方法，执行 BeanPostProcessor#postProcessAfterInitialization 方法，得到最终的封装过的 Bean 对象实例。业务系统停机时，调用 destroy-method 销毁对象相关信息。

 

一.  ApplicationContext 中 获取  Bean 实例 

         AbstractApplicationContext#getBean(java.lang.String)
        1. 检查 上下文环境 (ApplicationContext)活动标记是否正常。

        2. 通过 BeanFactory 实例获取 bean 对象。

    @Override
    public Object getBean(String name) throws BeansException {
        assertBeanFactoryActive();
        return getBeanFactory().getBean(name);
    }

 

二. BeanFactory  获取 Bean 实例

     AbstractBeanFactory#getBean(java.lang.String)

           --> AbstractBeanFactory#doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)

      1.将 name 名称转换成 原始的BeanName 名称。例如：如果 name 有 FACTORY_BEAN_PREFIX 标志，则循环处理去掉。如果是别名，则转换成实际的 BeanName。

      2.从单例缓存中获取 创建好的共享单例对象。

      3.如果获取的 共享单例对象不为 null。则 通过  getObjectForBeanInstance 方法处理 共享单例对象。

        getObjectForBeanInstance()：检查  Bean 实例是否是 FactoryBean 实现类，如果是，则进行相关处理。FactoryBean  是一个返回特殊Bean实例的接口。当运行程序需要简单生成 Bean 实例时，可以继承这个接口，实现简单的三个方法就行。由 FactoryBean  生成的 Bean 实例是没有复杂的生命周期管理。

      4.不满足 3 条件，则常规逻辑创建 bean 实例。

             a. 检查 beanName 是否是 原型模式 的循环依赖创建。 如果是，则直接抛出异常。Spring 只能解决 单例模式的循环依赖，不能解决原型模式的循环依赖。

             b. 当 BeanFactory 有 parentBeanFactory，并且 beanName 不在当前 beanDefinition 中 。 则通过 parentBeanFactory.getBean() 获取 beanName 实例。

             c. 标记正在创建 Bean 实例。

             d.  获取 合并后的 beanDefinition  定义信息，并检查 beanDefinition  信息。

             e. 从 beanDefinition  中获取所有依赖 bean 信息。先创建依赖 Bean 的实例。

             f.  如果是单例模式，则使用单例逻辑创建 Bean 实例。创建好后再通过 getObjectForBeanInstance  处理。

             j.  如果是原型模式，则使用原型逻辑创建 Bean 实例。创建好后再通过 getObjectForBeanInstance  处理。

             h. 如果其他自定义作用域模式，则使用对应的逻辑创建 Bean 实例。创建好后再通过 getObjectForBeanInstance  处理。

      5.如果创建的 bean 实例 和 指定的类型不匹配，则转换成指定的类型。

    /**
     * Return an instance, which may be shared or independent, of the specified bean.
     * @param name the name of the bean to retrieve
     * @param requiredType the required type of the bean to retrieve
     * @param args arguments to use when creating a bean instance using explicit arguments
     * (only applied when creating a new instance as opposed to retrieving an existing one)
     * @param typeCheckOnly whether the instance is obtained for a type check,
     * not for actual use
     * @return an instance of the bean
     * @throws BeansException if the bean could not be created
     */
    @SuppressWarnings("unchecked")
    protected <T> T doGetBean(
            String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
            throws BeansException {

        // 将 name 转换成 BeanDefinition 中定义的信息。
        // 1. 如果name 名称前面有 &,则循环去掉。 & 表示FactoryBean
        // 2. 如果name 是别名的话，则循环转换成 BeanDefinition 中定义的 id 名称。
        String beanName = transformedBeanName(name);
        Object beanInstance;

        //  singletonFactories  earlySingletonObjects singletonObjects
        //  1.检查 singletonObjects 或 earlySingletonObjects 中是否有在创建的 对象实例信息。
        //  2. 添加同步锁， 重新校验（双重校验 ） singletonObjects 或 earlySingletonObjects 是否有 对象实例信息。
        //  3. 获取 singletonFactories 中对象实例信息。如果获取到，放到  earlySingletonObjects 中。
        //  4. 否在返回 null 对象。

        // Eagerly check singleton cache for manually registered singletons.
        Object sharedInstance = getSingleton(beanName);
        if (sharedInstance != null && args == null) {
            if (logger.isTraceEnabled()) {
                if (isSingletonCurrentlyInCreation(beanName)) {
                    logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
                            "' that is not fully initialized yet - a consequence of a circular reference");
                }
                else {
                    logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
                }
            }
            beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }

        else {
            // Fail if we're already creating this bean instance:
            // We're assumably within a circular reference.
            if (isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }

            // Check if bean definition exists in this factory.
            BeanFactory parentBeanFactory = getParentBeanFactory();
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
                // Not found -> check parent.
                String nameToLookup = originalBeanName(name);
                if (parentBeanFactory instanceof AbstractBeanFactory) {
                    return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                            nameToLookup, requiredType, args, typeCheckOnly);
                }
                else if (args != null) {
                    // Delegation to parent with explicit args.
                    return (T) parentBeanFactory.getBean(nameToLookup, args);
                }
                else if (requiredType != null) {
                    // No args -> delegate to standard getBean method.
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }
                else {
                    return (T) parentBeanFactory.getBean(nameToLookup);
                }
            }

            if (!typeCheckOnly) {
                markBeanAsCreated(beanName);
            }

            StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
                    .tag("beanName", name);
            try {
                if (requiredType != null) {
                    beanCreation.tag("beanType", requiredType::toString);
                }
                RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                checkMergedBeanDefinition(mbd, beanName, args);

                // Guarantee initialization of beans that the current bean depends on.
                String[] dependsOn = mbd.getDependsOn();
                if (dependsOn != null) {
                    for (String dep : dependsOn) {
                        if (isDependent(beanName, dep)) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                    "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                        }
                        registerDependentBean(dep, beanName);
                        try {
                            getBean(dep);
                        }
                        catch (NoSuchBeanDefinitionException ex) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                    "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                        }
                    }
                }

                // Create bean instance.
                if (mbd.isSingleton()) {
                    sharedInstance = getSingleton(beanName, () -> {
                        try {
                            return createBean(beanName, mbd, args);
                        }
                        catch (BeansException ex) {
                            // Explicitly remove instance from singleton cache: It might have been put there
                            // eagerly by the creation process, to allow for circular reference resolution.
                            // Also remove any beans that received a temporary reference to the bean.
                            destroySingleton(beanName);
                            throw ex;
                        }
                    });
                    beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }

                else if (mbd.isPrototype()) {
                    // It's a prototype -> create a new instance.
                    Object prototypeInstance = null;
                    try {
                        beforePrototypeCreation(beanName);
                        prototypeInstance = createBean(beanName, mbd, args);
                    }
                    finally {
                        afterPrototypeCreation(beanName);
                    }
                    beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                }

                else {
                    String scopeName = mbd.getScope();
                    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 {
                        Object scopedInstance = scope.get(beanName, () -> {
                            beforePrototypeCreation(beanName);
                            try {
                                return createBean(beanName, mbd, args);
                            }
                            finally {
                                afterPrototypeCreation(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()));
                cleanupAfterBeanCreationFailure(beanName);
                throw ex;
            }
            finally {
                beanCreation.end();
            }
        }

        return adaptBeanInstance(name, beanInstance, requiredType);
    }

 

 三. BeanFactory  创建 Bean 实例

     AbstractBeanFactory#getBean(java.lang.String)

           --> AbstractBeanFactory#doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)

               -->  AbstractAutowireCapableBeanFactory#createBean(String,  RootBeanDefinition,  Object[])

     1. 解析 BeanClass 得到 对应的Class 实例，并设置到 BeanDefinition 上。

     2. 准备覆盖方法。

     3. 通过 InstantiationAwareBeanPostProcessor 实现类创建 Bean 对象的实例。如果创建成功，则直接返回。

               例如： org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator 实现类实现动态代理。

     4. 在 3步骤没有创建，则使用 AbstractAutowireCapableBeanFactory#doCreateBean() 创建对象实例 ，并返回。

    /**
     * Central method of this class: creates a bean instance,
     * populates the bean instance, applies post-processors, etc.
     * @see #doCreateBean
     */
    @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.
        Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
            mbdToUse = new RootBeanDefinition(mbd);
            mbdToUse.setBeanClass(resolvedClass);
        }

        // Prepare method overrides.
        try {
            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.
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            if (bean != null) {
                return bean;
            }
        }
        catch (Throwable ex) {
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                    "BeanPostProcessor before instantiation of bean failed", ex);
        }

        try {
            Object beanInstance = doCreateBean(beanName, mbdToUse, args);
            if (logger.isTraceEnabled()) {
                logger.trace("Finished creating instance of bean '" + beanName + "'");
            }
            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);
        }
    }

 

 四. AbstractAutowireCapableBeanFactory 创建 Bean 实例

     AbstractBeanFactory#getBean(java.lang.String)

           --> AbstractBeanFactory#doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)

               -->  AbstractAutowireCapableBeanFactory#createBean(String,  RootBeanDefinition,  Object[])

                  --> AbstractAutowireCapableBeanFactory#doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)

    1.  创建 BeanWrapper 实例。

    2.  通过 MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition() 实现类合并处理 BeanDefinition 配置。

    3.  检查 正在创建的 Bean 实例是否是 循环依赖 创建的单例。如果是循环依赖创建的单例，则添加 循环依赖的缓存信息。

               即：将 ObjectFactory 实例保存到   singletonFactories 中。

    4. 填充Bean 属性信息。例如  Autowired注解属性注入。

             InstantiationAwareBeanPostProcessor#postProcessProperties 和 InstantiationAwareBeanPostProcessor#postProcessPropertyValues 相关处理。

    5. 初始化 Bean 实例 。

              a. 执行 实现Aware接口的相关方法。

              b. 循环调用 BeanPostProcessor#postProcessBeforeInitialization() 方法。

              c. 执行 init-method() 方法。

              d. 循环调用 BeanPostProcessor#postProcessAfterInitialization() 方法。

      6.  如果是单例创建，进行相关的特殊处理。

      7. 注册 Bean 的 销毁相关逻辑处理方法。

      8. 返回最终的 Bean 实例。可能是动态代理实例。

如下是几个主要的方法，对应 Bean 创建的几个生命周期。

-->> AbstractAutowireCapableBeanFactory#createBeanInstance()

-->> AbstractAutowireCapableBeanFactory#populateBean()

-->> AbstractAutowireCapableBeanFactory#initializeBean()

    -->> AbstractAutowireCapableBeanFactory#invokeAwareMethods

    -->> AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization

    -->> AbstractAutowireCapableBeanFactory#invokeInitMethods

                     org.springframework.beans.factory.InitializingBean#afterPropertiesSet()

                     AbstractAutowireCapableBeanFactory#invokeCustomInitMethod()

    -->> AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization()

    /**
     * Actually create the specified bean. Pre-creation processing has already happened
     * at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks.
     * <p>Differentiates between default bean instantiation, use of a
     * factory method, and autowiring a constructor.
     * @param beanName the name of the bean
     * @param mbd the merged bean definition for the bean
     * @param args explicit arguments to use for constructor or factory method invocation
     * @return a new instance of the bean
     * @throws BeanCreationException if the bean could not be created
     * @see #instantiateBean
     * @see #instantiateUsingFactoryMethod
     * @see #autowireConstructor
     */
    protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException {

        // Instantiate the bean.
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) {
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        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 {
                    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));
        if (earlySingletonExposure) {
            if (logger.isTraceEnabled()) {
                logger.trace("Eagerly caching bean '" + beanName +
                        "' to allow for resolving potential circular references");
            }
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }

        // Initialize the bean instance.
        Object exposedObject = bean;
        try {
            populateBean(beanName, mbd, instanceWrapper);
            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 " +
                                "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
                    }
                }
            }
        }

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

        return exposedObject;
    }

 

五. 循环依赖的处理

       spring 只解决了 单例模式的 循环依赖问题。原型模式，构造器注入的等循环依赖没用解决。

         AbstractAutowireCapableBeanFactory#doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)

               AbstractAutowireCapableBeanFactory#createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)

               DefaultSingletonBeanRegistry#addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory)

               AbstractAutowireCapableBeanFactory#populateBean()

               AbstractAutowireCapableBeanFactory#initializeBean()

        1. 在创建A bean 原生实例后，将 ObjectFactory 包装后的实例 存入 singletonFactories (三级缓存 DefaultSingletonBeanRegistry#singletonFactories)中。 

        2. 填充A  bean 属性。这个时候可能会遇到 循环依赖问题。当填充其他 bean 实例时，其他bean又 依赖A bean 时，获取A bean实例时，先从 singletonFactories 获取的 ObjectFactory  实例，调用ObjectFactory#getObject() 获取处理后的 A bean 实例(最终调用AbstractAutowireCapableBeanFactory#getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean)方法依次调用

SmartInstantiationAwareBeanPostProcessor#getEarlyBeanReference(Object bean, String beanName) 方法。

)，并存入 earlySingletonObjects (二级缓存 DefaultSingletonBeanRegistry#earlySingletonObjects)

        3.  初始化bean 处理。AbstractAutowireCapableBeanFactory#initializeBean()

        4.  当是单例 bean 创建时，获得 earlySingletonObjects (二级缓存 DefaultSingletonBeanRegistry#earlySingletonObjects) 保存的 bean处理后的实例 earlySingletonReference。

        5.  当 earlySingletonReference 不为null,并且 exposedObject == bean 时，则使用 earlySingletonReference  代替A bean 原生实例。

    /**
     * Actually create the specified bean. Pre-creation processing has already happened
     * at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks.
     * <p>Differentiates between default bean instantiation, use of a
     * factory method, and autowiring a constructor.
     * @param beanName the name of the bean
     * @param mbd the merged bean definition for the bean
     * @param args explicit arguments to use for constructor or factory method invocation
     * @return a new instance of the bean
     * @throws BeanCreationException if the bean could not be created
     * @see #instantiateBean
     * @see #instantiateUsingFactoryMethod
     * @see #autowireConstructor
     */
    protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException {

        // Instantiate the bean.
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) {
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        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 {
                    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));
        if (earlySingletonExposure) {
            if (logger.isTraceEnabled()) {
                logger.trace("Eagerly caching bean '" + beanName +
                        "' to allow for resolving potential circular references");
            }
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }

        // Initialize the bean instance.
        Object exposedObject = bean;
        try {
            populateBean(beanName, mbd, instanceWrapper);
            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 " +
                                "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
                    }
                }
            }
        }

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

        return exposedObject;
    }

       

           在创建 bean 时，如果一直操作的是A bean 原生实例。单例循环依赖正常解决。当遇到经过一系列处理后返回的非A bean 原生实例时，默认则会报错，需要继承 SmartInstantiationAwareBeanPostProcessor接口，实现 getEarlyBeanReference() 方法。当是动态代理，返回的是AbstractAutoProxyCreator#getEarlyBeanReference(Object bean, String beanName) 处理后的 A bean 代理对象。

 

六： BEAN 生命周期

    在创建 Bean 对象实例时，通过各个生命周期，进行BEAN功能扩展

  org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean()

           -> org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance(beanName, mbd, args)

           -> org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean(beanName, mbd, instanceWrapper)

           -> org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(beanName, exposedObject, mbd)

           -> org.springframework.beans.factory.support.AbstractBeanFactory#registerDisposableBeanIfNecessary(beanName, bean, mbd)

   

    0. org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation()

      在创建 bean 实例 之前，先通过检查是否通过处理器  InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation() 创建实例。如果创建实例了，则直接返回，后续步骤不执行。

    1.   createBeanInstance() 通过 bean 构造函数创建实例。

    2.  populateBean()  给创建好的 bean 实例填充字段数据。

         ①. 先检查是否执行 bean 实例化后增强处理方法  org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation 。如果执行了，则直接返回，后续步骤不执行。

        ②. 填充 @Autowired ,@Resource 修饰的字段值。 或 setter 方法处理的字段。

     3. initializeBean()  bean 初始化，并进行增强处理(包含AOP处理)。

        ①. 当 Bean 对象实现了 BeanNameAware,BeanClassLoaderAware,BeanFactoryAware 接口时，则调用对应的set方法，设置对应的信息。

        ②. 进行 bean 初始化前的增强处理 org.springframework.beans.factory.config.BeanPostProcessor#postProcessBeforeInitialization().

        ③. 调用 bean 的初始化 方法。

                   当 bean 实现了 InitializingBean 接口时，执行 InitializingBean#afterPropertiesSet() 方法。

                   当 bean 配置了 初始化方法(initMethod) 方法时，通过反射调用配置的初始化方法。

                    初始化方法配置方式一: 

                               通过bean节点init-method 属性配置。 <bean id="beanName" class="BeanTypeName" init-method="init" destroy-method="destroy">

                    方式二:   通过 @Bean(initMethod = "init", destroyMethod = "destroy")  配置。

                   方式三:   通过 @PostConstruct 标记初始化方法。

         ④.  进行 bean 初始化后的增强处理 org.springframework.beans.factory.config.BeanPostProcessor#postProcessAfterInitialization() .士大夫

     4.  AbstractBeanFactory#registerDisposableBeanIfNecessary 注册销毁 bean 时的处理。 具体通过 DisposableBeanAdapter#destroy() 实现处理。

         ① 进行 bean 销毁前的增强处理 DestructionAwareBeanPostProcessor#postProcessBeforeDestruction()。

         ② 如果 bean 实现了 DisposableBean 接口，则调用 销毁方法 bean#destroy() 。 

         ③  调用配置的销毁方法

              销毁方法配置方式一: 

                               通过bean节点 destroy-method 属性配置。 <bean id="beanName" class="BeanTypeName" init-method="init" destroy-method="destroy">

                              当配置  <bean destroy-method=""> or <beans default-destroy-method=""> 时，则寻找 close 或 shutdown 方法名。

                    方式二:   通过 @Bean(initMethod = "init", destroyMethod = "destroy")  配置。

                   方式三:   通过 @PreDestroy 标记的销毁方法。