think in spring refresh 11

refresh方法的第11步：    核心方法 

　　实例化所有剩余的非懒加载的单例。

// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);

/**
     * Finish the initialization of this context's bean factory,
     * initializing all remaining singleton beans.
     */
    protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        // Initialize conversion service for this context.
// 什么作用？？？   <<<<

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

        // Register a default embedded value resolver if no bean post-processor
        // (such as a PropertyPlaceholderConfigurer bean) registered any before:
        // at this point, primarily for resolution in annotation attribute values.
// 注册嵌入值解析器， 主要用于注解属性值的解析。     注解属性值的解析是什么 ？？？ <<<<

        if (!beanFactory.hasEmbeddedValueResolver()) {
            beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
        }

        // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
// 下面创建的这个 bean实例的主要作用是什么？

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

        // Stop using the temporary ClassLoader for type matching.


        beanFactory.setTempClassLoader(null);

        // Allow for caching all bean definition metadata, not expecting further changes.

// 冻结所有的 bean 定义 ， 注册的 bean定义不会被进一步修改， 因为即将创建bean实例了
        beanFactory.freezeConfiguration();

        // Instantiate all remaining (non-lazy-init) singletons.
        beanFactory.preInstantiateSingletons();   // 实例化所有剩余的非懒加载的单例
    }

DefaultListableApplcationContext中的方法：

@Override
    public void preInstantiateSingletons() throws BeansException {
        if (logger.isTraceEnabled()) {  // 日志打印
            logger.trace("Pre-instantiating singletons in " + this);
        }

        // Iterate over a copy to allow for init methods which in turn register new bean definitions.
        // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
        List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);   // 创建一个list,用于存储所有beanName副本

        // Trigger initialization of all non-lazy singleton beans...
        for (String beanName : beanNames) {    // 遍历所有的  BeanName， 创建对应的bean实例
// 出现过好几次
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);  // 获得RootBeanDefinition    // 看refresh 6 在那里做了解释
// 如果  不是抽象类  是单例的   不是懒加载 
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 判断是否为 FactoryBean ,
                if (isFactoryBean(beanName)) {    // 1
// 创建FactoryBean的实例     工厂bean 的 beanName 会有一个前缀 & 
                    Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                    if (bean instanceof FactoryBean) {
                        FactoryBean<?> factory = (FactoryBean<?>) bean;
// 判断这个FactoryBean是否希望现在初始化 ？？  FactoryBean 里面会创建其它的 bean 实例
                        boolean isEagerInit;
                        if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                            isEagerInit = AccessController.doPrivileged(
                                    (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
                                    getAccessControlContext());
                        }
                        else {
                            isEagerInit = (factory instanceof SmartFactoryBean &&
                                    ((SmartFactoryBean<?>) factory).isEagerInit());
                        }
                        if (isEagerInit) {
                            getBean(beanName);
                        }
                    }
                }
                else {
                    getBean(beanName);  // 如果不是FactoryBean，则直接创建bean实例即可。
                }
            }
        }

        // Trigger post-initialization callback for all applicable beans...

// 遍历所有的 beanName, 拿到对应的bean实例，如果该bean实现了 SmartInitializingSingleton接口, 调用bean 中的 aferSingletonsInstantiated 方法
        for (String beanName : beanNames) {
            Object singletonInstance = getSingleton(beanName);
            if (singletonInstance instanceof SmartInitializingSingleton) {
                SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                        smartSingleton.afterSingletonsInstantiated(); 
                        return null;
                    }, getAccessControlContext());
                }
                else {
                    smartSingleton.afterSingletonsInstantiated();  // 
                }
            }
        }
    }

1  AbstractBeanFactory 中的方法： 

    @Override
    public boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException {
// 得到真正的  beanName
        String beanName = transformedBeanName(name);
// 
        Object beanInstance = getSingleton(beanName, false);   // 1.1
// 如果bean被创建出来了，返回它是否为 FactoryBean
        if (beanInstance != null) {
            return (beanInstance instanceof FactoryBean);
        }
        // No singleton instance found -> check bean definition.

// 如果 该 beanFactory中不存在此beanName   并且父BeanFactory 是 ConfigurablleBeanFactory类型
        if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
            // No bean definition found in this factory -> delegate to parent.

// 通过父BeanFactory 来判断它是否为 FactoryBean
            return ((ConfigurableBeanFactory) getParentBeanFactory()).isFactoryBean(name);  
        }
