2. 程式人生 > >spring boot 2.0 源碼分析（五）

spring boot 2.0 源碼分析（五）

阿新 • • 發佈：2018-06-11
pen div shutdown down etc messages servle started fec

在上一篇文章中我們詳細分析了spring boot是如何準備上下文環境的，今天我們來看一下run函數剩余的內容。還是先把run函數貼出來：

    /**
     * Run the Spring application, creating and refreshing a new
     * {@link ApplicationContext}.
     * @param args the application arguments (usually passed from a Java main method)
     * @return a running {@link ApplicationContext}
 

     */
    public ConfigurableApplicationContext run(String... args) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
        configureHeadlessProperty
 
();
        SpringApplicationRunListeners listeners = getRunListeners(args);
        listeners.starting();
        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                    args);
            ConfigurableEnvironment environment = prepareEnvironment
 
(listeners,
                    applicationArguments);
            configureIgnoreBeanInfo(environment);
            Banner printedBanner = printBanner(environment);
            context = createApplicationContext();
            exceptionReporters = getSpringFactoriesInstances(
                    SpringBootExceptionReporter.class,
                    new Class[] { ConfigurableApplicationContext.class }, context);
            prepareContext(context, environment, listeners, applicationArguments,
                    printedBanner);
            refreshContext(context);
            afterRefresh(context, applicationArguments);
            stopWatch.stop();
            if (this.logStartupInfo) {
                new StartupInfoLogger(this.mainApplicationClass)
                        .logStarted(getApplicationLog(), stopWatch);
            }
            listeners.started(context);
            callRunners(context, applicationArguments);
        }
        catch (Throwable ex) {
            handleRunFailure(context, ex, exceptionReporters, listeners);
            throw new IllegalStateException(ex);
        }

        try {
            listeners.running(context);
        }
        catch (Throwable ex) {
            handleRunFailure(context, ex, exceptionReporters, null);
            throw new IllegalStateException(ex);
        }
        return context;
    }

我們接著往下看，來看一下this.refreshContext(context);函數，這個函數用於刷新上下文，跟蹤到源碼看一下：

    private void refreshContext(ConfigurableApplicationContext context) {
        refresh(context);
        if (this.registerShutdownHook) {
            try {
                context.registerShutdownHook();
            }
            catch (AccessControlException ex) {
                // Not allowed in some environments.
            }
        }
    }

在refreshContext函數中，第一行調用了refresh(context);跳轉了一下，下面的代碼是註冊了一個應用關閉的函數鉤子。
先來看refresh(context);函數：

    /**
     * Refresh the underlying {@link ApplicationContext}.
     * @param applicationContext the application context to refresh
     */
    protected void refresh(ApplicationContext applicationContext) {
        Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
        ((AbstractApplicationContext) applicationContext).refresh();
    }

通過代碼跟蹤分析發現，其實是調用了AbstractApplicationContext中的refresh方法。
在ServletWebServerApplicationContext和ReactiveWebServerApplicationContext的refresh函數中都是調用了super.refresh();

    public void refresh() throws BeansException, IllegalStateException {
        Object var1 = this.startupShutdownMonitor;
        synchronized(this.startupShutdownMonitor) {
            this.prepareRefresh();
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            this.prepareBeanFactory(beanFactory);

            try {
                this.postProcessBeanFactory(beanFactory);
                this.invokeBeanFactoryPostProcessors(beanFactory);
                this.registerBeanPostProcessors(beanFactory);
                this.initMessageSource();
                this.initApplicationEventMulticaster();
                this.onRefresh();
                this.registerListeners();
                this.finishBeanFactoryInitialization(beanFactory);
                this.finishRefresh();
            } catch (BeansException var9) {
                if(this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization \
                    - cancelling refresh attempt: " + var9);
                }

                this.destroyBeans();
                this.cancelRefresh(var9);
                throw var9;
            } finally {
                this.resetCommonCaches();
            }

        }
    }

在這段代碼中我們可以看到，其是使用了上下文中的startupShutdownMonitor屬性創建一個同步代碼庫來執行的刷新動作。首先是實驗this.prepareRefresh();準備刷新上下文：

    protected void prepareRefresh() {
        this.startupDate = System.currentTimeMillis();
        this.closed.set(false);
        this.active.set(true);
        if(this.logger.isInfoEnabled()) {
            this.logger.info("Refreshing " + this);
        }

        this.initPropertySources();
        this.getEnvironment().validateRequiredProperties();
        this.earlyApplicationEvents = new LinkedHashSet();
    }

