前言

前一篇分析了SpringBoot如何啟動以及內建web容器，這篇我們一起看一下SpringBoot的整個啟動過程，廢話不多說，正文開始。

正文

一、SpringBoot的啟動類是**application，以註解@SpringBootApplication註明。

@SpringBootApplication
public class CmsApplication {

    public static void main(String[] args) {
        SpringApplication.run(CmsApplication.class, args);

    }
}
 

SpringBootApplication註解是@Configuration,@EnableAutoConfiguration,@ComponentScan三個註解的整合，分別表示Springbean的配置bean，開啟自動配置spring的上下文，元件掃描的路徑，這也是為什麼*application.java需要放在根路徑的原因，這樣@ComponentScan掃描的才是整個專案。

二、該啟動類預設只有一個main方法，呼叫的是SpringApplication.run方法，下面我們來看一下SpringApplication這個類。

public static ConfigurableApplicationContext run(Object source
 
, String... args) {
        return run(new Object[]{source}, args);
    }
...
public static ConfigurableApplicationContext run(Object[] sources, String[] args) {
        return (new SpringApplication(sources)).run(args);//sources為具體的CmsApplication.class類
    }
...

抽出其中兩個直接呼叫的run方法，可以看出靜態方法SpringApplication.run最終建立了一個SpringApplication，並執行其中run方法。

檢視起構造方法：

public SpringApplication(Object... sources) {
        this.bannerMode = Mode.CONSOLE;
        this.logStartupInfo = true;
        this.addCommandLineProperties = true;
        this.headless = true;
        this.registerShutdownHook = true;
        this.additionalProfiles = new HashSet();
        this.initialize(sources);
    }
...

構造方法設定了基礎值後呼叫initialize方法進行初始化，如下：

private void initialize(Object[] sources) {
        if (sources != null && sources.length > 0) {
            this.sources.addAll(Arrays.asList(sources));
        }
        this.webEnvironment = this.deduceWebEnvironment();
        this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
        this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
        this.mainApplicationClass = this.deduceMainApplicationClass();
    }
...

初始化方法主要做了幾步：
1.將source放入SpringApplication的sources屬性中管理，sources是一個LinkedHashSet()，這意味著我們可以同時建立多個自定義不重複的Application，但是目前只有一個。
2.判斷是否是web程式(javax.servlet.Servlet和org.springframework.web.context.ConfigurableWebApplicationContext都必須在類載入器中存在)，並設定到webEnvironment屬性中 。
3.從spring.factories中找出ApplicationContextInitializer並設定到初始化器initializers。
4.從spring.factories中找出ApplicationListener，並例項化後設置到SpringApplication的監聽器listeners屬性中。這個過程就是找出所有的應用程式事件監聽器。
5.找出的main方法的類（這裡是CmsApplication），並返回Class物件。

預設情況下，initialize方法從spring.factories檔案中找出的key為ApplicationContextInitializer的類有：

• org.springframework.boot.context.config.DelegatingApplicationContextInitializer
• org.springframework.boot.context.ContextIdApplicationContextInitializer
• org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer
• org.springframework.boot.context.web.ServerPortInfoApplicationContextInitializer
• org.springframework.boot.autoconfigure.logging.AutoConfigurationReportLoggingInitializer

key為ApplicationListener的有：

• org.springframework.boot.context.config.ConfigFileApplicationListener
• org.springframework.boot.context.config.AnsiOutputApplicationListener
• org.springframework.boot.logging.LoggingApplicationListener
• org.springframework.boot.logging.ClasspathLoggingApplicationListener
• org.springframework.boot.autoconfigure.BackgroundPreinitializer
• org.springframework.boot.context.config.DelegatingApplicationListener
• org.springframework.boot.builder.ParentContextCloserApplicationListener
• org.springframework.boot.context.FileEncodingApplicationListener
• org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener

三、SpringApplication構造和初始化完成後，便是執行其run方法