// 
        return isFactoryBean(beanName, getMergedLocalBeanDefinition(beanName));   // 1.2
    }

  1.1  DefaultSingletonBeanRegistry 中的方法：

　　protected Object getSingleton(String beanName, boolean allowEarlyReference) {   // 这里 第二个参数 传入的是 false
        // Quick check for existing instance without full singleton lock
        Object singletonObject = this.singletonObjects.get(beanName);     //  先从一级缓存中获取 bean 实例
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {  // 一级缓存中没有该 bean实例，并且 该bean正在创建中
            singletonObject = this.earlySingletonObjects.get(beanName);  //  从二级缓存中获取
            if (singletonObject == null && allowEarlyReference) {
                synchronized (this.singletonObjects) {
                    // Consistent creation of early reference within full singleton lock
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
                        singletonObject = this.earlySingletonObjects.get(beanName);
                        if (singletonObject == null) {
                            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                            if (singletonFactory != null) {
                                singletonObject = singletonFactory.getObject();
                                this.earlySingletonObjects.put(beanName, singletonObject);
                                this.singletonFactories.remove(beanName);
                            }
                        } 
                    }
                }
            }
        }
        return singletonObject;
    }

1.2   根据 beanName 和 RootBeanDefinition 来判断是否为 FactoryBean。 

    protected boolean isFactoryBean(String beanName, RootBeanDefinition mbd) {
        Boolean result = mbd.isFactoryBean;   
        if (result == null) {
            Class<?> beanType = predictBeanType(beanName, mbd, FactoryBean.class);   // 1.2.1
            result = (beanType != null && FactoryBean.class.isAssignableFrom(beanType));
            mbd.isFactoryBean = result;
        }
        return result;
    }

1.2.1  AbstractBeanFactory 的方法：  但是这里用的不是这个

    @Nullable
    protected Class<?> predictBeanType(String beanName, RootBeanDefinition mbd, Class<?>... typesToMatch) {
        Class<?> targetType = mbd.getTargetType();   
        if (targetType != null) {
            return targetType;
        }
        if (mbd.getFactoryMethodName() != null) {
            return null;
        }
        return resolveBeanClass(mbd, beanName, typesToMatch);
    }

1.2.1    AbstractAutowireCapableBeanFactory.

protected Class<?> predictBeanType(String beanName, RootBeanDefinition mbd, Class<?>... typesToMatch) {
// 获取生成的bean的类型
        Class<?> targetType = determineTargetType(beanName, mbd, typesToMatch);
        // Apply SmartInstantiationAwareBeanPostProcessors to predict the
        // eventual type after a before-instantiation shortcut.

// SmartInstantiationAwreBeanPostProcessor  继承了 InstantiationAwareBeanPostProcessor
// InstantiationAwareBeanPostProcessor 的 postProcessBeforeInstantiation 方法可以改变 Bean 实例的类型
// 通过 SmartInstantiationAwareBeanPostProcesspr 的 predictBeanType 方法可以预测这个bean最终的类型
        if (targetType != null && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            boolean matchingOnlyFactoryBean = typesToMatch.length == 1 && typesToMatch[0] == FactoryBean.class;
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                    SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                    Class<?> predicted = ibp.predictBeanType(targetType, beanName);
                    if (predicted != null &&
                            (!matchingOnlyFactoryBean || FactoryBean.class.isAssignableFrom(predicted))) {
                        return predicted;
                    }
                }
            }
        }
        return targetType;
    }

 

------------------------------------------------

getBean.

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

doGetBean. 

