Spring Boot SpringApplication启动类（一）

目录

• 前言
• 1、起源
• 2、SpringApplication 准备阶段
  • 2.1、推断 Web 应用类型
  • 2.2、加载应用上下文初始器 ApplicationContextInitializer
  • 2.3、加载应用事件监听器 ApplicationListener
  • 2.4、推断应用引导类
• 3、SpringApplication 配置
• 4、总结

前言

        最近在学习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 编程思想》