Spring5源碼解析8-refresh方法總結

廢話不多說，直接上源碼註釋：

//AbstractApplicationContext#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.
        //調用子類 refreshBeanFactory()方法
        //獲取 BeanFactory 實例 DefaultListableBeanFactory , DefaultListableBeanFactory 實現了 ConfigurableListableBeanFactory 接口
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // Prepare the bean factory for use in this context.
        //配置 beanFactory 上下文
        //1.添加 ApplicationContextAwareProcessor 和 ApplicationListenerDetector
        //2.忽略部分類型的自動裝配
        //3.註冊特殊的依賴類型，並使用相應的autowired值
        //4.註冊默認的environment beans
        //5.設置environment beans
        prepareBeanFactory(beanFactory);

        try {
            // Allows post-processing of the bean factory in context subclasses.
            //留給子類去擴展的一個方法
            postProcessBeanFactory(beanFactory);

            // Invoke factory processors registered as beans in the context.
            //執行BeanFactoryPostProcessors
            invokeBeanFactoryPostProcessors(beanFactory);

            // Register bean processors that intercept bean creation.
            // 註冊BeanPostProcessors
            registerBeanPostProcessors(beanFactory);

            // Initialize message source for this context.
            // 初始化信息源,作國際化相關
            initMessageSource();

            // Initialize event multicaster for this context.
            // 初始化容器實現傳播器,也就是往容器中添加了一個Bean
            initApplicationEventMulticaster();

            // Initialize other special beans in specific context subclasses.
            // 在特定 ApplicationContext 的子類中觸發某些特殊的Bean初始化
            // 在此處AbstractApplicationContext.onRefresh 是一個空方法
            onRefresh();

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

            // Instantiate all remaining (non-lazy-init) singletons.
            // 初始化所有還未被初始化的單例bean
            finishBeanFactoryInitialization(beanFactory);

            // Last step: publish corresponding event.
            // 容器啓動完成,清理緩存, 發佈 ContextRefreshedEvent 事件
            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.
            // 銷燬已創建的單例bean
            destroyBeans();

            // Reset 'active' flag.
            // 取消Refresh,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();
        }
    }
}

之前已經分析到了invokeBeanFactoryPostProcessors方法，現在來看一下
registerBeanPostProcessors。

registerBeanPostProcessors

registerBeanPostProcessors，顧名思義主要在註冊BeanPostProcessor，改方法的具體邏輯委託給了PostProcessorRegistrationDelegate#registerBeanPostProcessors方法，我們直接來看該方法源碼：

public static void registerBeanPostProcessors(
        ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

    //從 beanDefinitionNames 中獲取類型爲 BeanPostProcessor 的 beanName
    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.
    // BeanPostProcessorChecker 實現了 BeanPostProcessor接口
    // 用來判斷當前 bean 是否已經執行了所有的 BeanPostProcessor
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

    // Separate between BeanPostProcessors that implement PriorityOrdered,
    // Ordered, and the rest.
    // 對 BeanPostProcessor 進行分類排序
    // 實現 PriorityOrdered 接口的 BeanPostProcessor
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    // 實現 MergedBeanDefinitionPostProcessor 接口的 BeanPostProcessor
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
    // 實現 Ordered 接口的 BeanPostProcessor 的 BeanName
    List<String> orderedPostProcessorNames = new ArrayList<>();
    // 普通的 BeanPostProcessor 的 BeanName
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    for (String ppName : postProcessorNames) {
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            priorityOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        } else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    // First, register the BeanPostProcessors that implement PriorityOrdered.
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);

    // 註冊實現 PriorityOrdered 接口的 BeanPostProcessor
    // 底層循環List調用 beanFactory.addBeanPostProcessor(postProcessor); 方法
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

    // Next, register the BeanPostProcessors that implement Ordered.
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
    for (String ppName : orderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        orderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);

    // 註冊實現 Ordered 接口的 BeanPostProcessor
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);

    // Now, register all regular BeanPostProcessors.
    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
    for (String ppName : nonOrderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        nonOrderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }

    //註冊普通的 BeanPostProcessor
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

    // Finally, re-register all internal BeanPostProcessors.
    sortPostProcessors(internalPostProcessors, beanFactory);
    //註冊實現 MergedBeanDefinitionPostProcessor 接口的 BeanPostProcessor
    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).
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

是不是有種似曾相識的感受，嗯...這個源碼的內部套路和invokeBeanFactoryPostProcessors方法差不多。

