SpringBoot一站式啟動流程原始碼分析

阿豪聊乾貨發表於2018-06-06
Spring Boot原始碼

一、前言

　　由上篇文章我們得知，SpringBoot啟動時，就是有很簡單的一行程式碼。那我們可以很清楚的看到這行程式碼的主角便是SpringApplication了，本文我們就來聊一聊這貨，來探尋SpringBoot的一站式啟動流程。

​　　其實SpringApplication 是將一個典型的Spring應用的啟動流程”模板化”了，在沒有特殊定製需求的情況下，預設的模板化後的執行流程就能滿足我們的需求了。即便是我們有了特殊的需求也沒有太大關係，SpringApplication在內部合適的啟動節點給我們提供了一系列不同型別的擴充套件點，我們就可以通過這些開放的擴充套件點來對SpringBoot程式的啟動和關閉過程來進行定製和擴充套件。

二、關於定製

　SpringApplication中提供的最簡單的定製方式當屬設定方法(Setters)定製了。例如，我們可以把啟動類改成如下的方式來擴充套件啟動行為：

@SpringBootApplication
public class DemoApplication {
    public void main(String[] args) {
        // SpringApplication.run(DemoApplication.class, args);
        SpringApplication bootstrap = new SpringApplication(DemoApplication.class);
        bootstrap.setBanner(new Banner() {
            @Override
            public void printBanner(Environment environment, Class<?> aClass, PrintStream printStream) {
                System.out.println("My custom banner...");
            }
        });
        bootstrap.setBannerMode(Bannder.Mode.CONSOLE);
        bootstrap.run(args);
    }
}

​　　大多數的情況下，SpringApplication預設已經提供好了設定，我們基本不需要再對這些表層進行研究了，對錶象之下的本質才是我們最應該探究的課題。

三、揭祕SpringApplication的執行流程　

　　因為啟動程式的程式碼中執行的就是SpringApplication的run方法，所以我們執行流程當然就要從這個run方法開始，先上原始碼：

public class SpringApplication { 
    public SpringApplication(Object... sources) {
        initialize(sources);
    }
    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);
    }
}

  可以看出，啟動時：呼叫run方法先建立一個SpringApplication物件例項，然後呼叫建立好的SpringApplication的例項的run方法。在SpringApplication例項化的時候，它又會執行以下程式碼：

private static final String[] WEB_ENVIRONMENT_CLASSES = { "javax.servlet.Servlet",
            "org.springframework.web.context.ConfigurableWebApplicationContext" };
private void initialize(Object[] sources) {
    if (sources != null && sources.length > 0) {
        this.sources.addAll(Arrays.asList(sources));
    }
    this.webEnvironment = deduceWebEnvironment(); // 1
    setInitializers((Collection) getSpringFactoriesInstances(
                ApplicationContextInitializer.class)); // 2
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class)); // 3
    this.mainApplicationClass = deduceMainApplicationClass(); // 4
}
private boolean deduceWebEnvironment() {
    for (String className : WEB_ENVIRONMENT_CLASSES) {
        if (!ClassUtils.isPresent(className, null)) {
            return false;
        }
    }
    return true;
}
private <T> Collection<? extends T> getSpringFactoriesInstances(Class<T> type) {
    return getSpringFactoriesInstances(type, new Class<?>[] {});
}
public void setInitializers(
            Collection<? extends ApplicationContextInitializer<?>> initializers) {
    this.initializers = new ArrayList<ApplicationContextInitializer<?>>();
    this.initializers.addAll(initializers);
}
public void setListeners(Collection<? extends ApplicationListener<?>> listeners) {
    this.listeners = new ArrayList<ApplicationListener<?>>();
    this.listeners.addAll(listeners);
}
  • 首先執行deduceWebEnvironment方法(程式碼中標記1處)，該方法的作用是根據classpath裡面是否存在某些特徵類({“javax.servlet.Servlet”, “org.springframework.web.context.ConfigurableWebApplicationContext” })來決定是建立一個Web型別的ApplicationContext還是建立一個標準Standalone型別的ApplicationContext.
  • 使用SpringFactoriesLoader在應用的classpath中查詢並載入所有可用的ApplicationContextInitializer(程式碼中標記2處)。
  • 使用SpringFactoriesLoader在應用的classpath中查詢並載入所有可用的ApplicationListener(程式碼中標記3處)。
  • 推斷並設定main方法的定義類(程式碼中標記4處)。

  這樣，SpringApplication就完成了例項化並且完成了設定。然後就開始執行SpringApplication例項的run方法的邏輯了:

