【SpringBoot】启动过程源码分析

程序的入口：

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);
}

最终会调用SpringApplication的构造方法。

构造SpringApplication对象

1. 推测web应用类型
2. 获取BootstrapRegistryInitializer对象
3. 获取ApplicationContextInitializer对象
4. 获取ApplicationListener对象
5. 推测出Main类（main()方法所在的类）

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
	this.resourceLoader = resourceLoader;
	Assert.notNull(primarySources, "PrimarySources must not be null");
	this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
	// 推测web应用类型
	// 如果项目依赖中存在org.springframework.web.reactive.DispatcherHandler，并且不存在org.springframework.web.servlet.DispatcherServlet，那么应用类型为WebApplicationType.REACTIVE
	// 如果项目依赖中不存在org.springframework.web.reactive.DispatcherHandler，也不存在org.springframework.web.servlet.DispatcherServlet，那么应用类型为WebApplicationType.NONE
	// 否则，应用类型为WebApplicationType.SERVLET
	this.webApplicationType = WebApplicationType.deduceFromClasspath();

	// 获取BootstrapRegistryInitializer对象
	// 从"META-INF/spring.factories"中读取key为BootstrapRegistryInitializer类型的扩展点，并实例化出对应扩展点对象
	// BootstrapRegistryInitializer的作用是可以初始化BootstrapRegistry
	// 下面的DefaultBootstrapContext对象就是一个BootstrapRegistry，可以用来注册一些对象，这些对象可以用在从SpringBoot启动到Spring容器初始化完成的过程中
	// 我的理解：没有Spring容器之前就利用BootstrapRegistry来共享一些对象，有了Spring容器之后就利用Spring容器来共享一些对象

	this.bootstrapRegistryInitializers = new ArrayList<>(
		getSpringFactoriesInstances(BootstrapRegistryInitializer.class));

	// 获取ApplicationContextInitializer对象
	// 从"META-INF/spring.factories"中读取key为ApplicationContextInitializer类型的扩展点，并实例化出对应扩展点对象
	// 顾名思义，ApplicationContextInitializer是用来初始化Spring容器ApplicationContext对象的，比如可以利用ApplicationContextInitializer来向Spring容器中添加ApplicationListener
	setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));

	// 获取ApplicationListener对象
	// 从"META-INF/spring.factories"中读取key为ApplicationListener类型的扩展点，并实例化出对应扩展点对象
	// ApplicationListener是Spring中的监听器，并不是SpringBoot中的新概念，不多解释了
	setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));

	// 推测出Main类（main()方法所在的类）
	// 没什么具体的作用，逻辑是根据当前线程的调用栈来判断main()方法在哪个类，哪个类就是Main类
	this.mainApplicationClass = deduceMainApplicationClass();
}

run(String… args)方法

run()主要负责Spring的启动：

org.springframework.boot.SpringApplication#run(java.lang.String…)