接著獲取了bean工廠以後，設置了一些bean工廠的環境：

    protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        beanFactory.setBeanClassLoader(this.getClassLoader());
        beanFactory.setBeanExpressionResolver(
        new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
        beanFactory.addPropertyEditorRegistrar(
        new ResourceEditorRegistrar(this, this.getEnvironment()));
        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.registerResolvableDependency(BeanFactory.class, beanFactory);
        beanFactory.registerResolvableDependency(ResourceLoader.class, this);
        beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
        beanFactory.registerResolvableDependency(ApplicationContext.class, this);
        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
        if(beanFactory.containsBean("loadTimeWeaver")) {
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            beanFactory.setTempClassLoader(
            new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }

        if(!beanFactory.containsLocalBean("environment")) {
            beanFactory.registerSingleton("environment", this.getEnvironment());
        }

        if(!beanFactory.containsLocalBean("systemProperties")) {
            beanFactory.registerSingleton("systemProperties", 
            this.getEnvironment().getSystemProperties());
        }

        if(!beanFactory.containsLocalBean("systemEnvironment")) {
            beanFactory.registerSingleton("systemEnvironment", 
            this.getEnvironment().getSystemEnvironment());
        }

    }

接下來是發送了一個bean工廠的處理信號，其中ServletWebServerApplicationContext中的實現是在bean工廠裏添加了一個WebApplicationContextServletContextAwareProcessor處理器：

    protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        beanFactory.addBeanPostProcessor(
        new WebApplicationContextServletContextAwareProcessor(this));
        beanFactory.ignoreDependencyInterface(ServletContextAware.class);
    }

