关于spring:SpringBoot源码-bean的加载中

精彩的内容来了，各位看官，持续~

接上一节，AbstractApplicationContext 类中的 refresh() 办法，有那么一行不起眼的代码：

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

就是它，创立 bean 最集中的中央，实例化所有非懒加载的单例。

点击这个办法进去，能够看到办法体内又有一行代码：

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

真正干活的爷们就是它了。再点进去，能够看到办法实现：

getMergedLocalBeanDefinition(beanName)，将 BeanDefinition 的定义进行合并
if (isFactoryBean(beanName)) {……}，判断是不是 FactoryBean，拿到 FactoryBean 的实例，判断是否须要提前实例化，须要则通过 getBean 来实例化

getBean(beanName) 一般 bean 的实例化，点进去，来到 doGetBean()，上码：

protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)throws BeansException {
    // 获取实在的 beanName, 因为有的 bean 有别名，FactoryBean 自身创立的时候，传的是 &BeanName
    String beanName = transformedBeanName(name);
    Object beanInstance;

    // 从缓存获取单例实例，解决循环依赖和反复创立
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {if (logger.isTraceEnabled()) {if (isSingletonCurrentlyInCreation(beanName)) {logger.trace("……");
            }
            else {logger.trace("……");
            }
        }
        // 解决相似 FactoryBean 这样非凡的 bean 解决
        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }

    else {
        // 原型模式不需解决循环依赖，因为原型 bean 不放缓存，不会提前裸露援用
        if (isPrototypeCurrentlyInCreation(beanName)) {throw new BeanCurrentlyInCreationException(beanName);
        }

        // 如果 beanDefinitionMap 未加载有该 bean，则从 parentBeanFactory 查找
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {String nameToLookup = originalBeanName(name);
            if (parentBeanFactory instanceof AbstractBeanFactory) {return ((AbstractBeanFactory) parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
            }
            else if (args != null) {return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else if (requiredType != null) {return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
            else {return (T) parentBeanFactory.getBean(nameToLookup);
            }
        }
        // 非类型查看的时候，才标记该 bean 已创立
        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);

            // 以后 bean 依赖的 bean 的创立。String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {for (String dep : dependsOn) {// 不可显式依赖 (@DependOn)
                    if (isDependent(beanName, dep)) {throw new BeanCreationException("……");
                    }
                    // 先创立依赖的 bean，再创立自身本人
                    registerDependentBean(dep, beanName);
                    try {getBean(dep);
                    }
                    catch (NoSuchBeanDefinitionException ex) {throw new BeanCreationException("……");
                    }
                }
            }

            // 单例 bean 创立
            if (mbd.isSingleton()) {sharedInstance = getSingleton(beanName, () -> {
                    try {return createBean(beanName, mbd, args);
                    }
                    catch (BeansException ex) {destroySingleton(beanName);
                        throw ex;
                    }
                });
                beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }
            // 原型 bean 创立
            else if (mbd.isPrototype()) {
                Object prototypeInstance = null;
                try {beforePrototypeCreation(beanName);
                    prototypeInstance = createBean(beanName, mbd, args);
                }
                finally {afterPrototypeCreation(beanName);
                }
                beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }
            // 指定 scope 上实例化 bean
            else {String scopeName = mbd.getScope();
                if (!StringUtils.hasLength(scopeName)) {throw new IllegalStateException("……");
                }
                Scope scope = this.scopes.get(scopeName);
                if (scope == null) {throw new IllegalStateException("……");
                }
                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);
}

以上代码中，创立 bean 的中央是:

createBean(beanName, mbd, args);

点击该办法进去，还藏有一层：

doCreateBean(beanName, mbdToUse, args);

点击该办法进去，就是真正创立 bean 的中央。下节再讲，喝口酒先~~