public ConfigurableApplicationContext run(String... args) {
	long startTime = System.nanoTime();
	// 创建DefaultBootstrapContext对象
	// 用BootstrapRegistryInitializer初始化DefaultBootstrapContext对象
	// DefaultBootstrapContext用来在spring容器创建之前共享对象
	DefaultBootstrapContext bootstrapContext = createBootstrapContext();
	ConfigurableApplicationContext context = null;
	configureHeadlessProperty();

	// 从"META-INF/spring.factories"中读取key为SpringApplicationRunListener类型的扩展点，并实例化出对应扩展点对象
	SpringApplicationRunListeners listeners = getRunListeners(args);
	// 触发SpringApplicationRunListener的starting()
	// 默认情况下SpringBoot提供了一个EventPublishingRunListener，发布ApplicationStartingEvent事件
	listeners.starting(bootstrapContext, this.mainApplicationClass);
	try {
		ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
		// Environment对象表示环境变量，该对象内部主要包含了
		// 1. 当前操作系统的环境变量
		// 2. JVM的一些配置信息
		// 3. -D方式所配置的JVM环境变量
		ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);


		configureIgnoreBeanInfo(environment);

		// 打印banner
		Banner printedBanner = printBanner(environment);

		// 根据webApplicationType不同创建不同的ApplicationContext
		context = createApplicationContext();
		context.setApplicationStartup(this.applicationStartup);

		// refreshContext前的准备工作，例如注入一些配置Bean
		prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);

		// 调用applicationContext.refresh();
		refreshContext(context);

		// 空方法
		afterRefresh(context, applicationArguments);

		Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
		if (this.logStartupInfo) {
			// 打印启动时间日志
			new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
		}
		// 发布ApplicationStartedEvent事件
		// 发布AvailabilityChangeEvent事件，AvailabilityChangeEvent事件表示状态变更状态，变更后的状态为LivenessState.CORRECT
		listeners.started(context, timeTakenToStartup);

		// 调用ApplicationRunner.run
		// 调用CommandLineRunner.run
		callRunners(context, applicationArguments);
	}
	catch (Throwable ex) {
		handleRunFailure(context, ex, listeners);
		throw new IllegalStateException(ex);
	}
	try {
		Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
		// 发布ApplicationReadyEvent事件
		// 发布AvailabilityChangeEvent事件，AvailabilityChangeEvent事件表示状态变更状态，变更后的状态为ReadinessState.ACCEPTING_TRAFFIC
		listeners.ready(context, timeTakenToReady);
	}
	catch (Throwable ex) {
		handleRunFailure(context, ex, null);
		throw new IllegalStateException(ex);
	}
	return context;
}

创建Environment对象

Environment对象表示环境变量，该对象内部主要包含了:

1. 当前操作系统的环境变量
2. JVM的一些配置信息
3. -D方式所配置的JVM环境变量

org.springframework.boot.SpringApplication#prepareEnvironment

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
												   DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
	// Create and configure the environment
	// 创建环境变量，一般是ApplicationServletEnvironment
	ConfigurableEnvironment environment = getOrCreateEnvironment();
	// 向environment中添加defaultProperties
	// 将命令行的参数封装为SimpleCommandLinePropertySource，加入environment
	configureEnvironment(environment, applicationArguments.getSourceArgs());
	// 添加ConfigurationPropertySourcesPropertySource到environment
	ConfigurationPropertySources.attach(environment);

	// 默认情况下会利用EventPublishingRunListener发布ApplicationEnvironmentPreparedEvent事件
	// 比如默认情况下会有一个EnvironmentPostProcessorApplicationListener来消费这个事件
	// 而这个ApplicationListener接收到这个事件之后，就会解析application.properties、application.yml文件，并添加到Environment对象中去。
	/**
		 * @see EnvironmentPostProcessorApplicationListener
		 */
	listeners.environmentPrepared(bootstrapContext, environment);
	// 将DefaultPropertiesPropertySource移到最后
	DefaultPropertiesPropertySource.moveToEnd(environment);
	Assert.state(!environment.containsProperty("spring.main.environment-prefix"),
				 "Environment prefix cannot be set via properties.");
	bindToSpringApplication(environment);
	if (!this.isCustomEnvironment) {
		environment = convertEnvironment(environment);
	}
	// 为什么又调用一次？
	ConfigurationPropertySources.attach(environment);
	return environment;
}

创建Spring容器对象（ApplicationContext）

会利用ApplicationContextFactory.DEFAULT，根据应用类型创建对应的Spring容器。

ApplicationContextFactory.DEFAULT为：

ApplicationContextFactory DEFAULT = (webApplicationType) -> {
	try {
		/**
			 * org.springframework.boot.ApplicationContextFactory=\
			 * org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext.Factory,\
			 * org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext.Factory
			 */
		for (ApplicationContextFactory candidate : SpringFactoriesLoader
			 .loadFactories(ApplicationContextFactory.class, ApplicationContextFactory.class.getClassLoader())) {
			// 创建的是AnnotationConfigServletWebServerApplicationContext
			ConfigurableApplicationContext context = candidate.create(webApplicationType);
			if (context != null) {
				return context;
			}
		}
		return new AnnotationConfigApplicationContext();
	}
	catch (Exception ex) {
		throw new IllegalStateException("Unable create a default ApplicationContext instance, "
										+ "you may need a custom ApplicationContextFactory", ex);
	}
};