public ConfigurableApplicationContext run(String... args) {
        StopWatch stopWatch = new StopWatch();// 構造一個任務執行觀察器
        stopWatch.start();// 開始執行，記錄開始時間
        ConfigurableApplicationContext context = null;
        FailureAnalyzers analyzers = null;
        this.configureHeadlessProperty();
        // 獲取SpringApplicationRunListeners，內部只有一個EventPublishingRunListener
        SpringApplicationRunListeners listeners = this.getRunListeners(args);
        // 封裝成SpringApplicationEvent事件然後廣播出去給SpringApplication中的listeners所監聽，啟動監聽
        listeners.starting();

        try {
            // 構造一個應用程式引數持有類
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            // 載入配置環境
            ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
            Banner printedBanner = this.printBanner(environment);
            // 建立Spring容器（使用BeanUtils.instantiate）
            context = this.createApplicationContext();
            // 若容器建立失敗，分析輸出失敗原因
            new FailureAnalyzers(context);
            // 設定容器配置環境，監聽等
            this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
            // 重新整理容器
            this.refreshContext(context);
            this.afterRefresh(context, applicationArguments);
            // 廣播出ApplicationReadyEvent事件給相應的監聽器執行
            listeners.finished(context, (Throwable)null);
            stopWatch.stop();// 執行結束，記錄執行時間
            if (this.logStartupInfo) {
                (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
            }

            return context;// 返回Spring容器
        } catch (Throwable var9) {
            this.handleRunFailure(context, listeners, (FailureAnalyzers)analyzers, var9);
            throw new IllegalStateException(var9);
        }
    }

run方法過程分析如上，該方法幾個關鍵步驟如下：

1.建立了應用的監聽器SpringApplicationRunListeners並開始監聽

2.載入SpringBoot配置環境(ConfigurableEnvironment)，如果是通過web容器釋出，會載入StandardEnvironment，其最終也是繼承了ConfigurableEnvironment，類圖如下

可以看出，*Environment最終都實現了PropertyResolver介面，我們平時通過environment物件獲取配置檔案中指定Key對應的value方法時，就是呼叫了propertyResolver介面的getProperty方法。

3.配置環境(Environment)加入到監聽器物件中(SpringApplicationRunListeners)

4.建立Spring容器：ConfigurableApplicationContext(應用配置上下文)，我們可以看一下建立方法

protected ConfigurableApplicationContext createApplicationContext() {
        Class<?> contextClass = this.applicationContextClass;
        if (contextClass == null) {
            try {
                contextClass = Class.forName(this.webEnvironment ? "org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext" : "org.springframework.context.annotation.AnnotationConfigApplicationContext");
            } catch (ClassNotFoundException var3) {
                throw new IllegalStateException("Unable create a default ApplicationContext, please specify an ApplicationContextClass", var3);
            }
        }

        return (ConfigurableApplicationContext)BeanUtils.instantiate(contextClass);
    }

方法會先獲取顯式設定的應用上下文(applicationContextClass)，如果不存在，再載入預設的環境配置（通過是否是web environment判斷），預設選擇AnnotationConfigApplicationContext註解上下文（通過掃描所有註解類來載入bean），最後通過BeanUtils例項化上下文物件，並返回，ConfigurableApplicationContext類圖如下
主要看其繼承的兩個方向：
LifeCycle：生命週期類，定義了start啟動、stop結束、isRunning是否執行中等生命週期空值方法
ApplicationContext：應用上下文類，其主要繼承了beanFactory(bean的工廠類)。

5.回到run方法內，設定容器prepareContext方法，將listeners、environment、applicationArguments、banner等重要元件與上下文物件關聯

6.重新整理容器，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();
            }

        }
    }

refresh()方法做了很多核心工作比如BeanFactory的設定，BeanFactoryPostProcessor介面的執行、BeanPostProcessor介面的執行、自動化配置類的解析、spring.factories的載入、bean的例項化、條件註解的解析、國際化的初始化等等。這部分內容會在之後的文章中分析。

7.廣播出ApplicationReadyEvent，執行結束返回ConfigurableApplicationContext。

至此，SpringBoot啟動完成，回顧整體流程，Springboot的啟動，主要建立了配置環境(environment)、事件監聽(listeners)、應用上下文(applicationContext)，並基於以上條件，在容器中開始例項化我們需要的Bean。