Spring启动流程（八）：完成BeanFactory的初始化

|-AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(String...)
 |-AbstractApplicationContext#refresh
  |-AbstractApplicationContext#finishBeanFactoryInitialization
   |-DefaultListableBeanFactory#preInstantiateSingletons

public void preInstantiateSingletons() throws BeansException {
    // this.beanDefinitionNames е beanNames
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

    for (String beanName : beanNames) {
        // ϲ Bean еãע<bean id=""  parent="" /> е parent
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        // dzࡢǵҲص
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            //  FactoryBean
            if (isFactoryBean(beanName)) {
                // beanName ǰϡ& 
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                if (bean instanceof FactoryBean) {
                     final FactoryBean<?> factory = (FactoryBean<?>) bean;
                     // жϵǰ FactoryBean Ƿ SmartFactoryBean ʵ
                     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) {
                           // FactoryBeanֱʹô˷гʼ
                           getBean(beanName);
                     }
                }
            }
            else {
                getBean(beanName);
            }
        }
    }

    // Trigger post-initialization callback for all applicable beans...
    // beanʵ SmartInitializingSingleton ӿڵģôõص
    for (String beanName : beanNames) {
        Object singletonInstance = getSingleton(beanName);
        if (singletonInstance instanceof SmartInitializingSingleton) {
            final SmartInitializingSingleton smartSingleton = 
                    (SmartInitializingSingleton) singletonInstance;
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                    smartSingleton.afterSingletonsInstantiated();
                    return null;
                }, getAccessControlContext());
            }
            else {
                smartSingleton.afterSingletonsInstantiated();
            }
        }
    }
}

List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
for (String beanName : beanNames) {
    RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
    if(... && bd.isSingleton() && ...) {
        getBean(beanName);
    }
}

|-AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(String...)
 |-AbstractApplicationContext#refresh
  |-AbstractApplicationContext#finishBeanFactoryInitialization
   |-DefaultListableBeanFactory#preInstantiateSingletons
    |-AbstractBeanFactory#getBean(java.lang.String)
     |-AbstractBeanFactory#doGetBean

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
         @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

    // Ҫ߼FactoryBeanͰ&ȥ,DZͰѸݱȡʵ
    final String beanName = transformedBeanName(name);
    //ķֵ
    Object bean;

    // Ƿѳʼ
    Object sharedInstance = getSingleton(beanName);
    // Ѿʼˣûдargsʹgetֱȡ
    if (sharedInstance != null && args == null) {
        // ͨBean Ļֱӷأ FactoryBean ĻǸʵ
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
    else {
        // prototype͵bean
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        // ǰBeanDefinitionbeanҾиBeanFactory
        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) {.
                 // ظIJѯ
                 return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else if (requiredType != null) {
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
            else {
                return (T) parentBeanFactory.getBean(nameToLookup);
            }
        }

        if (!typeCheckOnly) {
            // typeCheckOnly Ϊ falseǰ beanName һ alreadyCreated  Set С
            markBeanAsCreated(beanName);
        }

        // Ҫbean
        try {
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);    
            // ȳʼ Bean depends-on ж
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    // Dzѭ
                    if (isDependent(beanName, dep)) {
                        throw new BeanCreationException(...);
                    }
                    // עһϵ
                    registerDependentBean(dep, beanName);
                    try {
                        // ȳʼ
                        getBean(dep);
                    }
                    catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanCreationException(...);
                    }
                }
            }

            // ǵ
            if (mbd.isSingleton()) {
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        // ִд Bean
                        return createBean(beanName, mbd, args);
                    }
                    catch (BeansException ex) {
                        destroySingleton(beanName);
                        throw ex;
                    }
                });
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }
            // prototype
            else if (mbd.isPrototype()) {
                Object prototypeInstance = null;
                try {
                    beforePrototypeCreation(beanName);
                    // ִд Bean
                    prototypeInstance = createBean(beanName, mbd, args);
                }
                finally {
                    afterPrototypeCreation(beanName);
                }
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }
            //  singleton  prototype, ôԶscope(WebĿеsession)
            // ͽԶscopeӦ÷ȥʵ
            else {
                String scopeName = mbd.getScope();
                final Scope scope = this.scopes.get(scopeName);
                if (scope == null) {
                  throw new IllegalStateException(...);
                }
                try {
                    Object scopedInstance = scope.get(beanName, () -> {
                        beforePrototypeCreation(beanName);
                        try {
                            // ִд Bean
                            return createBean(beanName, mbd, args);
                        }
                        finally {
                            afterPrototypeCreation(beanName);
                        }
                    });
                    bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                }
                catch (IllegalStateException ex) {
                  throw new BeanCreationException(...);
                }
            }
        }
        catch (BeansException ex) {
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
    }

    //bean
    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) {
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
    }
    return (T) bean;
}

//ķֵ
Object bean;

// 
// 1\. ȡͬʱҲṩһlambdaʽbeanĴ
sharedInstance = getSingleton(beanName, () -> {
    try {
        // ִд Bean
        return createBean(beanName, mbd, args);
    }
    catch (BeansException ex) {
        destroySingleton(beanName);
        throw ex;
    }
});

// 2\. һsharedInstanceȻ󷵻beanʵϣҪǣ
// FactoryBeanͷطǸʵ󣬷ֱӷ
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

return (T) bean;

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    synchronized (this.singletonObjects) {
        boolean newSingleton = false;
        try {
            // д
            singletonObject = singletonFactory.getObject();
            newSingleton = true;
        }
        catch (... ex) {
            ...
        }
        finally {
            // ɺһЩжϲ봴̹ϵ
            afterSingletonCreation(beanName);
        }
        if (newSingleton) {
            // ӵ  beanFactory 
            addSingleton(beanName, singletonObject);
        }
        return singletonObject;
    }
}

@FunctionalInterface
public interface ObjectFactory<T> {
    T getObject() throws BeansException;
}

sharedInstance = getSingleton(beanName, () -> {
    try {
        // ִд Bean
        return createBean(beanName, mbd, args);
    }
    catch (BeansException ex) {
        destroySingleton(beanName);
        throw ex;
    }
});

try {
    // ִд Bean
    return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
    destroySingleton(beanName);
    throw ex;
}