Spring Boot啟動流程

Spring Boot啟動流程

 

　　　　　　　　君生我未生，君生我已老。君恨我生遲，我恨君生早。

 

 一、簡述

Spring Boot啟動流程分析使用版本SpringBoot VERSION：版本 2.5.5-SNAPSHOT。

Spring Boot專案最簡單的Application啟動類。

可以看出Application啟動類中，包含了@SpringBootApplication 註解和 SpringApplication.run 啟動方法，所以SpringBoot的啟動可以分解為 註解 和 啟動方法 兩大過程，而仔細看啟動類中還引入了一個【org.springframework.boot.SpringApplication】包，所以啟動方法中又可以分為兩個階段即 建立SpringApplication 例項 和 執行run方法。

二、註解

註解暫且簡單瞭解，暫不深入。

1、@SpirngBootApplication註解

進入@SpringBootApplication註解內。

從@SpringBootApplication註解內部可以發現，它雖然定義使用了多個Annotation進行了原資訊標註，但實際上重要的只有三個Annotation：

• @SpringBootConfiguration（@SpringBootConfiguration註解點開檢視發現裡面還是應用了@Configuration）->Spring IOC容器配置類。
• @EnableAutoConfiguration ->使用@Import將所有符合自動配置條件的bean定義載入到IOC容器。
• @ComponentScan ->自動掃描並載入符合條件的元件或者bean定義，預設掃描SpringApplication的run方法裡的class所在的包路徑下檔案，所以通常將該啟動類放到根包路徑下。

即 @SpringBootApplication = (預設屬性)@Configuration + @EnableAutoConfiguration + @ComponentScan。

三、啟動方法

啟動方法中分為兩個階段即 建立SpringApplication 例項 和 執行run方法。

1、建立SpringApplication例項

從啟動類中的run方法跟進去，SpringApplication.run -> return run -> return new SpringApplication(primarySources).run(args) -> this(null, primarySources) -> SpringApplication。

其中：return new SpringApplication(primarySources).run(args) ，如果跟new SpringApplication(primarySources) 方法則是啟動方法中的第一階段即建立SpringApplication例項，跟run(args) 方法進去就是啟動方法中的第二階段。

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources)

/**
     * Create a new {@link SpringApplication} instance. The application context will load
     * beans from the specified primary sources (see {@link SpringApplication class-level}
     * documentation for details. The instance can be customized before calling
     * {@link #run(String...)}.
     *
     * @param resourceLoader the resource loader to use
     * @param primarySources the primary bean sources
     * @see #run(Class, String[])
     * @see #setSources(Set)
     */
    @SuppressWarnings({"unchecked", "rawtypes"})
    public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        // 初始化類載入器
        this.resourceLoader = resourceLoader;
        // Assert 斷言非空，若傳入的class引數為null則列印異常並退出初始化
        Assert.notNull(primarySources, "PrimarySources must not be null");
        // 獲取main方法中的args，初始化啟動時配置的額外引數集合
        this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
        // 判斷專案啟動型別：NONE/SERVLET/REACTIVE
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        // 從 Spring 工廠獲取 Bootstrap Registry Initializers
        this.bootstrapRegistryInitializers = getBootstrapRegistryInitializersFromSpringFactories();
        // 獲取 Spring 工廠例項 -> 容器上下文相關的初始化
        setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
        // 獲取 Spring 工廠例項 -> 設定應用程式監聽器
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        // 推匯出主應用程式類，即從當前的棧資訊中尋找main所在主類：com.iot.SpringBootLoveApplication
        this.mainApplicationClass = deduceMainApplicationClass();
    }

1.1、WebApplicationType

WebApplicationType 判斷專案型別。

 public enum WebApplicationType

/*
 * Copyright 2012-2019 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.boot;

import org.springframework.util.ClassUtils;

/**
 * An enumeration of possible types of web application.
 *
 * @author Andy Wilkinson
 * @author Brian Clozel
 * @since 2.0.0
 */
public enum WebApplicationType {

    /**
     * The application should not run as a web application and should not start an
     * embedded web server.
     */
    NONE,

    /**
     * The application should run as a servlet-based web application and should start an
     * embedded servlet web server.
     */
    SERVLET,

    /**
     * The application should run as a reactive web application and should start an
     * embedded reactive web server.
     */
    REACTIVE;

    private static final String[] SERVLET_INDICATOR_CLASSES = {"javax.servlet.Servlet",
            "org.springframework.web.context.ConfigurableWebApplicationContext"};

    private static final String WEBMVC_INDICATOR_CLASS = "org.springframework.web.servlet.DispatcherServlet";

    private static final String WEBFLUX_INDICATOR_CLASS = "org.springframework.web.reactive.DispatcherHandler";

    private static final String JERSEY_INDICATOR_CLASS = "org.glassfish.jersey.servlet.ServletContainer";

    private static final String SERVLET_APPLICATION_CONTEXT_CLASS = "org.springframework.web.context.WebApplicationContext";

    private static final String REACTIVE_APPLICATION_CONTEXT_CLASS = "org.springframework.boot.web.reactive.context.ReactiveWebApplicationContext";