從beanDefinitionNames中獲取類型爲BeanPostProcessor的所有beanName
遍歷所有的postProcessorNames，將其分類：
- 實現PriorityOrdered接口的
- 實現MergedBeanDefinitionPostProcessor接口的
- 實現Ordered接的
- 普通的BeanPostProcessor
按一定是先後順序依次執行所有的爲BeanPostProcessor，具體可查看上述源碼。

initMessageSource

initMessageSource方法負責，初始化信息源,是一些國際化相關功能，我們忽略。

initApplicationEventMulticaster

初始化容器實現傳播器,也就是往容器中添加了一個Bean，具體代碼如下：

protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    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 {
        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() + "]");
        }
    }
}

onRefresh

onRefresh方法在此處AbstractApplicationContext.onRefresh是一個空方法，其作用是在特定ApplicationContext的子類中觸發某些特殊的Bean初始化。

registerListeners

註冊ApplicationListener，源碼如下：

protected void registerListeners() {
    // Register statically specified listeners first.
    // 這裏的 applicationListeners 是需要我們手動調用 AbstractApplicationContext.addApplicationListener 方法纔會有內容
    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(beanFactory);

初始化所有還未被初始化的單例bean。
AbstractApplicationContext#finishBeanFactoryInitialization
調用DefaultListableBeanFactory#preInstantiateSingletons：

//DefaultListableBeanFactory#preInstantiateSingletons源碼：
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.
    // 獲取所有的beanDefinitionNames
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

    // Trigger initialization of all non-lazy singleton beans...
    // 遍歷所有的beanDefinitionNames
    for (String beanName : beanNames) {
        // 根據指定的beanName獲取其父類的相關公共屬性,返回合併的RootBeanDefinition
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        // 如果不是抽象類,而且是單例,又不是懶加載
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            // 判斷是不是FactoryBean
            if (isFactoryBean(beanName)) {
                // 如果是FactoryBean,使用 &+beanName ,去獲取 FactoryBean
                // 爲什麼要這樣做,因爲beanName獲取的是FactoryBean生產的Bean,要獲取FactoryBean本身,需要通過&+beanName
                // 其實,實例化所有的非懶加載單例Bean的時候,如果是FactoryBean,這裏只是創建了FactoryBean
                // 什麼時候去創建由FactoryBean產生的Bean呢? 好像也是懶加載的,在使用到這個Bean的時候,才通過FactoryBean去創建Bean
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                if (bean instanceof FactoryBean) {
                    final FactoryBean<?> factory = (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 {
                // 不是FactoryBean
                getBean(beanName);
            }
        }
    }

    // Trigger post-initialization callback for all applicable beans...
    for (String beanName : beanNames) {
        Object singletonInstance = getSingleton(beanName);
        // Spring容器的一個拓展點SmartInitializingSingleton
        // 在所有非懶加載單例Bean創建完成之後調用該接口 @since 4.1
        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();
            }
        }
    }
}

獲取所有的beanDefinitionNames，然後遍歷
先合併其父類的相關公共屬性,返回合併的RootBeanDefinition
如果不是抽象類,而且是非懶加載的單例則開始創建Bean
首先判斷是不是FactoryBean，如果是FactoryBean,使用 &+beanName ,去獲取 FactoryBean
如果不是FactoryBean，則直接調用getBean(beanName);方法創建或者獲取對應的Bean
SmartInitializingSingleton是Spring4.1版本之後的一個新擴展點。在創建完所有的非懶加載單例Bean之後，調用SmartInitializingSingleton接口，完成回調。

finishRefresh

容器啓動完成，清理緩存，發佈ContextRefreshedEvent事件。

protected void finishRefresh() {
    // Clear context-level resource caches (such as ASM metadata from scanning).
    clearResourceCaches();

    // Initialize lifecycle processor for this context.
    initLifecycleProcessor();

    // Propagate refresh to lifecycle processor first.
    getLifecycleProcessor().onRefresh();

    // Publish the final event.
    publishEvent(new ContextRefreshedEvent(this));

    // Participate in LiveBeansView MBean, if active.
    LiveBeansView.registerApplicationContext(this);
}

源碼註釋GITHUB地址：https://github.com/shenjianeng/spring-code-study

歡迎關注公衆號：

Spring5源碼解析8-refresh方法總結

registerBeanPostProcessors

initMessageSource

initApplicationEventMulticaster

onRefresh

registerListeners

finishBeanFactoryInitialization(beanFactory);

finishRefresh

一分鐘面試題：令人撓頭的三目運算符

Spring5 AOP 默認使用Cglib ？從現象到源碼深度分析

經驗分享：程序員如何快速定位問題(BUG)

SpringBoot2.x升級踩坑--新增Configuration property name限制

Spring5源碼解析8-refresh方法總結

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結