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

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應(yīng)用類型
	// 如果項(xiàng)目依賴中存在org.springframework.web.reactive.DispatcherHandler，并且不存在org.springframework.web.servlet.DispatcherServlet，那么應(yīng)用類型為WebApplicationType.REACTIVE
	// 如果項(xiàng)目依賴中不存在org.springframework.web.reactive.DispatcherHandler，也不存在org.springframework.web.servlet.DispatcherServlet，那么應(yīng)用類型為WebApplicationType.NONE
	// 否則，應(yīng)用類型為WebApplicationType.SERVLET
	this.webApplicationType = WebApplicationType.deduceFromClasspath();

	// 獲取BootstrapRegistryInitializer對象
	// 從"META-INF/spring.factories"中讀取key為BootstrapRegistryInitializer類型的擴(kuò)展點(diǎn)，并實(shí)例化出對應(yīng)擴(kuò)展點(diǎn)對象
	// BootstrapRegistryInitializer的作用是可以初始化BootstrapRegistry
	// 下面的DefaultBootstrapContext對象就是一個(gè)BootstrapRegistry，可以用來注冊一些對象，這些對象可以用在從SpringBoot啟動到Spring容器初始化完成的過程中
	// 我的理解：沒有Spring容器之前就利用BootstrapRegistry來共享一些對象，有了Spring容器之后就利用Spring容器來共享一些對象

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

	// 獲取ApplicationContextInitializer對象
	// 從"META-INF/spring.factories"中讀取key為ApplicationContextInitializer類型的擴(kuò)展點(diǎn)，并實(shí)例化出對應(yīng)擴(kuò)展點(diǎn)對象
	// 顧名思義，ApplicationContextInitializer是用來初始化Spring容器ApplicationContext對象的，比如可以利用ApplicationContextInitializer來向Spring容器中添加ApplicationListener
	setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));

	// 獲取ApplicationListener對象
	// 從"META-INF/spring.factories"中讀取key為ApplicationListener類型的擴(kuò)展點(diǎn)，并實(shí)例化出對應(yīng)擴(kuò)展點(diǎn)對象
	// ApplicationListener是Spring中的監(jiān)聽器，并不是SpringBoot中的新概念，不多解釋了
	setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));

	// 推測出Main類（main()方法所在的類）
	// 沒什么具體的作用，邏輯是根據(jù)當(dāng)前線程的調(diào)用棧來判斷main()方法在哪個(gè)類，哪個(gè)類就是Main類
	this.mainApplicationClass = deduceMainApplicationClass();
}

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

	// 從"META-INF/spring.factories"中讀取key為SpringApplicationRunListener類型的擴(kuò)展點(diǎn)，并實(shí)例化出對應(yīng)擴(kuò)展點(diǎn)對象
	SpringApplicationRunListeners listeners = getRunListeners(args);
	// 觸發(fā)SpringApplicationRunListener的starting()
	// 默認(rèn)情況下SpringBoot提供了一個(gè)EventPublishingRunListener，發(fā)布ApplicationStartingEvent事件
	listeners.starting(bootstrapContext, this.mainApplicationClass);
	try {
		ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
		// Environment對象表示環(huán)境變量，該對象內(nèi)部主要包含了
		// 1. 當(dāng)前操作系統(tǒng)的環(huán)境變量
		// 2. JVM的一些配置信息
		// 3. -D方式所配置的JVM環(huán)境變量
		ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);


		configureIgnoreBeanInfo(environment);

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

		// 根據(jù)webApplicationType不同創(chuàng)建不同的ApplicationContext
		context = createApplicationContext();
		context.setApplicationStartup(this.applicationStartup);

		// refreshContext前的準(zhǔn)備工作，例如注入一些配置Bean
		prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);

		// 調(diào)用applicationContext.refresh();
		refreshContext(context);

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

		Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
		if (this.logStartupInfo) {
			// 打印啟動時(shí)間日志
			new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
		}
		// 發(fā)布ApplicationStartedEvent事件
		// 發(fā)布AvailabilityChangeEvent事件，AvailabilityChangeEvent事件表示狀態(tài)變更狀態(tài)，變更后的狀態(tài)為LivenessState.CORRECT
		listeners.started(context, timeTakenToStartup);

		// 調(diào)用ApplicationRunner.run
		// 調(diào)用CommandLineRunner.run
		callRunners(context, applicationArguments);
	}
	catch (Throwable ex) {
		handleRunFailure(context, ex, listeners);
		throw new IllegalStateException(ex);
	}
	try {
		Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
		// 發(fā)布ApplicationReadyEvent事件
		// 發(fā)布AvailabilityChangeEvent事件，AvailabilityChangeEvent事件表示狀態(tài)變更狀態(tài)，變更后的狀態(tài)為ReadinessState.ACCEPTING_TRAFFIC
		listeners.ready(context, timeTakenToReady);
	}
	catch (Throwable ex) {
		handleRunFailure(context, ex, null);
		throw new IllegalStateException(ex);
	}
	return context;
}

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
												   DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
	// Create and configure the environment
	// 創(chuàng)建環(huán)境變量，一般是ApplicationServletEnvironment
	ConfigurableEnvironment environment = getOrCreateEnvironment();
	// 向environment中添加defaultProperties
	// 將命令行的參數(shù)封裝為SimpleCommandLinePropertySource，加入environment
	configureEnvironment(environment, applicationArguments.getSourceArgs());
	// 添加ConfigurationPropertySourcesPropertySource到environment
	ConfigurationPropertySources.attach(environment);

	// 默認(rèn)情況下會利用EventPublishingRunListener發(fā)布ApplicationEnvironmentPreparedEvent事件
	// 比如默認(rèn)情況下會有一個(gè)EnvironmentPostProcessorApplicationListener來消費(fèi)這個(gè)事件
	// 而這個(gè)ApplicationListener接收到這個(gè)事件之后，就會解析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);
	}
	// 為什么又調(diào)用一次？
	ConfigurationPropertySources.attach(environment);
	return environment;
}

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())) {
			// 創(chuàng)建的是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);
	}
};

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

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