    /**
     * deduceFromClasspath
     * 依次迴圈遍歷當前應用中是否存在相關的類來判斷最終應用的啟動型別
     *
     * @return
     */
    static WebApplicationType deduceFromClasspath() {
        /**
         * REACTIVE：響應式WEB專案
         * 若啟動型別為REACTIVE,
         * 則類路徑下存在 org.springframework.web.reactive.DispatcherHandler 類
         * 並且不存在 org.springframework.web.servlet.DispatcherServlet 和 org.glassfish.jersey.servlet.ServletContainer
         * 兩者指的是SpringMVC/Tomcat和jersey容器
         */
        if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
                && !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
            return WebApplicationType.REACTIVE;
        }
        /**
         * NONE：非WEB專案,就是一個最簡單的Springboot應用
         * 若啟動型別為NONE
         * 則類路徑下 javax.servlet.Servlet 和org.springframework.web.context.ConfigurableWebApplicationContext都不存在
         */
        for (String className : SERVLET_INDICATOR_CLASSES) {
            if (!ClassUtils.isPresent(className, null)) {
                return WebApplicationType.NONE;
            }
        }
        /**
         * SERVLET：SERVLET WEB 專案
         * 若啟動型別為Servlet，則必須有SERVLET_INDICATOR_CLASSES中的javax.servlet.Servlet
         * 和org.springframework.web.context.ConfigurableWebApplicationContext
         */
        return WebApplicationType.SERVLET;
    }

    static WebApplicationType deduceFromApplicationContext(Class<?> applicationContextClass) {
        if (isAssignable(SERVLET_APPLICATION_CONTEXT_CLASS, applicationContextClass)) {
            return WebApplicationType.SERVLET;
        }
        if (isAssignable(REACTIVE_APPLICATION_CONTEXT_CLASS, applicationContextClass)) {
            return WebApplicationType.REACTIVE;
        }
        return WebApplicationType.NONE;
    }

    private static boolean isAssignable(String target, Class<?> type) {
        try {
            return ClassUtils.resolveClassName(target, null).isAssignableFrom(type);
        } catch (Throwable ex) {
            return false;
        }
    }

}

1.2、getBootstrapRegistryInitializersFromSpringFactories

getBootstrapRegistryInitializersFromSpringFactories方法從spring.factories 中獲取 BootstrapRegistryInitializer。

private List<BootstrapRegistryInitializer> getBootstrapRegistryInitializersFromSpringFactories() 

private List<BootstrapRegistryInitializer> getBootstrapRegistryInitializersFromSpringFactories(){
        ArrayList<BootstrapRegistryInitializer> initializers=new ArrayList<>();
        /**
         * 從spring.factories 中獲取Bootstrapper集合，
         * 然後遍歷轉化為BootstrapRegistryInitializer，再存入 initializers
         */
        getSpringFactoriesInstances(Bootstrapper.class).stream()
        .map((bootstrapper)->((BootstrapRegistryInitializer)bootstrapper::initialize))
        .forEach(initializers::add);
        /**
         * 從spring.factories 中獲取BootstrapRegistryInitializer集合，再存入 initializers
         * getSpringFactoriesInstances 該方法在整個啟動流程中會頻繁出現,下面集中介紹
         */
        initializers.addAll(getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
        return initializers;
        }

1.3、setInitializers && setListeners

setInitializers && setListeners 分別是容器上下文初始化 & 監聽器初始化。

容器上下文初始化setInitializers 和監聽器初始化setListeners 都是呼叫了getSpringFactoriesInstances() 方法，從spring.factories中獲取配置。不同的是傳給它的type引數，主要有一下幾種型別。

• ApplicationContextInitializer.class 上下文相關
• ApplicationListener.class 監聽器相關
• SpringApplicationRunListener.class 執行時監聽器
• SpringBootExceptionReporter.class 異常類相關

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args)

/**
     * The location to look for factories.
     * <p>Can be present in multiple JAR files.
     */
    public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";


    /**
     * 從spring.factories中獲取配置
     */
    private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
        ClassLoader classLoader = getClassLoader();
        // Use names and ensure unique to protect against duplicates
        /**
         * 載入各jar包中的"META-INF/spring.factories"配置
         * 其中SpringFactoriesLoader.loadFactoryNames(type, classLoader) 方法
         * 是獲取spring.factories配置檔案中已經配置的指定型別的的實現類集合
         * 其中FACTORIES_RESOURCE_LOCATION的值：META-INF/spring.factories
         */
        Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
        // 通過反射建立這些類
        List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
        // 排序
        AnnotationAwareOrderComparator.sort(instances);
        return instances;
    }


    /**
     * Load the fully qualified class names of factory implementations of the
     * given type from {@value #FACTORIES_RESOURCE_LOCATION}, using the given
     * class loader.
     * <p>As of Spring Framework 5.3, if a particular implementation class name
     * is discovered more than once for the given factory type, duplicates will
     * be ignored.
     *
     * @param factoryType the interface or abstract class representing the factory
     * @param classLoader the ClassLoader to use for loading resources; can be
     *                    {@code null} to use the default
     * @throws IllegalArgumentException if an error occurs while loading factory names
     * @see #loadFactories
     */
    public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        ClassLoader classLoaderToUse = classLoader;
        if (classLoaderToUse == null) {
            classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
        }
        String factoryTypeName = factoryType.getName();
        return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
    }


    /**
     * Springboot自動配置的祕密
     * Springboot在啟動時讀取了所有starter jar包裡的META-INF/spring.factories配置檔案，實現了所謂的自動化配置
     * 這裡jar包裡的都是預設配置，後續Springboot也會從xml、yaml檔案中的使用者配置去覆蓋同名的配置。
     * 另外，這裡的快取配置是儲存在一個map型別的cache中，其中的key鍵對應上面提到的各種Type型別，value就是Type的各種初始jar包裡的同型別Java類。
     */
    private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
        // 獲取相應類載入器中內容
        Map<String, List<String>> result = cache.get(classLoader);
        // 存在則直接返回類載入器中內容
        if (result != null) {
            return result;
        }
        // 不存在則初始化類載入器中內容
        result = new HashMap<>();
        try {
            /**
             * 獲取資源 -> META-INF/spring.factories 列表
             * 其中FACTORIES_RESOURCE_LOCATION的值：META-INF/spring.factories
             */
            Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
            // 可能存在多個META-INF/spring.factories 檔案,迴圈載入
            while (urls.hasMoreElements()) {
                // 獲取 META-INF/spring.factories 檔案URL地址
                URL url = urls.nextElement();
                // 載入資源
                UrlResource resource = new UrlResource(url);
                // 載入資源配置
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                // key:value形式迴圈配置
                for (Map.Entry<?, ?> entry : properties.entrySet()) {
                    String factoryTypeName = ((String) entry.getKey()).trim();
                    // 逗號分隔列表到字串陣列
                    String[] factoryImplementationNames =
                            StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
                    // 迴圈value中子項到列表中
                    for (String factoryImplementationName : factoryImplementationNames) {
                        result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())
                                .add(factoryImplementationName.trim());
                    }
                }
            }

            // Replace all lists with unmodifiable lists containing unique elements
            // 列表去重
            result.replaceAll((factoryType, implementations) -> implementations.stream().distinct()
                    .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)));
            // 列表儲存
            cache.put(classLoader, result);
        } catch (IOException ex) {
            throw new IllegalArgumentException("Unable to load factories from location [" +
                    FACTORIES_RESOURCE_LOCATION + "]", ex);
        }
        return result;
    }


    /**
     * 反射建立實現類
     */
    private <T> List<T> createSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes,
                                                       ClassLoader classLoader, Object[] args, Set<String> names) {
        List<T> instances = new ArrayList<>(names.size());
        for (String name : names) {
            try {
                Class<?> instanceClass = ClassUtils.forName(name, classLoader);
                Assert.isAssignable(type, instanceClass);
                Constructor<?> constructor = instanceClass.getDeclaredConstructor(parameterTypes);
                T instance = (T) BeanUtils.instantiateClass(constructor, args);
                instances.add(instance);
            } catch (Throwable ex) {
                throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, ex);
            }
        }
        return instances;
    }