public ConfigurableApplicationContext run(String... args) {
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    ConfigurableApplicationContext context = null;
    FailureAnalyzers analyzers = null;
    configureHeadlessProperty();
    SpringApplicationRunListeners listeners = getRunListeners(args); // 1
    listeners.starting(); // 2
    try {
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                args);
        ConfigurableEnvironment environment = prepareEnvironment(listeners,
                applicationArguments); // 3
        Banner printedBanner = printBanner(environment); // 5
        context = createApplicationContext(); // 6
        analyzers = new FailureAnalyzers(context);
        prepareContext(context, environment, listeners, applicationArguments,
                printedBanner);
        refreshContext(context); // 13
        afterRefresh(context, applicationArguments); // 15
        listeners.finished(context, null); // 16
        stopWatch.stop();
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass)
                    .logStarted(getApplicationLog(), stopWatch);
        }
        return context;
    }
    catch (Throwable ex) {
        handleRunFailure(context, listeners, analyzers, ex); // 17
        throw new IllegalStateException(ex);
    }
}
private ConfigurableEnvironment prepareEnvironment(
        SpringApplicationRunListeners listeners,
        ApplicationArguments applicationArguments) {
    // Create and configure the environment
    ConfigurableEnvironment environment = getOrCreateEnvironment();
    configureEnvironment(environment, applicationArguments.getSourceArgs());
    listeners.environmentPrepared(environment); // 4
    if (!this.webEnvironment) {
        environment = new EnvironmentConverter(getClassLoader())
                .convertToStandardEnvironmentIfNecessary(environment);
    }
    return environment;
}
private void prepareContext(ConfigurableApplicationContext context,
        ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
        ApplicationArguments applicationArguments, Banner printedBanner) {
    context.setEnvironment(environment); // 7
    postProcessApplicationContext(context); // 8
    applyInitializers(context); // 9
    listeners.contextPrepared(context); // 10
    if (this.logStartupInfo) {
        logStartupInfo(context.getParent() == null);
        logStartupProfileInfo(context);
    }

    // Add boot specific singleton beans
    context.getBeanFactory().registerSingleton("springApplicationArguments",
            applicationArguments);
    if (printedBanner != null) {
        context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
    }

    // Load the sources
    Set<Object> sources = getSources();
    Assert.notEmpty(sources, "Sources must not be empty");
    load(context, sources.toArray(new Object[sources.size()])); // 11
    listeners.contextLoaded(context); // 12
}
private void refreshContext(ConfigurableApplicationContext context) {
    refresh(context);
    if (this.registerShutdownHook) { // 14
        try {
            context.registerShutdownHook();
        }
        catch (AccessControlException ex) {
            // Not allowed in some environments.
        }
    }
}
  • 該方法中，首先通過SpringFactoriesLoader查詢並載入SpringApplicationRunListener(程式碼標記1處),然後接著呼叫它們的started()方法(程式碼標記2處)，告訴這些SpringApplicationRunListener說：“Hello, SpringBoot應用要開始執行嘍”。
  • 接著，建立和配置當前SpringBoot應用將要使用的Environment(包括配置要使用到的PropertySource和Profile)(程式碼標記3處).
  • 然後遍歷所有的SpringApplicationRunListener的environmentPrepared()方法，告訴他們：“當前SpringBoot應用使用的Environment已經準備好了哈”(程式碼標記4處)。
  • 如果SpringApplication的showBanner屬性為true的話，則列印banner(這裡是基於Banner.Mode來決定banner的列印行為)(程式碼標記5處)。這個步驟其實我們不用過多關心，個人感覺它的用途純粹是為了好玩。
  • 根據使用者是否明確設定了applicationContextClass型別以及初始化SpringApplication類階段的推斷結果，決定該為當前的SpringBoot應用建立什麼型別的ApplicationContext,並完成建立(程式碼標記6處)。
  • 然後將之前準備好的Environment設定給建立好的ApplicationContext，供以後使用(程式碼標記7處)。
  • 根據條件來決定是否使用自定義的BeanNameGenerator,決定是否使用自定義的ResourceLoader(程式碼標記8處)。
  • 完成後，SpringApplication會再次藉助SpringFactoriesLoader查詢並載入classpath中所有可用的ApplicationContextInitializer,然後遍歷呼叫它們的initialize(applicationContext)方法來對已經建立好的ApplicationContext進行進一步的處理(程式碼標記9處)。
  • 接著，遍歷所有SpringApplicationRunListener的contextPrepared()方法，通知它們：“SpringBoot應用的ApplicationContext準備好啦哈~”(程式碼標記10處)。
  • 非常最要的一步，將之前通過@EnableAutoConfiguration獲取的所有配置類以及其他形式的IoC容器配置類載入到已經準備完畢的ApplicationContext中(程式碼標記11處)。
  • 遍歷所有的SpringApplicationRunListener並呼叫它們的contextLoaded()方法，告訴所有的SpringApplicationRunListener說：“ApplicationContext裝填完畢啦”(程式碼標記12處)。
  • 呼叫ApplicationContext的refresh()方法，完成IoC容器初始化的最後一步流程(程式碼標記13處)。
  • 然後再根據條件來決定是否需要新增ShutdownHook(程式碼標記14處)。
  • 查詢當前ApplicationContext中是否註冊有ApplicationRunner以及CommandLineRunner，如果有，則遍歷執行它們。
  • 不出意外的情況下，遍歷所有的SpringApplicationRunListener並執行finished()方法，告訴他們：“啟動大功告成了！”(程式碼標記16處),如果整個啟動過程中出現了異常,則依然呼叫所有的SpringApplicationRunListener的finished()方法，這種情況下會將所有的異常資訊一起傳入並處理(程式碼標記17處)。

  經過以上的這些步驟以後，一個完整的SpringBoot應用就啟動完畢了！整個過程雖然看起來冗長無比，但其實很多都是一些事件通知的擴充套件點，如果我們將這些邏輯暫時的忽略掉的話，那整個SpringBoot應用啟動的邏輯就可以壓縮到極其精簡的幾步了，如下圖：

　　

  這樣我們對比以後就會發現，其實SpringApplication提供的這些各種擴充套件點有點”喧賓奪主”的味道，它們佔據了整個SpringBoot應用啟動邏輯的大部分，除了初始化準備好ApplicationContext，剩下的絕大部分工作均是通過這些擴充套件點來完成的。

四、總結

　　本文，我們通過原始碼的方式來解析了整個SpringBoot應用程式的啟動過程，我們發現了大部分工作都是由SpringApplication提供的擴充套件點來完成的，那我們下一篇文章就來逐一解析這些擴充套件點元件，這樣的話，我們就可以在需要的時候可以很輕鬆的為我所用！

​

相關文章