spring學習之源碼分析--AbstractApplicationContext之refresh

spring學習之源碼分析--AnnotationConfigApplicationContext之register和scan中，講了註解形式是怎麼註冊BeanDefinition的，註冊完後，有了bean的定義信息，固然是初始化容器了。

refresh

public void refresh() throws BeansException, IllegalStateException {

    synchronized (this.startupShutdownMonitor) {
        // Prepare this context for refreshing.
        // 準備刷新的上下文環境
        prepareRefresh();

        // Tell the subclass to refresh the internal bean factory.
        // 獲取beanFactory
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // Prepare the bean factory for use in this context.

        // 設置beanFactory的各個屬性
        prepareBeanFactory(beanFactory);

        try {
            // Allows post-processing of the bean factory in context subclasses.
            // 模板模式，留給子類經過重寫這個方法來作其餘處理
            postProcessBeanFactory(beanFactory);

            // Invoke factory processors registered as beans in the context.
            // BeanFactoryPostProcessorc，BeanFactory的後置處理器處理
            invokeBeanFactoryPostProcessors(beanFactory);

            // Register bean processors that intercept bean creation.
            // 註冊BeanPostProcessors，攔截bean的建立過程，bean在這個時候還沒建立
            registerBeanPostProcessors(beanFactory);

            // Initialize message source for this context.
            // 國際化處理
            initMessageSource();

            // Initialize event multicaster for this context.
            // 初始化事件派發器
            initApplicationEventMulticaster();

            // Initialize other special beans in specific context subclasses.
            // 模板模式，留給子類經過重寫這個方法來作其餘處理
            onRefresh();

            // Check for listener beans and register them.
            // 註冊ApplicationListener到applicationEventMulticaster
            registerListeners();

            // Instantiate all remaining (non-lazy-init) singletons.
            // 初始化全部的單例，除了延遲加載的bean
            finishBeanFactoryInitialization(beanFactory);

            // Last step: publish corresponding event.
            // 通知別人說已經完成了
            finishRefresh();
        }

        catch (BeansException ex) {
            if (logger.isWarnEnabled()) {
                logger.warn("Exception encountered during context initialization - " +
                        "cancelling refresh attempt: " + ex);
            }

            // Destroy already created singletons to avoid dangling resources.
            destroyBeans();

            // Reset 'active' flag.
            cancelRefresh(ex);

            // Propagate exception to caller.
            throw ex;
        }

        finally {
            // Reset common introspection caches in Spring's core, since we
            // might not ever need metadata for singleton beans anymore...
            resetCommonCaches();
        }
    }
}

prepareRefresh

刷新前的準備，對容器屬性的初始化，校驗屬性文件的合法性，保留早期事件

protected void prepareRefresh() {
    // Switch to active.
    // 啓動時間
    this.startupDate = System.currentTimeMillis();
    // 容器是否關閉
    this.closed.set(false);
    // 容器是不是活動狀態
    this.active.set(true);

    if (logger.isDebugEnabled()) {
        if (logger.isTraceEnabled()) {
            logger.trace("Refreshing " + this);
        }
        else {
            logger.debug("Refreshing " + getDisplayName());
        }
    }

    // Initialize any placeholder property sources in the context environment.
    // 初始化屬性，留給子類
    initPropertySources();

    // Validate that all properties marked as required are resolvable:
    // see ConfigurablePropertyResolver#setRequiredProperties
    // 校驗屬性文件是否合法
    getEnvironment().validateRequiredProperties();

    // Store pre-refresh ApplicationListeners...
    // 保留早期事件
    if (this.earlyApplicationListeners == null) {
        this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
    }
    else {
        // Reset local application listeners to pre-refresh state.
        this.applicationListeners.clear();
        this.applicationListeners.addAll(this.earlyApplicationListeners);
    }

    // Allow for the collection of early ApplicationEvents,
    // to be published once the multicaster is available...
    this.earlyApplicationEvents = new LinkedHashSet<>();
}