1.4、deduceMainApplicationClass

deduceMainApplicationClass 推導主應用程式類。

private Class<?> deduceMainApplicationClass()

 /**
     * 推導主應用程式類
     * @return
     */
    private Class<?> deduceMainApplicationClass() {
        try {
            // 獲取當前的棧資訊
            StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
            for (StackTraceElement stackTraceElement : stackTrace) {
                // 獲取main方法所在的類class，此處即com.iot.SpringBootLoveApplication
                if ("main".equals(stackTraceElement.getMethodName())) {
                    return Class.forName(stackTraceElement.getClassName());
                }
            }
        }
        catch (ClassNotFoundException ex) {
            // Swallow and continue
        }
        return null;
    }

2、run方法

初始化完SpringApplication 就可以執行他的run方法了，也就是啟動方法中的第二階段。

public ConfigurableApplicationContext run(String... args)

/**
     * 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();
        // 建立啟動上下文物件即spring根容器
        DefaultBootstrapContext bootstrapContext = createBootstrapContext();
        // 定義可配置的應用程式上下文變數
        ConfigurableApplicationContext context = null;
        /**
         * 設定jdk系統屬性
         * headless直譯就是無頭模式，
         * headless模式的意思就是明確Springboot要在無鼠鍵支援的環境中執行，一般程式也都跑在Linux之類的伺服器上，無鼠鍵支援，這裡預設值是true；
         */
        configureHeadlessProperty();
        /**
         * 獲取執行監聽器 getRunListeners, 其中也是呼叫了上面說到的getSpringFactoriesInstances 方法
         * 從spring.factories中獲取配置
         */
        SpringApplicationRunListeners listeners = getRunListeners(args);
        // 啟動監聽器
        listeners.starting(bootstrapContext, this.mainApplicationClass);
        try {
            // 包裝預設應用程式引數，也就是在命令列下啟動應用帶的引數，如--server.port=9000
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            //
            /**
             * 準備環境 prepareEnvironment 是個硬茬，裡面主要涉及到
             * getOrCreateEnvironment、configureEnvironment、configurePropertySources、configureProfiles
             * environmentPrepared、bindToSpringApplication、attach諸多方法可以在下面的例子中檢視
             */
            ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
            // 配置忽略的 bean
            configureIgnoreBeanInfo(environment);
            // 列印 SpringBoot 標誌，即啟動的時候在控制檯的圖案logo，可以在src/main/resources下放入名字是banner的自定義檔案
            Banner printedBanner = printBanner(environment);
            // 建立 IOC 容器
            context = createApplicationContext();
            // 設定一個啟動器，設定應用程式啟動
            context.setApplicationStartup(this.applicationStartup);
            // 配置 IOC 容器的基本資訊 (spring容器前置處理)
            prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
            /**
             * 重新整理IOC容器
             * 這裡會涉及Spring容器啟動、自動裝配、建立 WebServer啟動Web服務即SpringBoot啟動內嵌的 Tomcat
             */
            refreshContext(context);
            /**
             * 留給使用者自定義容器重新整理完成後的處理邏輯
             * 重新整理容器後的擴充套件介面(spring容器後置處理)
             */
            afterRefresh(context, applicationArguments);
            // 結束計時器並列印，這就是我們啟動後console的顯示的時間
            stopWatch.stop();
            if (this.logStartupInfo) {
                // 列印啟動完畢的那行日誌
                new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
            }
            // 釋出監聽應用上下文啟動完成（發出啟動結束事件），所有的執行監聽器呼叫 started() 方法
            listeners.started(context);
            // 執行runner，遍歷所有的 runner，呼叫 run 方法
            callRunners(context, applicationArguments);
        } catch (Throwable ex) {
            // 異常處理，如果run過程發生異常
            handleRunFailure(context, ex, listeners);
            throw new IllegalStateException(ex);
        }

        try {
            // 所有的執行監聽器呼叫 running() 方法,監聽應用上下文
            listeners.running(context);
        } catch (Throwable ex) {
            // 異常處理
            handleRunFailure(context, ex, null);
            throw new IllegalStateException(ex);
        }
        // 返回最終構建的容器物件
        return context;
    }

2.1、configureHeadlessProperty

configureHeadlessProperty 設定headless無頭模式。

