文章目錄

前言

最近在學習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 接口也是類似實現。而在這裏則是在上下文中加入了 CachingMetadataReaderFactoryPostProcessorbean工廠後置處理器。

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 編程思想》

SpringBoot（三）SpringApplication啓動類準備階段 - ApplicationContextInitializer、ApplicationListener

文章目錄

前言

1、起源

2、SpringApplication 準備階段

2.1、推斷 Web 應用類型

2.2、加載應用上下文初始器 ApplicationContextInitializer

2.3、加載應用事件監聽器 ApplicationListener

2.4、推斷應用引導類

3、SpringApplication 配置

4、總結

35K*14 薪，入職了！這公司只要不裁員，我能一直呆下去！

Spring（八）核心容器 - Bean 創建過程

Spring（七）核心容器 - 鉤子接口

SpringBoot（二）自動裝配正文 - @SpringBootApplication、@EnableAutoConfiguration

SpringBoot（五）外部化配置 - Environment、ConfigFileApplicationListener

SpringBoot（三）SpringApplication啓動類準備階段 - ApplicationContextInitializer、ApplicationListener

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結