　　protected <T> T doGetBean(
            String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
            throws BeansException {
// 获得beanName的真正名字，如果是工厂bean，也就是beanName的前面有 & 前缀，那么删去这个前缀，也就是得到工厂bean中要创建的bean的beanName；
// 如果当前beanName是个别名，那么获取它的真正的名字
        String beanName = transformedBeanName(name);
        Object bean;

        // Eagerly check singleton cache for manually registered singletons.
        Object sharedInstance = getSingleton(beanName);    // 3  从 一级 二级 三级  缓存中尝试获取bean
// 如果从缓存中获取到了 bean实例，则进行日志的打印
        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 + "'");
                }
            }
//  对于 FactoryBean, 通过下面方法会进行进一步处理    待进一步看代码
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);    // 4
        }

        else {
            // Fail if we're already creating this bean instance:
            // We're assumably within a circular reference.

//  进行 scope 为 prototype的 循环依赖校验   不允许原型模式存在循环依赖。
            if (isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }

            // Check if bean definition exists in this factory.
            BeanFactory parentBeanFactory = getParentBeanFactory();    // 获取父BeanFactory
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {  // 如果父BeanFactory存在，并且当前 BeanFactory不存在该beanName的定义
                // Not found -> check parent.
                String nameToLookup = originalBeanName(name);   // 将别名解析成真正的名字，如果name的前缀有 & ，那么这里得到的结果的前缀也有 &
// 尝试通过 父 BeanFactory 来获取 bean 实例
                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) {    // typeCheckOnly 为false， 整个判断为 true
// 如果不仅仅是做类型检测，而是要创建bean实例，那么这里将beanName 放到 缓存中       做类型检测就怎么保证了不创建bean实例呢
                markBeanAsCreated(beanName);     // 5
            }

            try {
// 再次获取 RootBeanDefinition ?   为什么需要再次获取呢？？？ <<<<<<<
                RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 其实就是检测mbd是不是抽象的
                checkMergedBeanDefinition(mbd, beanName, args);

                // Guarantee initialization of beans that the current bean depends on.

// 获取当前 bean 所依赖的bean集合，在实例化自己之前，需要先实例化 当前bean 依赖的 bean, 这里的依赖指的是什么？？ 父类吗？ <<<<
                String[] dependsOn = mbd.getDependsOn();
                if (dependsOn != null) {
                    for (String dep : dependsOn) {
// 检测 dep是否依赖 beanName, 即检测是否存在循环依赖  
                        if (isDependent(beanName, dep)) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                    "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                        }
// 将 dep和 beanName的依赖关系注册到缓存中    为啥要注册到缓存中呢？？？哪里用到了呢？？ <<<<<<

                        registerDependentBean(dep, beanName);
                        try {
// 获取 beanName 依赖的 dep 的实例
                            getBean(dep);
                        }
                        catch (NoSuchBeanDefinitionException ex) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                    "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                        }
                    }
                }
// 见 think in spring refresh 11 - 2
                // Create bean instance.
                if (mbd.isSingleton()) {
                    sharedInstance = getSingleton(beanName, () -> {        // 6
                        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;
                        }
                    });
                    bean = 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);
                    }
                    bean = 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);
                            }
                        });
                        bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    }
                    catch (IllegalStateException ex) {
                        throw new BeanCreationException(beanName,
                                "Scope '" + scopeName + "' is not active for the current thread; consider " +
                                "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
                                ex);
                    }
                }
            }
            catch (BeansException ex) {
                cleanupAfterBeanCreationFailure(beanName);
                throw ex;
            }
        }

        // Check if required type matches the type of the actual bean instance.
        if (requiredType != null && !requiredType.isInstance(bean)) {
            try {
                T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
                if (convertedBean == null) {
                    throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
                }
                return convertedBean;
            }
            catch (TypeMismatchException ex) {
                if (logger.isTraceEnabled()) {
                    logger.trace("Failed to convert bean '" + name + "' to required type '" +
                            ClassUtils.getQualifiedName(requiredType) + "'", ex);
                }
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
        }
        return (T) bean;
    }

3   DefaultSingletonBeanRegistry 中的方法。

　　@Override
    @Nullable
    public Object getSingleton(String beanName) {
        return getSingleton(beanName, true);   // 这里传入的是 true
    }