private void configureHeadlessProperty()

    private static final String SYSTEM_PROPERTY_JAVA_AWT_HEADLESS = "java.awt.headless";
    
    /**
     * headless直譯就是無頭模式，
     * headless模式的意思就是明確Springboot要在無鼠鍵支援的環境中執行，一般程式也都跑在Linux之類的伺服器上，無鼠鍵支援，這裡預設值是true；
     */
    private void configureHeadlessProperty() {
        // SYSTEM_PROPERTY_JAVA_AWT_HEADLESS = "java.awt.headless";
        System.setProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS,
                System.getProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, Boolean.toString(this.headless)));
    }

2.2、prepareEnvironment

prepareEnvironment 準備環境是個硬茬，裡面主要涉及到getOrCreateEnvironment、configureEnvironment、configurePropertySources、configureProfilesenvironmentPrepared、bindToSpringApplication、attach諸多方法。

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) 

    /**
     * 準備環境
     *
     * @param listeners
     * @param bootstrapContext
     * @param applicationArguments
     * @return
     */
    private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
                                                       DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
        // Create and configure the environment 建立和配置環境
        // 根據專案型別建環境ConfigurableEnvironment
        ConfigurableEnvironment environment = getOrCreateEnvironment();
        // 從環境中獲取並設定 PropertySources 和 activeProfiles
        configureEnvironment(environment, applicationArguments.getSourceArgs());
        // 把 PropertySources 設定在自己PropertySources的第一個位置
        ConfigurationPropertySources.attach(environment);
        /**
         * 執行監聽器呼叫
         * 廣播事件，listeners環境準備(就是廣播ApplicationEnvironmentPreparedEvent事件)
         * 釋出事件通知所有的監聽器當前環境準備完成
         */
        listeners.environmentPrepared(bootstrapContext, environment);
        // 移動 defaultProperties 屬性源到環境中的最後一個源
        DefaultPropertiesPropertySource.moveToEnd(environment);
        // 斷言 拋異常
        Assert.state(!environment.containsProperty("spring.main.environment-prefix"),
                "Environment prefix cannot be set via properties.");
        // 與容器繫結當前環境
        bindToSpringApplication(environment);
        // 若非web環境，將環境轉換成StandardEnvironment
        if (!this.isCustomEnvironment) {
            environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,
                    deduceEnvironmentClass());
        }
        // 配置PropertySources對它自己的遞迴依賴
        ConfigurationPropertySources.attach(environment);
        return environment;
    }


    /**
     * 獲取或建立環境Environment
     *
     * @return
     */
    private ConfigurableEnvironment getOrCreateEnvironment() {
        // 存在則直接返回
        if (this.environment != null) {
            return this.environment;
        }
        /**
         * 根據webApplicationType建立對應的Environment
         */
        switch (this.webApplicationType) {
            // SERVLET WEB 專案
            case SERVLET:
                return new ApplicationServletEnvironment();
            // REACTIVE：響應式WEB專案
            case REACTIVE:
                return new ApplicationReactiveWebEnvironment();
            // 非WEB專案,就是一個最簡單的Springboot應用
            default:
                return new ApplicationEnvironment();
        }
    }

    /**
     * 從環境中獲取並設定 PropertySources 和 activeProfiles
     * 將配置任務按順序委託給configurePropertySources和configureProfiles
     * Template method delegating to
     * {@link #configurePropertySources(ConfigurableEnvironment, String[])} and
     * {@link #configureProfiles(ConfigurableEnvironment, String[])} in that order.
     * Override this method for complete control over Environment customization, or one of
     * the above for fine-grained control over property sources or profiles, respectively.
     *
     * @param environment this application's environment
     * @param args        arguments passed to the {@code run} method
     * @see #configureProfiles(ConfigurableEnvironment, String[])
     * @see #configurePropertySources(ConfigurableEnvironment, String[])
     */
    protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
        if (this.addConversionService) {
            environment.setConversionService(new ApplicationConversionService());
        }
        // 配置PropertySources
        configurePropertySources(environment, args);
        // 配置Profiles
        configureProfiles(environment, args);
    }

    /**
     * 配置PropertySources
     * Add, remove or re-order any {@link PropertySource}s in this application's
     * environment.
     *
     * @param environment this application's environment
     * @param args        arguments passed to the {@code run} method
     * @see #configureEnvironment(ConfigurableEnvironment, String[])
     */
    protected void configurePropertySources(ConfigurableEnvironment environment, String[] args) {
        MutablePropertySources sources = environment.getPropertySources();
        // 初始化 defaultProperties
        if (!CollectionUtils.isEmpty(this.defaultProperties)) {
            // 存在的話將其放到最後位置
            DefaultPropertiesPropertySource.addOrMerge(this.defaultProperties, sources);
        }
        /**
         * 存在命令列引數，則解析它並封裝進SimpleCommandLinePropertySource物件
         * 同時將此物件放到sources的第一位置（優先順序最高）
         */
        if (this.addCommandLineProperties && args.length > 0) {
            String name = CommandLinePropertySource.COMMAND_LINE_PROPERTY_SOURCE_NAME;
            if (sources.contains(name)) {
                PropertySource<?> source = sources.get(name);
                CompositePropertySource composite = new CompositePropertySource(name);
                composite.addPropertySource(
                        new SimpleCommandLinePropertySource("springApplicationCommandLineArgs", args));
                composite.addPropertySource(source);
                sources.replace(name, composite);
            } else {
                // 放到首位
                sources.addFirst(new SimpleCommandLinePropertySource(args));
            }
        }
    }

    /**
     * 配置Profiles
     *
     * @param environment
     * @param args
     */
    protected void configureProfiles(ConfigurableEnvironment environment, String[] args) {
        /**
         * 保證environment的activeProfiles屬性被初始化了。從PropertySources中查詢spring.profiles.active屬性
         * 存在則將其值新增activeProfiles集合中。
         * 配置應用環境中的哪些配置檔案處於啟用狀態(或預設啟用)
         * 可以通過spring.profiles.active屬性在配置檔案處理期間啟用其他配置檔案
         * 就是我們專案中通常配置的dev、sit、prod等環境配置資訊設定哪些Profiles是啟用的。
         */
        environment.getActiveProfiles(); // ensure they are initialized
        // But these ones should go first (last wins in a property key clash)
        // 如果存在其他的Profiles，則將這些Profiles放到第一的位置
        Set<String> profiles = new LinkedHashSet<>(this.additionalProfiles);
        profiles.addAll(Arrays.asList(environment.getActiveProfiles()));
        environment.setActiveProfiles(StringUtils.toStringArray(profiles));
    }

    /**
     * 執行監聽器呼叫
     *
     * @param bootstrapContext
     * @param environment
     */
    void environmentPrepared(ConfigurableBootstrapContext bootstrapContext, ConfigurableEnvironment environment) {
        doWithListeners("spring.boot.application.environment-prepared",
                (listener) -> listener.environmentPrepared(bootstrapContext, environment));
    }

    /**
     * 執行監聽器呼叫
     * Called once the environment has been prepared, but before the
     * {@link ApplicationContext} has been created.
     *
     * @param environment the environment
     * @deprecated since 2.4.0 for removal in 2.6.0 in favor of
     * {@link #environmentPrepared(ConfigurableBootstrapContext, ConfigurableEnvironment)}
     */
    @Deprecated
    default void environmentPrepared(ConfigurableEnvironment environment) {
        for (SpringApplicationRunListener listener : this.listeners) {
            // 廣播ApplicationEnvironmentPreparedEvent事件,後面再看
            listener.environmentPrepared(environment);
        }
    }

    /**
     * 與容器繫結當前環境
     * Bind the environment to the {@link SpringApplication}.
     *
     * @param environment the environment to bind
     */
    protected void bindToSpringApplication(ConfigurableEnvironment environment) {
        try {
            // 將environment繫結到SpringApplication
            Binder.get(environment).bind("spring.main", Bindable.ofInstance(this));
        } catch (Exception ex) {
            throw new IllegalStateException("Cannot bind to SpringApplication", ex);
        }
    }

    /**
     * 配置PropertySources對它自己的遞迴依賴
     * Attach a {@link ConfigurationPropertySource} support to the specified
     * {@link Environment}. Adapts each {@link PropertySource} managed by the environment
     * to a {@link ConfigurationPropertySource} and allows classic
     * {@link PropertySourcesPropertyResolver} calls to resolve using
     * {@link ConfigurationPropertyName configuration property names}.
     * <p>
     * The attached resolver will dynamically track any additions or removals from the
     * underlying {@link Environment} property sources.
     *
     * @param environment the source environment (must be an instance of
     *                    {@link ConfigurableEnvironment})
     * @see #get(Environment)
     */
    public static void attach(Environment environment) {
        // 判斷environment是否是ConfigurableEnvironment的例項
        Assert.isInstanceOf(ConfigurableEnvironment.class, environment);
        // 從environment獲取PropertySources
        MutablePropertySources sources = ((ConfigurableEnvironment) environment)
                .getPropertySources();
        PropertySource<?> attached = sources.get(ATTACHED_PROPERTY_SOURCE_NAME);
        if (attached != null && attached.getSource() != sources) {
            sources.remove(ATTACHED_PROPERTY_SOURCE_NAME);
            attached = null;
        }
        if (attached == null) {
            // 將sources封裝成ConfigurationPropertySourcesPropertySource物件，並把這個物件放到sources的第一位置
            sources.addFirst(new ConfigurationPropertySourcesPropertySource(
                    ATTACHED_PROPERTY_SOURCE_NAME,
                    new SpringConfigurationPropertySources(sources)));
        }
    }

