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

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

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

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

点击这个方法进去，可以看到方法体内又有一行代码：

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

真正干活的爷们就是它了。再点进去，可以看到方法实现：

preInstantiateSingletons.png

1. getMergedLocalBeanDefinition(beanName) ，将BeanDefinition的定义进行合并

2. if (isFactoryBean(beanName)) {……} ，判断是不是FactoryBean，拿到FactoryBean的实例，判断是否需要提前实例化，需要则通过getBean来实例化

3. 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的地方。下节再讲，喝口酒先~~