obtainFreshBeanFactory

獲取beanFactory

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    refreshBeanFactory();
    return getBeanFactory();
}

// GenericApplicationContext.class
protected final void refreshBeanFactory() throws IllegalStateException {
    // refreshed爲false才能夠，只能一個線程執行refresh方法
    if (!this.refreshed.compareAndSet(false, true)) {
        throw new IllegalStateException(
                "GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
    }
    // 設置序列號，因爲咱們這個是經過AnnotationConfigApplicationContext查看的
    // 因此已經由AnnotationConfigApplicationContext的父類GenericApplicationContext初始化了beanFactory
    this.beanFactory.setSerializationId(getId());
}

prepareBeanFactory

設置beanFactory的各個屬性

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // Tell the internal bean factory to use the context's class loader etc.
    // 設置類加載器
    beanFactory.setBeanClassLoader(getClassLoader());
    // 設置表達式解析器
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    // 添加屬性編輯器
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

    // Configure the bean factory with context callbacks.
    // 添加ApplicationContextAwareProcessor，根據不一樣的類型加入不一樣的屬性
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    // 忽略一下幾個接口的自動裝配
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
    beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

    // BeanFactory interface not registered as resolvable type in a plain factory.
    // MessageSource registered (and found for autowiring) as a bean.
    // 註冊幾個依賴類型和自動注入值
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);

    // Register early post-processor for detecting inner beans as ApplicationListeners.
    // 註冊ApplicationListenerDetector，若是bean是ApplicationListener的，加入到事件派發器
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

    // Detect a LoadTimeWeaver and prepare for weaving, if found.
    // 增長對AspectJ的支持
    if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        // Set a temporary ClassLoader for type matching.
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }

    // Register default environment beans.
    // 註冊默認的環境bean
    if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
    }
}

invokeBeanFactoryPostProcessors

咱們先了解一下BeanFactoryPostProcessor接口，他有個方法，傳遞的參數是ConfigurableListableBeanFactory，也就是說，在refresh中，beanFactory初始化完成後，把這個beanFactory傳給BeanFactoryPostProcessor。BeanFactoryPostProcessor能夠在實例化bean前，自定義他的任何行爲。與之相似的BeanPostProcessor，是bean級別的，BeanFactoryPostProcessor是容器級別的。兩個針對不一樣的範圍進行增強。
大概流程是：
一、先處理BeanDefinitionRegistryPostProcessor類型的
二、再處理其餘類型的BeanFactoryPostProcessor
兩種BeanFactoryPostProcessor都是按照PriorityOrdered>Ordered>其餘的順序執行。
經過AnnotationConfigApplicationContext掃描或註冊後，bean裏面的註解要怎麼注入到容器呢，就是經過ConfigurationClassPostProcessor實現的，這個ConfigurationClassPostProcessor就是實現了BeanDefinitionRegistryPostProcessor和PriorityOrdered的接口。

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

    // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
    // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
    if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }
}