2.3、printBanner

printBanner 列印SpringBoot標誌。printBanner(environment)方法就是列印Banner，Banner就是專案啟動時看到的那個logo。在工程專案src/main/resources路徑下下放入名字是banner的檔案，字尾後可以是SpringApplicationBannerPrinter.java類裡的{ "gif", "jpg", "png" }，或者是txt、圖片也可以的，但是圖片列印時會字元化，而不是列印圖片本身。自定義banner連結

 private Banner printBanner(ConfigurableEnvironment environment)

    /**
     * 列印SpringBoot標誌
     * banner的輸出預設有三種種模式，LOG、CONSOLE、OFF。
     * 1. LOG：將banner資訊輸出到日誌檔案。
     * 2. CONSOLE：將banner資訊輸出到控制檯。
     * 3. OFF：禁用banner的資訊輸出。
     *
     * @param environment
     * @return
     */
    private Banner printBanner(ConfigurableEnvironment environment) {
        // 判斷Banner的模式是否關閉，如果關閉直接返回。
        if (this.bannerMode == Banner.Mode.OFF) {
            return null;
        }
        ResourceLoader resourceLoader = (this.resourceLoader != null) ? this.resourceLoader
                : new DefaultResourceLoader(null);
        // 建立SpringApplicationBannerPrinter 列印類
        SpringApplicationBannerPrinter bannerPrinter = new SpringApplicationBannerPrinter(resourceLoader, this.banner);
        // LOG：將banner資訊輸出到日誌檔案
        if (this.bannerMode == Mode.LOG) {
            return bannerPrinter.print(environment, this.mainApplicationClass, logger);
        }
        //banner沒有關閉且沒有指定是寫到log檔案中 將banner資訊輸出到控制檯
        return bannerPrinter.print(environment, this.mainApplicationClass, System.out);
    }

    /**
     * 列印
     *
     * @param environment
     * @param sourceClass
     * @param logger
     * @return
     */
    Banner print(Environment environment, Class<?> sourceClass, Log logger) {
        // 獲取banner內容
        Banner banner = getBanner(environment);
        try {
            logger.info(createStringFromBanner(banner, environment, sourceClass));
        } catch (UnsupportedEncodingException ex) {
            logger.warn("Failed to create String for banner", ex);
        }
        return new PrintedBanner(banner, sourceClass);
    }

    /**
     * 獲取banner內容
     *
     * @param environment
     * @return
     */
    private Banner getBanner(Environment environment) {
        Banners banners = new Banners();
        // 圖片型別的banner內容
        banners.addIfNotNull(getImageBanner(environment));
        // 文字型別的banner內容
        banners.addIfNotNull(getTextBanner(environment));
        if (banners.hasAtLeastOneBanner()) {
            return banners;
        }
        if (this.fallbackBanner != null) {
            return this.fallbackBanner;
        }
        return DEFAULT_BANNER;
    }

    static final String BANNER_LOCATION_PROPERTY = "spring.banner.location";
    static final String DEFAULT_BANNER_LOCATION = "banner.txt";

    /**
     * 文字型別的banner內容獲取
     *
     * @param environment
     * @return
     */
    private Banner getTextBanner(Environment environment) {
        /**
         * 拿到自定義配置的banner檔案地址
         * BANNER_LOCATION_PROPERTY = "spring.banner.location"
         * DEFAULT_BANNER_LOCATION = "banner.txt";
         */
        String location = environment.getProperty(BANNER_LOCATION_PROPERTY, DEFAULT_BANNER_LOCATION);
        Resource resource = this.resourceLoader.getResource(location);
        try {
            if (resource.exists() && !resource.getURL().toExternalForm().contains("liquibase-core")) {
                return new ResourceBanner(resource);
            }
        } catch (IOException ex) {
            // Ignore
        }
        return null;
    }