緊接著就是調用了這處理器，並且註冊到bean工廠。然後就是分別調用了initMessageSource()和initApplicationEventMulticaster()用於初始化監聽器和監聽管理器：

    protected void initMessageSource() {
        ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
        if(beanFactory.containsLocalBean("messageSource")) {
            this.messageSource = (MessageSource)beanFactory
            .getBean("messageSource", MessageSource.class);
            if(this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
                HierarchicalMessageSource dms = (HierarchicalMessageSource)this.messageSource;
                if(dms.getParentMessageSource() == null) {
                    dms.setParentMessageSource(this.getInternalParentMessageSource());
                }
            }

            if(this.logger.isDebugEnabled()) {
                this.logger.debug("Using MessageSource [" + this.messageSource + "]");
            }
        } else {
            DelegatingMessageSource dms1 = new DelegatingMessageSource();
            dms1.setParentMessageSource(this.getInternalParentMessageSource());
            this.messageSource = dms1;
            beanFactory.registerSingleton("messageSource", this.messageSource);
            if(this.logger.isDebugEnabled()) {
                this.logger.debug("Unable to locate MessageSource with name 
                \'messageSource\': using default [" + this.messageSource + "]");
            }
        }

    }

    protected void initApplicationEventMulticaster() {
        ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
        if(beanFactory.containsLocalBean("applicationEventMulticaster")) {
            this.applicationEventMulticaster = (ApplicationEventMulticaster)beanFactory
            .getBean("applicationEventMulticaster", ApplicationEventMulticaster.class);
            if(this.logger.isDebugEnabled()) {
                this.logger.debug("Using ApplicationEventMulticaster [" + 
                this.applicationEventMulticaster + "]");
            }
        } else {
            this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
            beanFactory.registerSingleton("applicationEventMulticaster", 
            this.applicationEventMulticaster);
            if(this.logger.isDebugEnabled()) {
                this.logger.debug("Unable to locate ApplicationEventMulticaster with name 
                \'applicationEventMulticaster\':
                 using default [" + this.applicationEventMulticaster + "]");
            }
        }

    }

在initMessageSource函數中會首先判斷beanFactory工廠中是否已經存在messageSource，如果不存在就會為當前的messageSource創建一個新的DelegatingMessageSource。
initApplicationEventMulticaster的初始化方式跟initMessageSource差不多，這裏不再多述。
繼續看run函數，接下來調用onRefresh()函數，這個函數只是發送一個刷新的事件，源碼中並沒有具體的實現。
接著放下看，this.registerListeners();把spring容器內的listener和beanfactory的listener都添加到廣播器中：

    protected void registerListeners() {
        Iterator listenerBeanNames = this.getApplicationListeners().iterator();

        while(listenerBeanNames.hasNext()) {
            ApplicationListener earlyEventsToProcess = (ApplicationListener)listenerBeanNames.next();
            this.getApplicationEventMulticaster().addApplicationListener(earlyEventsToProcess);
        }

        String[] var6 = this.getBeanNamesForType(ApplicationListener.class, true, false);
        String[] var7 = var6;
        int var3 = var6.length;

        for(int earlyEvent = 0; earlyEvent < var3; ++earlyEvent) {
            String listenerBeanName = var7[earlyEvent];
            this.getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
        }

        Set var8 = this.earlyApplicationEvents;
        this.earlyApplicationEvents = null;
        if(var8 != null) {
            Iterator var9 = var8.iterator();

            while(var9.hasNext()) {
                ApplicationEvent var10 = (ApplicationEvent)var9.next();
                this.getApplicationEventMulticaster().multicastEvent(var10);
            }
        }

    }

通過this.finishBeanFactoryInitialization(beanFactory);實例化BeanFactory 中已經被註冊但是沒被實例化的所有實例。初始化的過程中各種BeanPostProcessor就開始生效了：

    protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        if(beanFactory.containsBean("conversionService") && 
        beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
        
            beanFactory.setConversionService((ConversionService)beanFactory
            .getBean("conversionService", ConversionService.class));
        }

        if(!beanFactory.hasEmbeddedValueResolver()) {
            beanFactory.addEmbeddedValueResolver((strVal) -> {
                return this.getEnvironment().resolvePlaceholders(strVal);
            });
        }

        String[] weaverAwareNames = beanFactory
        .getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
        String[] var3 = weaverAwareNames;
        int var4 = weaverAwareNames.length;

        for(int var5 = 0; var5 < var4; ++var5) {
            String weaverAwareName = var3[var5];
            this.getBean(weaverAwareName);
        }

        beanFactory.setTempClassLoader((ClassLoader)null);
        beanFactory.freezeConfiguration();
        beanFactory.preInstantiateSingletons();
    }

接下來調用finishRefresh()函數用於完成刷新後的一些掃尾工作，包括產生的緩存、初始化生命周期處理器LifecycleProcessor，並調用其onRefresh()方法、發布事件、調用LiveBeansView的registerApplicationContext註冊context。

    protected void finishRefresh() {
        this.clearResourceCaches();
        this.initLifecycleProcessor();
        this.getLifecycleProcessor().onRefresh();
        this.publishEvent((ApplicationEvent)(new ContextRefreshedEvent(this)));
        LiveBeansView.registerApplicationContext(this);
    }

接著看run函數，在刷新完context後，調用了一個afterRefresh函數，這個函數前面已經說過了，是為了給ApplicationContext的子類留下的一個擴展點。
然後調用了listeners.started(context);，把監聽器設置成了已經啟動的狀態。
最後調用了callRunners函數，獲取所有的ApplicationRunner和CommandLineRunner然後調用他們的run方法：

    private void callRunners(ApplicationContext context, ApplicationArguments args) {
        List<Object> runners = new ArrayList<>();
        runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
        runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
        AnnotationAwareOrderComparator.sort(runners);
        for (Object runner : new LinkedHashSet<>(runners)) {
            if (runner instanceof ApplicationRunner) {
                callRunner((ApplicationRunner) runner, args);
            }
            if (runner instanceof CommandLineRunner) {
                callRunner((CommandLineRunner) runner, args);
            }
        }
    }

總結：spring boot 2.0在啟動的時候，首先會調用SpringApplication的構造函數進行初始化，調用實例函數run，在run函數中，首先獲取監聽器，並設置成啟動狀態，後面準備環境prepareEnvironment，準備prepareContext上下文，刷新上下文refreshContext，最後調用callRunners來依次調用註冊的Runner。

spring boot 2.0 源碼分析（五）

相關推薦

spring boot 2.0 源碼分析（五）

pen div shutdown down etc messages servle started fec 在上一篇文章中我們詳細分析了spring boot是如何準備上下文環境的，今天我們來看一下run函數剩余的內容。還是先把run函數貼出來： /**

Spring源碼分析（五）獲取Document

規則 一個 自定義 trac tst nload indexof get t對象 摘要：本文結合《Spring源碼深度解析》來分析Spring 5.0.6版本的源代碼。若有描述錯誤之處，歡迎指正。 這一篇開始進行Document加載了，XmlBeanFactoryR

SpringBoot2.0源碼分析（二）：整合ActiveMQ分析

reg 同時 set rip ttr subscript 進行 msg found SpringBoot具體整合ActiveMQ可參考：SpringBoot2.0應用（二）：SpringBoot2.0整合ActiveMQ ActiveMQ自動註入 當項目中存在javax.j

tinymce原裝插件源碼分析（五）-searchreplace

style rip 第一個 idt cto 關於 結合 hid 就是 searchreplace 功能：查找和替換 代碼註釋見： https://www.xunhanliu.top/static/js/tinymce/plugins/searchreplace/plug

Spring 源碼分析（一）--整體架構和環境搭建

spring 事件傳播 com 之間 環境搭建 core模塊 batis bsp 元數據 本系統分析的spring源碼版本為4.3.8。 （一）整體架構 這些模塊被分為以下幾個部分 （1）Core Container Core容器（核心容器）包含Core，Bean

Spring 源碼分析（四）--自定義標簽的使用

div protected 不同 space xsd文件 不同的 handle body img 在之前的代碼分析中，Spring標簽的解析分為 默認標簽和自定義標簽兩種，前一篇文章分析了Spring中對默認標簽的解析過程。 本文將分析Spring中自定義標

Spring 源碼分析（六）--bean的加載整體分析

mean ash rep end on() 靈活性 available iat cleanup 通過前面的分析，我們結束了對XML配置文件的解析，接下來將進行bean加載的分析。對於加載bean的功能，在Spring中的調用方式為： 或者 MyTest

Spring 源碼分析（八）--容器的功能擴展

use abs 提取 ext troy sha 根據 idc owb 經過前面幾篇的分析，相信大家對Spring中容器功能有了簡單的了解，在前面的章節中我們一直以BeanFactory接口以及它的默認實現類XmlBeanFactory為例進行分析。但是，Spring

Spring 源碼分析（九）--AOP

see nbsp 完成 owa new util 定義 sep ret 我們知道，使用面向對象編程（OOP）有一些弊端，當需要為多個不具有繼承關系的對象引入同一個公共行為時，例如日誌，安全檢測等，我們只有在每個對象裏引用公共行為，這樣程序中就產生了大量的重復代碼，程

Spring源碼分析（八）AbstractBeanDefinition屬性

strac code 出現 shm main candidate 靜態變量 col aof 摘要：本文結合《Spring源碼深度解析》來分析Spring 5.0.6版本的源代碼。若有描述錯誤之處，歡迎指正。 在上一篇中已經完成了XML文檔到GenericBeanDe

Spring源碼分析（十）註冊解析的BeanDefinition

emp int style ash table 針對 全局變量 我們 名稱 摘要：本文結合《Spring源碼深度解析》來分析Spring 5.0.6版本的源代碼。若有描述錯誤之處，歡迎指正。 對配置文件解析完成後，獲取的beanDefiniton已經可以進行使用了，

Spring源碼分析（十三）緩存中獲取單例bean

ould for 目的 存儲 不同 單例 color 正在 span 摘要：本文結合《Spring源碼深度解析》來分析Spring 5.0.6版本的源代碼。若有描述錯誤之處，歡迎指正。 介紹過FactoryBean的用法後，我們就可以了解bean加載的過程了。前面已

Spring Boot Admin 詳解（Spring Boot 2.0，基於 Eureka 的實現）

Spring Boot Admin 用於監控基於 Spring Boot 的應用，它是在 Spring Boot Actuator 的基礎上提供簡潔的視覺化 WEB UI。 （一）簡介 Spring Boot Admin 提供了很多功能，如顯示 name、id 和 version，顯示線上狀態，

Spring boot 2.0+ MyBatis 多資料來源（多Mysql）

業務的需求需要兩個在不同伺服器的資料庫。 首先確定Springboot版本，我這裡引用的是2.0.0 <parent> <groupId>org.springframework.boot</groupId> <artifactId&g

linux設備驅動之misc驅動框架源碼分析（一）

linux驅動開發misc設備驅動 1、misc設備驅動框架源碼部分是由內核開發者實現提供的，主要是創建misc類和為驅動開發者提供misc_register函數，來進行創建misc設備。 這部分的源碼在/drvier/char/misc.c裏，代碼如下：/* * linux/drivers/c

linux設備驅動之misc驅動框架源碼分析（二）

linux驅動開發misc設備驅動1、misc_open函數分析 該函數在driver/char/misc.c中，misc.c是驅動框架實現的，這裏面的misc_Open函數是misc驅動框架為應用層提供的一個打開misc設備的一個接口。 1、首先我們要知道在misc.c中的misc_init函數

linux驅動開發之蜂鳴器驅動源碼分析（一）

linux 蜂鳴器 驅動 蜂鳴器的驅動源碼在/driver/char/buzzer/x210-buzzer.c文件中，源碼如下#include <linux/module.h> #include <linux/kernel.h> #include <linux

vlc源碼分析（二） 播放流程

.net ges bmp pre https 學習 ref lock 流媒體 http://www.cnblogs.com/jiayayao/p/6752388.html 　　當點擊播放文件或者輸入要播放的文件後，vlc會執行一系列的流程。 　　首先需要了解視頻以及流媒體處

redis源碼分析（3）-- 基本數據結構雙鏈表list

direction 函數指針 all eas 源碼 計數 type ima blog 一、雙鏈表結構 redis中實現的雙鏈表結構體如下： 1 typedef struct list { 2 listNode *head; # 鏈表頭 3 listNode

redis源碼分析（4）-- 基本數據結構字典dict

img 掩碼 val 一個 pair pro key-value span 數組 一、字典結構 Redis中字典采用hash表結構，如下： typedef struct dictht { dictEntry **table; // hash表數組 unsi