public static void invokeBeanFactoryPostProcessors(
        ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

    // Invoke BeanDefinitionRegistryPostProcessors first, if any.
    // 保存被處理過的beanName
    Set<String> processedBeans = new HashSet<>();
    // 若是是BeanDefinitionRegistry
    if (beanFactory instanceof BeanDefinitionRegistry) {
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
        // BeanDefinitionRegistryPostProcessor先處理，保存在registryProcessors
        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                BeanDefinitionRegistryPostProcessor registryProcessor =
                        (BeanDefinitionRegistryPostProcessor) postProcessor;
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                registryProcessors.add(registryProcessor);
            }
            else {
                // 保存常規的，非BeanDefinitionRegistryPostProcessor
                regularPostProcessors.add(postProcessor);
            }
        }

        // Do not initialize FactoryBeans here: We need to leave all regular beans
        // uninitialized to let the bean factory post-processors apply to them!
        // Separate between BeanDefinitionRegistryPostProcessors that implement
        // PriorityOrdered, Ordered, and the rest.
        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

        // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
        // 獲取BeanDefinitionRegistryPostProcessor類型的beanName
        String[] postProcessorNames =
                beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            // 先執行實現了PriorityOrdered接口的bean
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                // 生成的bean保存在currentRegistryProcessors
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                // 保存被處理過的beanName
                processedBeans.add(ppName);
            }
        }
        // 對currentRegistryProcessors進行排序
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        // 所有添加到registryProcessors，此時全部的BeanFactoryPostProcessor，包括定義的bean，都保存在registryProcessors
        registryProcessors.addAll(currentRegistryProcessors);
        // 獲取PriorityOrdered接口的BeanFactoryPostProcessor完後，進行後置處理
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        // 清空currentRegistryProcessors做其餘用途
        currentRegistryProcessors.clear();

        // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
        // 獲取BeanDefinitionRegistryPostProcessor，且實現Ordered接口的。實現了PriorityOrdered接口的，經過processedBeans排除了
        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                // 生成的bean保存在currentRegistryProcessors
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                // 保存被處理過的beanName
                processedBeans.add(ppName);
            }
        }
        // 對currentRegistryProcessors進行排序
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        // 所有添加到registryProcessors
        registryProcessors.addAll(currentRegistryProcessors);
        // 獲取Ordered接口的BeanFactoryPostProcessor完後，進行後置處理
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        // 清空currentRegistryProcessors做其餘用途
        currentRegistryProcessors.clear();

        // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
        // 爲false說明已經遍歷完了
        boolean reiterate = true;
        while (reiterate) {
            reiterate = false;
            // 獲取processedBeans排除的BeanDefinitionRegistryPostProcessor
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                if (!processedBeans.contains(ppName)) {
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                    // 說明還有，繼續遍歷
                    reiterate = true;
                }
            }
            // 對currentRegistryProcessors進行排序
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            // 所有添加到registryProcessors
            registryProcessors.addAll(currentRegistryProcessors);
            // 獲取的BeanFactoryPostProcessor完後，進行後置處理
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            // 清空currentRegistryProcessors做其餘用途
            currentRegistryProcessors.clear();
        }

        // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
        // BeanDefinitionRegistryPostProcessor處理完了，再調用BeanFactoryPostProcessor的後置處理器。
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    }

    else {
        // Invoke factory processors registered with the context instance.
        // 直接調用BeanFactoryPostProcessor的後置處理器。
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    }

    // Do not initialize FactoryBeans here: We need to leave all regular beans
    // uninitialized to let the bean factory post-processors apply to them!
    // 上面主要對BeanDefinitionRegistryPostProcessor和傳入的參數beanFactoryPostProcessors兩種後置處理器的調用
    // 下面是bean定義中BeanFactoryPostProcessor後置處理器的調用
    // 獲取bean定義中BeanFactoryPostProcessor
    String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

    // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
    // Ordered, and the rest.
    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    List<String> orderedPostProcessorNames = new ArrayList<>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    for (String ppName : postProcessorNames) {
        // 已處理過的跳過
        if (processedBeans.contains(ppName)) {
            // skip - already processed in first phase above
        }
        else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            // 實現了PriorityOrdered接口的
            priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        }
        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            // 實現了Ordered接口的
            orderedPostProcessorNames.add(ppName);
        }
        else {
            // 其餘的
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
    // 先對實現了PriorityOrdered接口的排序，而後再調用後置處理器
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

    // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
    // 先對實現了Ordered接口的排序，而後再調用後置處理器
    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    for (String postProcessorName : orderedPostProcessorNames) {
        orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

    // Finally, invoke all other BeanFactoryPostProcessors.
    // 最後調用剩下的後置處理器
    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
    for (String postProcessorName : nonOrderedPostProcessorNames) {
        nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

    // Clear cached merged bean definitions since the post-processors might have
    // modified the original metadata, e.g. replacing placeholders in values...
    // 由於後處理器可能有修改了原始的元數據，因此要清除緩存的合併bean定義
    beanFactory.clearMetadataCache();
}

registerBeanPostProcessors

註冊BeanPostProcessor，這邊並無調用，只是註冊，傳遞的參數是實例及beanName。真正的調用是在bean的實例化的時候。
總體流程跟上面BeanFactoryPostProcessor差很少，只是多了一個MergedBeanDefinitionPostProcessor。

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

public static void registerBeanPostProcessors(
        ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
    // 獲取全部的BeanPostProcessor
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

    // Register BeanPostProcessorChecker that logs an info message when
    // a bean is created during BeanPostProcessor instantiation, i.e. when
    // a bean is not eligible for getting processed by all BeanPostProcessors.
    // 獲取後置處理器的個數，這個+1就是加BeanPostProcessorChecker
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

    // Separate between BeanPostProcessors that implement PriorityOrdered,
    // Ordered, and the rest.
    // 下面這段代碼是否是很熟悉，跟BeanFactoryPostProcessor同樣的思想，先PriorityOrdered再Ordered最後其餘
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
    List<String> orderedPostProcessorNames = new ArrayList<>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    for (String ppName : postProcessorNames) {
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            // 保存實現了PriorityOrdered接口的BeanPostProcessor
            priorityOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                // 保存實現了PriorityOrdered及MergedBeanDefinitionPostProcessor接口的BeanPostProcessor
                internalPostProcessors.add(pp);
            }
        }
        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            // 保存實現了Ordered接口的BeanPostProcessor
            orderedPostProcessorNames.add(ppName);
        }
        else {
            // 保存其餘接口的BeanPostProcessor
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    // First, register the BeanPostProcessors that implement PriorityOrdered.
    // PriorityOrdered接口，排序，註冊到beanFactory
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

    // Next, register the BeanPostProcessors that implement Ordered.
    // Ordered接口，排序，註冊到beanFactory，另外過濾MergedBeanDefinitionPostProcessor類型的加入到internalPostProcessors
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    for (String ppName : orderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        orderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);

    // Now, register all regular BeanPostProcessors.
    // 其餘接口，註冊到beanFactory，另外過濾MergedBeanDefinitionPostProcessor類型的加入到internalPostProcessors
    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
    for (String ppName : nonOrderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        nonOrderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

    // Finally, re-register all internal BeanPostProcessors.
    // MergedBeanDefinitionPostProcessor接口，排序，註冊到beanFactory
    sortPostProcessors(internalPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, internalPostProcessors);

    // Re-register post-processor for detecting inner beans as ApplicationListeners,
    // moving it to the end of the processor chain (for picking up proxies etc).
    // 添加ApplicationListenerDetector監聽
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

initMessageSource

國際化處理

protected void initMessageSource() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    // 若是beanFactory存在messageSource，賦值給messageSource
    if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
        this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
        // Make MessageSource aware of parent MessageSource.
        if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
            HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
            if (hms.getParentMessageSource() == null) {
                // Only set parent context as parent MessageSource if no parent MessageSource
                // registered already.
                hms.setParentMessageSource(getInternalParentMessageSource());
            }
        }
        if (logger.isTraceEnabled()) {
            logger.trace("Using MessageSource [" + this.messageSource + "]");
        }
    }
    else {
        // Use empty MessageSource to be able to accept getMessage calls.
        // beanFactory不存在messageSource，使用默認的
        DelegatingMessageSource dms = new DelegatingMessageSource();
        dms.setParentMessageSource(getInternalParentMessageSource());
        this.messageSource = dms;
        beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
        if (logger.isTraceEnabled()) {
            logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
        }
    }
}