2.4、createApplicationContext

createApplicationContext建立IOC容器。

protected ConfigurableApplicationContext createApplicationContext() 

    /**
     * 建立 IOC 容器
     * A default {@link ApplicationContextFactory} implementation that will create an
     * appropriate context for the {@link WebApplicationType}.
     */
    ApplicationContextFactory DEFAULT = (webApplicationType) -> {
        try {
            // 根據當前應用的型別建立 IOC 容器
            switch (webApplicationType) {
                // Web 應用環境對應 AnnotationConfigServletWebServerApplicationContext
                case SERVLET:
                    return new AnnotationConfigServletWebServerApplicationContext();
                // 響應式程式設計對應 AnnotationConfigReactiveWebServerApplicationContext
                case REACTIVE:
                    return new AnnotationConfigReactiveWebServerApplicationContext();
                // 預設為 Spring 環境 AnnotationConfigApplicationContext
                default:
                    return new AnnotationConfigApplicationContext();
            }
        }
        catch (Exception ex) {
            throw new IllegalStateException("Unable create a default ApplicationContext instance, "
                    + "you may need a custom ApplicationContextFactory", ex);
        }
    };

    /**
     * 設定一個啟動器
     * Set the {@link ApplicationStartup} for this application context.
     * <p>This allows the application context to record metrics
     * during startup.
     * @param applicationStartup the new context event factory
     * @since 5.3
     */
    void setApplicationStartup(ApplicationStartup applicationStartup);

2.5、prepareContext

prepareContext 配置 IOC 容器的基本資訊。

private void prepareContext(引數此處省略)

    /**
     * 準備IOC容器基本資訊
     * @param bootstrapContext
     * @param context
     * @param environment
     * @param listeners
     * @param applicationArguments
     * @param printedBanner
     */
    private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,
                                ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
                                ApplicationArguments applicationArguments, Banner printedBanner) {
        // 設定容器環境，包括各種變數
        context.setEnvironment(environment);
        /**
         * 後置處理流程
         * 設定IOC容器的 bean 生成器和資源載入器
         */
        postProcessApplicationContext(context);
        /**
         * 獲取所有的初始化器呼叫 initialize() 方法進行初始化
         * 執行容器中的ApplicationContextInitializer（包括從 spring.factories和自定義的例項）初始化
         */
        applyInitializers(context);
        /**
         * 觸發所有 SpringApplicationRunListener 監聽器的 contextPrepared 事件方法
         * 所有的執行監聽器呼叫 environmentPrepared() 方法，EventPublishingRunListener 釋出事件通知 IOC 容器準備完成
         */
        listeners.contextPrepared(context);
        bootstrapContext.close(context);
        // 列印啟動日誌
        if (this.logStartupInfo) {
            logStartupInfo(context.getParent() == null);
            logStartupProfileInfo(context);
        }
        // Add boot specific singleton beans
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        // 註冊新增特定的單例bean
        beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
        if (printedBanner != null) {
            beanFactory.registerSingleton("springBootBanner", printedBanner);
        }
        if (beanFactory instanceof DefaultListableBeanFactory) {
            ((DefaultListableBeanFactory) beanFactory)
                    .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
        }
        if (this.lazyInitialization) {
            context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
        }
        // Load the sources
        // 載入所有資源
        Set<Object> sources = getAllSources();
        // 斷言資源費控
        Assert.notEmpty(sources, "Sources must not be empty");
        // 建立BeanDefinitionLoader，載入啟動類，將啟動類注入容器
        load(context, sources.toArray(new Object[0]));
        // 觸發所有 SpringApplicationRunListener 監聽器的 contextLoaded 事件方法
        listeners.contextLoaded(context);
    }

2.6、refresh

refresh 重新整理應用上下文，即重新整理Spring上下文資訊refreshContext。這裡會涉及Spring容器啟動、SpringBoot自動裝配、建立 WebServer啟動Web服務即SpringBoot啟動內嵌的 Tomcat。