　DefaultSingletonBeanRegistry 中的　getSingleton方法

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        // Quick check for existing instance without full singleton lock
        Object singletonObject = this.singletonObjects.get(beanName);    // 先从一级缓存中进行获取
// 如果没有从一级缓存中获取到 bean实例， && 该bean正在创建过程中      什么时候将 beanName 添加到了正在创建bean的set集合中的？？  <<<<<<
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            singletonObject = this.earlySingletonObjects.get(beanName);   // 从二级缓存中进行获取
// 如果没有从二级缓存中获取到，并且允许早期引用
            if (singletonObject == null && allowEarlyReference) {
                synchronized (this.singletonObjects) {
                    // Consistent creation of early reference within full singleton lock
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
                        singletonObject = this.earlySingletonObjects.get(beanName);
                        if (singletonObject == null) {
// 上面加锁后 怎么又从一级缓存和二级缓存中 获取了一次 ？？？
                            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);  // 从三级缓存中获取
                            if (singletonFactory != null) {
// 从三级缓存中获取 对象     也就是通过单例工厂来创建一个对象，这里有可能创建的不是bean本身
                                singletonObject = singletonFactory.getObject();
// 将获取到的对象添加到二级缓存中
                                this.earlySingletonObjects.put(beanName, singletonObject);
// 从三级缓存中移除掉 该对象
                                this.singletonFactories.remove(beanName);
                            }
                        }
                    }
                }
            }
        }
        return singletonObject;
    }

4

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

        // Don't let calling code try to dereference the factory if the bean isn't a factory.
        if (BeanFactoryUtils.isFactoryDereference(name)) {  // 如果是工厂 bean,那么name肯定是以 & 开头，怎么还会执行后面的语句 ？？？？<<<<<
            if (beanInstance instanceof NullBean) {
                return beanInstance;
            }
            if (!(beanInstance instanceof FactoryBean)) {
                throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
            }
            if (mbd != null) {
                mbd.isFactoryBean = true;
            }
            return beanInstance;
        }

        // Now we have the bean instance, which may be a normal bean or a FactoryBean.
        // If it's a FactoryBean, we use it to create a bean instance, unless the
        // caller actually wants a reference to the factory.
        if (!(beanInstance instanceof FactoryBean)) {
            return beanInstance;
        }

        Object object = null;
        if (mbd != null) {
            mbd.isFactoryBean = true;
        }
        else {
            object = getCachedObjectForFactoryBean(beanName);  // 4.1   先尝试从缓存中获取
        }
        if (object == null) {
            // Return bean instance from factory.
            FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
            // Caches object obtained from FactoryBean if it is a singleton.
            if (mbd == null && containsBeanDefinition(beanName)) {
                mbd = getMergedLocalBeanDefinition(beanName);
            }
            boolean synthetic = (mbd != null && mbd.isSynthetic());
            object = getObjectFromFactoryBean(factory, beanName, !synthetic); // 4.2
        }
        return object;
    }

FactoryBeanRegistrySupport中的变量：

/** Cache of singleton objects created by FactoryBeans: FactoryBean name to object. */
    private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap<>(16);   // 用来存储该工厂bean创建的对象

4.1 FactoryBeanRegistrySupport 中的方法，  先尝试从缓存中获取

    protected Object getCachedObjectForFactoryBean(String beanName) {
        return this.factoryBeanObjectCache.get(beanName);
    }

4.2  FactoryBeanRegistrySupport 中的方法，    通过工厂bean，来创建bean