initApplicationEventMulticaster

初始化事件派發器

protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    // 若是beanFactory存在applicationEventMulticaster，賦值給applicationEventMulticaster
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        this.applicationEventMulticaster =
                beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
        if (logger.isTraceEnabled()) {
            logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
        }
    }
    else {
        // beanFactory不存在applicationEventMulticaster，使用默認的
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
        if (logger.isTraceEnabled()) {
            logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
                    "[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
        }
    }
}

registerListeners

註冊監聽

protected void registerListeners() {
    // Register statically specified listeners first.
    // 注入到事件派發器
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        getApplicationEventMulticaster().addApplicationListener(listener);
    }

    // Do not initialize FactoryBeans here: We need to leave all regular beans
    // uninitialized to let post-processors apply to them!
    // 從配置信息獲取監聽注入到事件派發器
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }

    // Publish early application events now that we finally have a multicaster...
    // 早起的監聽註冊到事件派發器
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    if (earlyEventsToProcess != null) {
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}

finishBeanFactoryInitialization

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // Initialize conversion service for this context.
    // 若是beanFactory存在conversionService，賦值給ConversionService
    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.
    String[] weaverAwareNames = beanFactoryFactoryBean.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的定義被修改
    beanFactory.freezeConfiguration();

    // Instantiate all remaining (non-lazy-init) singletons.
    // 初始化剩下的單例，且除了延遲加載的bean
    beanFactory.preInstantiateSingletons();
}