private void refreshContext(ConfigurableApplicationContext context) 

    /**
     * 重新整理應用上下文
     *
     * @param context
     */
    private void refreshContext(ConfigurableApplicationContext context) {
        if (this.registerShutdownHook) {
            // 判斷是否註冊關閉的鉤子，是則註冊鉤子
            shutdownHook.registerApplicationContext(context);
        }
        refresh(context);
    }

    /**
     * Refresh the underlying {@link ApplicationContext}.
     *
     * @param applicationContext the application context to refresh
     */
    protected void refresh(ConfigurableApplicationContext applicationContext) {
        applicationContext.refresh();
    }

    /**
     * 重新整理IOC容器
     *
     * @throws BeansException
     * @throws IllegalStateException
     */
    @Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

            // Prepare this context for refreshing. 準備重新整理上下文
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory. 通知子類重新整理內部工廠
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context. 準備Bean工廠
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                // 允許在上下文子類中對bean工廠進行後處理,這部分涉及Web伺服器的啟動，如servlet
                postProcessBeanFactory(beanFactory);

                StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
                // Invoke factory processors registered as beans in the context.
                // 呼叫在上下文中註冊為 bean 的工廠處理器
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation. 註冊攔截 bean 建立的 bean 處理器
                registerBeanPostProcessors(beanFactory);
                beanPostProcess.end();

                // Initialize message source for this context. 初始化此上下文的訊息源
                initMessageSource();

                // Initialize event multicaster for this context. 為該上下文初始化事件多播器
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses. 初始化特定上下文子類中的其他特殊 bean
                /**
                 * SpringBoot 一鍵啟動web工程的關鍵方法
                 * 建立 WebServer啟動Web服務
                 * SpringBoot啟動內嵌的 Tomcat 首先要在pom檔案配置內嵌容器為tomcat
                 * SpringBoot 嵌入式 Servlet 容器，預設支援的 webServe：Tomcat、Jetty、Undertow
                 *          <exclusion>
                 *             <groupId>org.springframework.boot</groupId>
                 *             <artifactId>spring-boot-starter-tomcat</artifactId>
                 *         </exclusion>
                 */
                onRefresh();

                // Check for listener beans and register them. 檢查偵聽器 bean 並註冊
                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons. 例項化所有剩餘的（非延遲初始化）單例
                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.  銷燬bean
                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();
                contextRefresh.end();
            }
        }
    }

2.7、onRefresh

onRefresh方法中建立WebServer、建立Tomcat物件，是SpringBoot一鍵啟動web工程的關鍵。SpringBoot 嵌入式 Servlet 容器，預設支援的 webServe：Tomcat、Jetty、Undertow，但要在POM檔案加入tomcat相關配置。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion> <!--必須要把內嵌的 Tomcat 容器-->
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

protected void onRefresh() throws BeansException 

    /**
     * 建立 WebServer啟動Web服務
     */
    @Override
    protected void onRefresh() {
        // 初始化給定應用程式上下文的主題資源
        super.onRefresh();
        try {
            // 建立Web 服務
            createWebServer();
        }
        catch (Throwable ex) {
            throw new ApplicationContextException("Unable to start web server", ex);
        }
    }

    /**
     * super.onRefresh();
     * Initialize the theme capability.
     */
    @Override
    protected void onRefresh() {
        /**
         * 初始化給定應用程式上下文的主題資源，自動檢測一個名為“themeSource”的bean。
         * 如果沒有這樣的，將使用預設的(空的)ThemeSource。
         */
        this.themeSource = UiApplicationContextUtils.initThemeSource(this);
    }

    /**
     * 建立Web 服務
     */
    private void createWebServer() {
        WebServer webServer = this.webServer;
        ServletContext servletContext = getServletContext();
        if (webServer == null && servletContext == null) {
            // 獲取web server
            StartupStep createWebServer = this.getApplicationStartup().start("spring.boot.webserver.create");
            // 獲取建立容器的工廠
            ServletWebServerFactory factory = getWebServerFactory();
            createWebServer.tag("factory", factory.getClass().toString());
            /**
             * 獲取 tomcat 、Jetty 或 Undertow 容器
             * 從 getWebServer 方法點進去，找到 TomcatServletWebServerFactory 的實現方法，
             * 與之對應的還有 Jetty 和 Undertow。這裡配置了基本的聯結器、引擎、虛擬站點等配置。
             * 自動配置類 ServletWebServerFactoryAutoConfiguration 匯入了 ServletWebServerFactoryConfiguration（配置類）,
             * 根據條件裝配判斷系統中到底匯入了哪個 Web 伺服器的包，建立出伺服器並啟動
             * 預設是 web-starter 匯入 tomcat 包，容器中就有 TomcatServletWebServerFactory，建立出 Tomcat 伺服器並啟動
             */
            this.webServer = factory.getWebServer(getSelfInitializer());
            createWebServer.end();
            getBeanFactory().registerSingleton("webServerGracefulShutdown",
                    new WebServerGracefulShutdownLifecycle(this.webServer));
            getBeanFactory().registerSingleton("webServerStartStop",
                    new WebServerStartStopLifecycle(this, this.webServer));
        }
        else if (servletContext != null) {
            try {
                // 啟動web server
                getSelfInitializer().onStartup(servletContext);
            }
            catch (ServletException ex) {
                throw new ApplicationContextException("Cannot initialize servlet context", ex);
            }
        }
        initPropertySources();
    }

    /**
     * 獲取tomcat 容器
     * 配置了基本的聯結器、引擎、虛擬站點等配置
     * @param initializers
     * @return
     */
    @Override
    public WebServer getWebServer(ServletContextInitializer... initializers) {
        if (this.disableMBeanRegistry) {
            Registry.disableRegistry();
        }
        /**
         * 建立了Tomcat物件，並設定引數
         */
        Tomcat tomcat = new Tomcat();
        // 設定工作忙碌
        File baseDir = (this.baseDirectory != null) ? this.baseDirectory : createTempDir("tomcat");
        tomcat.setBaseDir(baseDir.getAbsolutePath());
        // 初始化tomcat 連線，預設NIO
        Connector connector = new Connector(this.protocol);
        connector.setThrowOnFailure(true);
        tomcat.getService().addConnector(connector);
        customizeConnector(connector);
        // 配置基本的聯結器、引擎、虛擬站點
        tomcat.setConnector(connector);
        // 設定自動部署為false
        tomcat.getHost().setAutoDeploy(false);
        configureEngine(tomcat.getEngine());
        for (Connector additionalConnector : this.additionalTomcatConnectors) {
            tomcat.getService().addConnector(additionalConnector);
        }
        // 準備上下文
        prepareContext(tomcat.getHost(), initializers);
        // 返回TomcatWebServer服務
        return getTomcatWebServer(tomcat);
    }

    /**
     * Create a new {@link TomcatWebServer} instance.
     * @param tomcat the underlying Tomcat server
     * @param autoStart if the server should be started
     * @param shutdown type of shutdown supported by the server
     * @since 2.3.0
     */
    public TomcatWebServer(Tomcat tomcat, boolean autoStart, Shutdown shutdown) {
        Assert.notNull(tomcat, "Tomcat Server must not be null");
        this.tomcat = tomcat;
        this.autoStart = autoStart;
        this.gracefulShutdown = (shutdown == Shutdown.GRACEFUL) ? new GracefulShutdown(tomcat) : null;
        // 初始化Tomcat
        initialize();
    }

    /**
     * 初始化Tomcat
     * @throws WebServerException
     */
    private void initialize() throws WebServerException {
        logger.info("Tomcat initialized with port(s): " + getPortsDescription(false));
        synchronized (this.monitor) {
            try {
                addInstanceIdToEngineName();

                Context context = findContext();
                context.addLifecycleListener((event) -> {
                    if (context.equals(event.getSource()) && Lifecycle.START_EVENT.equals(event.getType())) {
                        // Remove service connectors so that protocol binding doesn't
                        // happen when the service is started.
                        removeServiceConnectors();
                    }
                });

                // Start the server to trigger initialization listeners
                this.tomcat.start();

                // We can re-throw failure exception directly in the main thread
                rethrowDeferredStartupExceptions();

                try {
                    ContextBindings.bindClassLoader(context, context.getNamingToken(), getClass().getClassLoader());
                }
                catch (NamingException ex) {
                    // Naming is not enabled. Continue
                }

                // Unlike Jetty, all Tomcat threads are daemon threads. We create a
                // blocking non-daemon to stop immediate shutdown
                startDaemonAwaitThread();
            }
            catch (Exception ex) {
                stopSilently();
                destroySilently();
                throw new WebServerException("Unable to start embedded Tomcat", ex);
            }
        }
    }