所以：

1. 应用类型为SERVLET，则对应AnnotationConfigServletWebServerApplicationContext
2. 应用类型为REACTIVE，则对应AnnotationConfigReactiveWebServerApplicationContext
3. 应用类型为普通类型，则对应AnnotationConfigApplicationContext

利用ApplicationContextInitializer初始化Spring容器对象

默认情况下SpringBoot提供了多个ApplicationContextInitializer，其中比较重要的有ConditionEvaluationReportLoggingListener，别看到它的名字叫XXXListener，但是它确实是实现了ApplicationContextInitializer接口的。

org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener#initialize

@Override
public void initialize(ConfigurableApplicationContext applicationContext) {
	this.applicationContext = applicationContext;
	applicationContext.addApplicationListener(new ConditionEvaluationReportListener());
	if (applicationContext instanceof GenericApplicationContext) {
		// Get the report early in case the context fails to load
		this.report = ConditionEvaluationReport.get(this.applicationContext.getBeanFactory());
	}
}

在它的initialize()方法中会：

1. 将Spring容器赋值给它的applicationContext属性
2. 并且往Spring容器中添加一个ConditionEvaluationReportListener（ConditionEvaluationReportLoggingListener的内部类），它是一个ApplicationListener
3. 并生成一个ConditionEvaluationReport对象赋值给它的report属性

ConditionEvaluationReportListener会负责接收ContextRefreshedEvent事件，也就是Spring容器一旦启动完毕就会触发ContextRefreshedEvent，ConditionEvaluationReportListener就会打印自动配置类的条件评估报告。

触发SpringApplicationRunListener的contextPrepared()

默认情况下会利用EventPublishingRunListener发布一个ApplicationContextInitializedEvent事件，默认情况下暂时没有ApplicationListener消费了这个事件

调用DefaultBootstrapContext对象的close()

没什么特殊的，忽略

将启动类作为配置类注册到Spring容器中（load()方法）

将SpringApplication.run(MyApplication.class);中传入进来的类，比如MyApplication.class，作为Spring容器的配置类

触发SpringApplicationRunListener的contextLoaded()

默认情况下会利用EventPublishingRunListener发布一个ApplicationPreparedEvent事件

刷新Spring容器

调用Spring容器的refresh()方法，相当于执行了这样一个流程：

AnnotationConfigServletWebServerApplicationContext applicationContext = new AnnotationConfigServletWebServerApplicationContext();
applicationContext .register(MyApplication.class)
applicationContext .refresh()

触发SpringApplicationRunListener的started()

发布ApplicationStartedEvent事件和AvailabilityChangeEvent事件，AvailabilityChangeEvent事件表示状态变更状态，变更后的状态为LivenessState.CORRECT

LivenessState枚举有两个值：

• CORRECT：表示当前应用正常运行中
• BROKEN：表示当前应用还在运行，但是内部出现问题，暂时还没发现哪里用到了

调用ApplicationRunner和CommandLineRunner

1. 获取Spring容器中的ApplicationRunner类型的Bean
2. 获取Spring容器中的CommandLineRunner类型的Bean
3. 执行它们的run()

触发SpringApplicationRunListener的ready()

发布ApplicationReadyEvent事件和AvailabilityChangeEvent事件，AvailabilityChangeEvent事件表示状态变更状态，变更后的状态为ReadinessState.ACCEPTING_TRAFFIC

ReadinessState枚举有两个值：

• ACCEPTING_TRAFFIC：表示当前应用准备接收请求
• REFUSING_TRAFFIC：表示当前应用拒绝接收请求，比如Tomcat关闭时，就会发布AvailabilityChangeEvent事件，并且状态为REFUSING_TRAFFIC

上述过程抛异常了就触发SpringApplicationRunListener的failed()

发布ApplicationFailedEvent事件。