　　protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
// 如果工厂bean是单例，并且在一级缓存中已经含有已经创建的 beanName对应的bean ， 说明 beanName对应的bean已经被创建出来了，下面为什么还要创建？？<<<<<
        if (factory.isSingleton() && containsSingleton(beanName)) {
            synchronized (getSingletonMutex()) {
// 从缓存中获取  与4.1一样
                Object object = this.factoryBeanObjectCache.get(beanName);
                if (object == null) {
                    object = doGetObjectFromFactoryBean(factory, beanName);   // 4.2.1
                    // Only post-process and store if not put there already during getObject() call above
                    // (e.g. because of circular reference processing triggered by custom getBean calls)
                    Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
                    if (alreadyThere != null) {
                        object = alreadyThere;
                    }
                    else {
                        if (shouldPostProcess) {
                            if (isSingletonCurrentlyInCreation(beanName)) {
                                // Temporarily return non-post-processed object, not storing it yet..
                                return object;
                            }
                            beforeSingletonCreation(beanName);
                            try {
                                object = postProcessObjectFromFactoryBean(object, beanName);
                            }
                            catch (Throwable ex) {
                                throw new BeanCreationException(beanName,
                                        "Post-processing of FactoryBean's singleton object failed", ex);
                            }
                            finally {
                                afterSingletonCreation(beanName);
                            }
                        }
                        if (containsSingleton(beanName)) {
                            this.factoryBeanObjectCache.put(beanName, object);
                        }
                    }
                }
                return object;
            }
        }
        else {
            Object object = doGetObjectFromFactoryBean(factory, beanName);   //4.2.1
            if (shouldPostProcess) {
                try {
                    object = postProcessObjectFromFactoryBean(object, beanName);
                }
                catch (Throwable ex) {
                    throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
                }
            }
            return object;
        }
    }

4.2.1   FactoryBeanRegistrySupport 中的方法

　　private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {
        Object object;
        try {
            if (System.getSecurityManager() != null) {
                AccessControlContext acc = getAccessControlContext();
                try {
                    object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
                }
                catch (PrivilegedActionException pae) {
                    throw pae.getException();
                }
            }
            else {
                object = factory.getObject();   // 应该就是这里创建的 工厂bean 里面的 bean,  <<<<<  待继续看 ！！！！
            }
        }
        catch (FactoryBeanNotInitializedException ex) {
            throw new BeanCurrentlyInCreationException(beanName, ex.toString());
        }
        catch (Throwable ex) {
            throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
        }

        // Do not accept a null value for a FactoryBean that's not fully
        // initialized yet: Many FactoryBeans just return null then.
        if (object == null) {
            if (isSingletonCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(
                        beanName, "FactoryBean which is currently in creation returned null from getObject");
            }
            object = new NullBean();
        }
        return object;
    }

 5  AbstractBeanFactory 中有一个 set 集合，专门用来存储 

/** Names of beans that have already been created at least once. */
    private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256));

 

    /**
     * Mark the specified bean as already created (or about to be created).
     * <p>This allows the bean factory to optimize its caching for repeated
     * creation of the specified bean.
     * @param beanName the name of the bean
     */
    protected void markBeanAsCreated(String beanName) {
// 如果  set集合中没有这个 beanName
        if (!this.alreadyCreated.contains(beanName)) {
            synchronized (this.mergedBeanDefinitions) {
// 又检测了一次  DCL ？
                if (!this.alreadyCreated.contains(beanName)) {
                    // Let the bean definition get re-merged now that we're actually creating
                    // the bean... just in case some of its metadata changed in the meantime.
                    clearMergedBeanDefinition(beanName);   // 5.1
// 添加到 集合中
                    this.alreadyCreated.add(beanName);
                }
            }
        }
    }

 

　　protected void clearMergedBeanDefinition(String beanName) {
        RootBeanDefinition bd = this.mergedBeanDefinitions.get(beanName);
        if (bd != null) {
            bd.stale = true;   // 设置 RootBeanDefinition的stale属性为true,  这个属性有什么作用呢？ 之前看到过，在前面有用到。
        }
    }

stale属性在这里用到了

    protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
        // Quick check on the concurrent map first, with minimal locking.
        RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
        if (mbd != null && !mbd.stale) {  // 如果stale 为false,mbd为空，那么直接返回缓存中的结果； 设置了stale为false后，就需要重新获取RootBeanDefinition
            return mbd;
        }
        return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
    }

 

 

 

　　

参考文档：

　　https://blog.csdn.net/v123411739/article/details/87907784

　　https://blog.csdn.net/v123411739/article/details/87954818