beanFactory.preInstantiateSingletons()中，區分了普通bean和FactoryBean的實例化，若是是FactoryBean，則beanName加上&再實例化。
實例化調用的是getBean方法，實際調用的是doGetBean方法。doGetBean大概步驟以下：
一、transformedBeanName，獲取beanName，有可能傳過來的是原始的beanName，有多是加了&的，有多是別名。若是是加了&的，先去除，再獲取。若是是別名，先遞歸到最原始的別名，再獲取beanName。
二、getSingleton，獲取到beanName後，經過beanName看單例緩存是否建立過了，有的話直接返回。若是singletonObjects和earlySingletonObjects兩個緩存都沒有，從singletonFactories加載。
三、getObjectForBeanInstance，獲得的bean，是原始的bean，多是普通的bean，也多是FactoryBean，因此要經過這個方法處理一下，獲得咱們想要的bean。咱們常常說起的後置處理器就是在這裏調用的。
四、isPrototypeCurrentlyInCreation，若是沒獲得bean，就去建立一個bean，此時先判斷是不是多例。在單例的時候，可能嘗試解決循環依賴，若是是多例，會循環引用，是不容許的。
五、若是有父容器，當前容器沒有這個bean的定義，說明了這個bean就有可能在父容器中，或者讓父容器建立，一直遞歸上去。
六、getMergedBeanDefinition，父容器也沒有，就只能根據bean的定義中建立了。原先的bean的定義，都是GenericBeanDefinition類型的，要轉換爲RootBeanDefinition類型。大致邏輯是這樣的，若是mergedBeanDefinitions緩存有，直接返回，若是沒有，看看有沒有父類，有父類，遞歸上去找，併合並父類的屬性。若是沒有父類，判斷是否是RootBeanDefinition類型的，若是是，直接複製，若是不是，就轉換爲RootBeanDefinition。
七、實例化以前，要先實例化依賴的對象。要判斷是否循環依賴isDependent，再保存依賴的關係registerDependentBean。
八、若是是單例，getSingleton中先對緩存、建立狀態進行處理，再經過回調createBean建立bean，最後調用getObjectForBeanInstance處理一下。（見3步驟）
九、若是是多例，調用createBean先後，要調用beforePrototypeCreation和afterPrototypeCreation來保存是否在建立的狀態，防止循環引用，（見4步驟的判斷）。建立bean後，再調用getObjectForBeanInstance處理一下。（見3步驟）
十、其餘scope類型的判斷，大概步驟同9.
十一、根據類型轉換須要的類型。