前言
最近在學習Spring Boot相關的課程，過程中以筆記的形式記錄下來，方便以后回憶，同時也在這里和大家探討探討，文章中有漏的或者有補充的、錯誤的都希望大家能夠及時提出來，本人在此先謝謝了！
開始之前呢，希望大家帶着幾個問題去學習：
1、Spring Boot SpringApplication是什么？
2、怎么實現的？
3、優點和缺點是什么？
4、是怎么和 Spring 關聯起來的？
這是對自我的提問，我認為帶着問題去學習，是一種更好的學習方式，有利於加深理解。好了，接下來進入主題。
1、起源
上篇文章我們講了 Spring Boot 自動裝配相關的知識，但還是不知道 Spring Boot 為什么運行 SpringApplication.run() 就可以啟動，它是怎么和 Spring 應用上下文聯系起來的，以及如何使用 SpringApplication 驅動 Spring 應用。接下來就展開對 SpringApplication 的討論。
注：本篇文章所用到的 Spring Boot版本是 2.1.6.BUILD-SNAPSHOT
2、SpringApplication 准備階段
SpringApplication 在運行前做了一系列的准備工作，如：推斷 Web 應用類型、加載 Spring 的上下文初始化器和事件監聽器以及配置默認屬性等。接下來，就通過源碼的方式進行學習。
先來看看啟動類：
@SpringBootApplication
public class DiveInSpringBootApplication {
public static void main(String[] args) {
SpringApplication.run(DiveInSpringBootApplication.class, args);
}
}
@SpringBootApplication 該注解上篇文章說過，是進行自動裝配以及包掃描使用，這里不再贅述，我們主要關注 run 方法：
public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
return run(new Class<?>[] { primarySource }, args);
}
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
return new SpringApplication(primarySources).run(args);
}
可以看到， 通過入參 primarySources 構造 SpringApplication 類，然后在調用 run 方法，其中，准備階段的工作皆在 SpringApplication 的構造器中處理：
public class SpringApplication {
...
private Set<Class<?>> primarySources;
private WebApplicationType webApplicationType;
private List<ApplicationContextInitializer<?>> initializers;
private List<ApplicationListener<?>> listeners;
private Class<?> mainApplicationClass;
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
// resourceLoader 主要用來獲取 Resource 及 ClassLoader。這里值為 null
this.resourceLoader = resourceLoader;
// 斷言主要加載資源類不能為 null，否則報錯
Assert.notNull(primarySources, "PrimarySources must not be null");
// primarySources是SpringApplication.run的參數，存放的是主配置類
this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
// 進行Web應用的類型推斷
this.webApplicationType = WebApplicationType.deduceFromClasspath();
// 加載應用上下文初始化器 initializer
setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
// 加載應用事件監聽器 listener
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
// 推斷引導類，也就是找到入口類
this.mainApplicationClass = deduceMainApplicationClass();
}
...
}
接下來，對構造器中的重點部分進行詳細說明。
2.1、推斷 Web 應用類型
SpringApplication允許指定應用的類型，大體上包括Web應用和非Web應用。從 Spring Boot 2.0開始，Web應用又可分為Servlet Web和Reactive Web。而在准備階段，是通過檢查當前ClassPath下某些Class是否存在，從而推導應用的類型。我們進入 WebApplicationType.deduceFromClasspath() 方法查看：
public enum WebApplicationType {
/**
* 非 web 項目
*/
NONE,
/**
* servlet web 項目
*/
SERVLET,
/**
* reactive web 項目
*/
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";
static WebApplicationType deduceFromClasspath() {
if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
&& !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
return WebApplicationType.REACTIVE;
}
for (String className : SERVLET_INDICATOR_CLASSES) {
if (!ClassUtils.isPresent(className, null)) {
return WebApplicationType.NONE;
}
}
return WebApplicationType.SERVLET;
}
...
}
可以看到，在方法中利用 ClassUtils.isPresent 進行判斷， 當DispatcherHandler存在，而DispatcherServlet和ServletContainer不存在時，則當前應用推導為 Reactive web 類型；當 Servlet 和 ConfigurableWebApplicationContext 不存在時，當前應用為非 Web 類型；其他的則為 Servlet Web 類型。
Reactive：Reactive響應式編程是一種新的編程風格，其特點是異步或並發、事件驅動、推送PUSH機制以及觀察者模式的衍生。
2.2、加載應用上下文初始器 ApplicationContextInitializer
接着進入加載Spring應用上下文初始器的過程 setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class))：
public class SpringApplication {
...
private List<ApplicationContextInitializer<?>> initializers;
public void setInitializers(Collection<? extends ApplicationContextInitializer<?>> initializers) {
this.initializers = new ArrayList<>();
this.initializers.addAll(initializers);
}
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
return getSpringFactoriesInstances(type, new Class<?>[] {});
}
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
ClassLoader classLoader = getClassLoader();
// Use names and ensure unique to protect against duplicates
Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
AnnotationAwareOrderComparator.sort(instances);
return instances;
}
}
可以看到，這里是通過 Spring 工廠加載機制 SpringFactoriesLoader.loadFactoryNames(type, classLoader) 方法獲取。結合上篇文章所講，我們知道，該方法是從所有的 META-INF/spring.factories 資源中獲取key為 ApplicationContextInitializer 的實現類集合，如下是 spring-boot-autoconfigure 包下的 spring.factories 文件：
# Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener
這里獲取的就是 SharedMetadataReaderFactoryContextInitializer 和 ConditionEvaluationReportLoggingListener 上下文初始化器，接下來通過 createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names) 方法初始化這些實現類：
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;
}
這里先通過 BeanUtils.instantiate 初始化這些類，然后將初始化的類保存至List進行返回，並進行排序操作，最后添加到SpringApplication的initializers集合變量中。至此，該流程結束。
我們舉例來看看初始器中的內容，如SharedMetadataReaderFactoryContextInitializer：
class SharedMetadataReaderFactoryContextInitializer
implements ApplicationContextInitializer<ConfigurableApplicationContext>, Ordered {
...
@Override
public void initialize(ConfigurableApplicationContext applicationContext) {
applicationContext.addBeanFactoryPostProcessor(new CachingMetadataReaderFactoryPostProcessor());
}
...
}
可以看到該類實現了 Spring 的 ApplicationContextInitializer 接口，並重寫了initialize()方法。同理，其他的 Initializer 接口也是類似實現。 而在這里則是在上下文中加入了 CachingMetadataReaderFactoryPostProcessor bean工廠后置處理器。
ApplicationContextInitializer 接口的主要作用是在 ConfigurableApplicationContext#refresh() 方法調用之前做一些初始化工作。
2.3、加載應用事件監聽器 ApplicationListener
接着加載應用事件監聽器 setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class))，過程與“加載應用上下文初始器”基本一致，同樣是調用 getSpringFactoriesInstances 方法，不過這里獲取的是 key 為 ApplicationListener 的對象集合，如下是 spring-boot-autoconfigure 包下的 spring.factories 文件：：
# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.autoconfigure.BackgroundPreinitializer
最后，將獲取的 BackgroundPreinitializer 對象通過 setListeners 方法放入 listeners 屬性變量中：
public void setListeners(Collection<? extends ApplicationListener<?>> listeners) {
this.listeners = new ArrayList<>();
this.listeners.addAll(listeners);
}
我們同樣舉例，來看看監聽器中的內容，如BackgroundPreinitializer：
public class BackgroundPreinitializer implements ApplicationListener<SpringApplicationEvent> {
...
@Override
public void onApplicationEvent(SpringApplicationEvent event) {
if (!Boolean.getBoolean(IGNORE_BACKGROUNDPREINITIALIZER_PROPERTY_NAME)
&& event instanceof ApplicationStartingEvent && preinitializationStarted.compareAndSet(false, true)) {
...
}
if ((event instanceof ApplicationReadyEvent || event instanceof ApplicationFailedEvent)
&& preinitializationStarted.get()) {
...
}
}
...
}
可以看到，該類實現了 Spring 的 ApplicationListener 接口，在重寫的 onApplicationEvent 方法中觸發相應的事件進行操作。同理，其他 Listener 也是類似實現。而該接口的主要功能是另起一個后台線程觸發那些耗時的初始化，包括驗證器、消息轉換器等等。
目前spring boot中支持的事件類型如下：
- ApplicationFailedEvent：該事件為spring boot啟動失敗時的操作
- ApplicationPreparedEvent：上下文context准備時觸發
- ApplicationReadyEvent：上下文已經准備完畢的時候觸發
- ApplicationStartedEvent：spring boot 啟動監聽類
- SpringApplicationEvent：獲取SpringApplication
- ApplicationEnvironmentPreparedEvent：環境事先准備
2.4、推斷應用引導類
准備階段的最后一步是推斷應用的引導類，也就是獲取啟動 main 方法的類，執行的是 deduceMainApplicationClass() 方法：
private Class<?> deduceMainApplicationClass() {
try {
StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
for (StackTraceElement stackTraceElement : stackTrace) {
if ("main".equals(stackTraceElement.getMethodName())) {
return Class.forName(stackTraceElement.getClassName());
}
}
}
catch (ClassNotFoundException ex) {
// Swallow and continue
}
return null;
}
可以看到，通過 getStackTrace() 方法獲取當前線程的執行棧，再通過 getMethodName() 獲取方法名，判斷是否是 main 方法，最后返回 main 方法的所在類。
3、SpringApplication 配置
SpringApplication 准備階段結束后，按道理應該進入運行階段，但運行階段之前還有一個操作，就是可以修改 SpringApplication 默認配置。開頭的代碼示例可以看到，應用程序主類中的main方法中寫的都是SpringApplication.run(xx.class)，可能這種寫法不滿足我們的需求，我們可以對SpringApplication進行一些配置，例如關閉Banner，設置一些默認的屬性等。下面則是利用 SpringApplicationBuilder 的方式來添加配置：
@SpringBootApplication
public class DiveInSpringBootApplication {
public static void main(String[] args) {
new SpringApplicationBuilder(DiveInSpringBootApplication.class)
// 設置當前應用類型
.web(WebApplicationType.SERVLET)
// 設置 banner 橫幅打印方式、有關閉、日志、控制台
.bannerMode(Banner.Mode.OFF)
// 設置自定義的 banner
.banner()
// 追加自定義的 initializer 到集合中
.initializers()
// 追加自定義的 listeners 到集合中
.listeners()
.run(args);
}
}
可以看到，使用該方式實現的SpringApplication可以對其添加自定義的配置。當然配置遠遠不止這么點，其它的還請自行觀看源碼。
4、總結
至此，SpringApplication 的准備工作結束，其實主要是對primarySources、webApplicationType、initializers、listeners、mainApplicationClass 這幾個屬性進行初始化，以及對 SpringApplication 進行自定義配置 。下篇文章，就來講講SpringApplication運行階段，在運行階段中這些 SpringApplication的配置和應用初始化器、監聽器等如何被使用。
以上就是本章的內容，如過文章中有錯誤或者需要補充的請及時提出，本人感激不盡。
參考：
《Spring Boot 編程思想》