2.8、afterRefresh

afterReftesh() 重新整理後處理，是個一空實現的擴充套件介面，留著後期擴充套件如使用者自定義容器重新整理後的處理邏輯。

2.9、停止計時並列印啟動完畢相關日誌

2.10、started

started 釋出監聽應用啟動事件。

void started(ConfigurableApplicationContext context)  

    /**
     * 釋出應用監聽啟動事件
     * @param context
     */
    void started(ConfigurableApplicationContext context) {
        // listener.started(context) 中交由context.publishEvent（）方法處理
        // 實際上是傳送了一個ApplicationStartedEvent的事件
        doWithListeners("spring.boot.application.started", (listener) -> listener.started(context));
    }

    /**
     * 釋出應用啟動事件ApplicationStartedEvent.
     * @param context
     */
    @Override
    public void started(ConfigurableApplicationContext context) {
        context.publishEvent(new ApplicationStartedEvent(this.application, this.args, context));
        AvailabilityChangeEvent.publish(context, LivenessState.CORRECT);
    }

2.11、callRunners

callRunners，執行runner主要是遍歷所有的runner獲取所有的ApplicationRuner 和CommandLineRunner 來初始化引數，其中callRuner（是一個回撥函式)。

private void callRunners(ApplicationContext context, ApplicationArguments args) 

    /**
     * 執行runner 初始化引數
     * @param context
     * @param args
     */
    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);
        // 遍歷所有runner
        for (Object runner : new LinkedHashSet<>(runners)) {
            if (runner instanceof ApplicationRunner) {
                /**
                 * 回撥函式callRunner 處理 ApplicationRunner
                 */
                callRunner((ApplicationRunner) runner, args);
            }
            if (runner instanceof CommandLineRunner) {
                /**
                 * 回撥函式callRunner 處理 CommandLineRunner
                 */
                callRunner((CommandLineRunner) runner, args);
            }
        }
    }

2.12、running

running 釋出上下文完成準備事件，listeners.running() 釋出上下文完成準備事件同前面的listeners.started() 方法一樣，都是釋出了一個running事件，程式碼也相同。

void running(ConfigurableApplicationContext context) 

    /**
     * 釋出上下文完成準備事件
     * 與上面的 listeners.started() 方法一樣
     * @param context
     */
    void running(ConfigurableApplicationContext context) {
        // listener.started(context) 中交由context.publishEvent（）方法處理
        // 實際上是傳送了一個ApplicationStartedEvent的事件
        doWithListeners("spring.boot.application.running", (listener) -> listener.running(context));
    }

    /**
     * 釋出上下文完成準備事件
     * Called immediately before the run method finishes, when the application context has
     * been refreshed and all {@link CommandLineRunner CommandLineRunners} and
     * {@link ApplicationRunner ApplicationRunners} have been called.
     * @param context the application context.
     * @since 2.0.0
     */
    @Override
    public void running(ConfigurableApplicationContext context) {
        context.publishEvent(new ApplicationReadyEvent(this.application, this.args, context));
        AvailabilityChangeEvent.publish(context, ReadinessState.ACCEPTING_TRAFFIC);
    }

這也是SpringBoot啟動流程兩大過程中的第二階段的啟動方法run中最後一個方法了，該方法執行完成後，SpringApplication的run(String... args)方法執行結束，至此Spring Boot的ApplicationContext 啟動結束。

四、總結

SpringBoot啟動流程總結就是下面兩張圖片，一個建立SpringApplication例項，一個執行run方法，所有的貓膩都在其中。

 

 

 

 

 

君生我未生

　　　　君生我已老

　　　　　　　　君恨我生遲

　　　　      　　　　　　我恨君生早