1、web.xml 定义入口类

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>com.baosight.ApplicationBoot</param-value>
</context-param>

2、主入口类: ApplicationBoot,SpringBoot项目的mian函数

@SpringBootApplication(scanBasePackages = "com.bs")
@ServletComponentScan("com.bs.4j.core.web.servlet")
@ImportResource(locations = {"classpath*:spring/framework/platApplicationContext*.xml", "classpath*:spring/framework/applicationContext*.xml"})
@EnableConfigurationProperties({LiquibaseProperties.class, ApplicationProperties.class})
public class ApplicationBoot extends SpringBootServletInitializer {

    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(ApplicationBoot.class);
        app.run(args);
    }

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(ApplicationBoot.class);
    }

}

3、SpringApplication

SpringApplication类是Spring Boot框架的核心组件之一，它负责整个应用的启动和初始化过程。SpringApplication的设计目标是简化Spring应用的启动步骤，提供一套开箱即用的配置，让开发者能够快速启动和运行Spring应用。

在这个类中:

3.1、SpringApplication构造方法

/**
	 * Create a new {@link SpringApplication} instance. The application context will load
	 * beans from the specified primary sources (see {@link SpringApplication class-level}
	 * documentation for details. The instance can be customized before calling
	 * {@link #run(String...)}.
	 * @param primarySources the primary bean sources
	 * @see #run(Class, String[])
	 * @see #SpringApplication(ResourceLoader, Class...)
	 * @see #setSources(Set)
	 */
	public SpringApplication(Class<?>... primarySources) {
		this(null, primarySources);
	}

	/**
	 * Create a new {@link SpringApplication} instance. The application context will load
	 * beans from the specified primary sources (see {@link SpringApplication class-level}
	 * documentation for details. The instance can be customized before calling
	 * {@link #run(String...)}.
	 * @param resourceLoader the resource loader to use
	 * @param primarySources the primary bean sources
	 * @see #run(Class, String[])
	 * @see #setSources(Set)
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
		this.resourceLoader = resourceLoader;
		Assert.notNull(primarySources, "PrimarySources must not be null");
		this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
		this.webApplicationType = WebApplicationType.deduceFromClasspath();
		setInitializers((Collection) getSpringFactoriesInstances(
				ApplicationContextInitializer.class));
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
		this.mainApplicationClass = deduceMainApplicationClass();
	}

 对于构造函数的解读

1. 参数初始化：

   • resourceLoader：这是一个资源加载器，用于从类路径或其他位置加载资源，如配置文件、静态资源等。
   • primarySources：这是应用程序的主要配置源，通常是一个或多个配置类的数组，用于引导Spring的自动配置和组件扫描。

2. 非空检查：

   • 对primarySources进行非空检查，确保至少有一个配置源被提供，否则将抛出IllegalArgumentException。

3. 配置源存储：

   • 将primarySources转换为LinkedHashSet集合并存储，保持插入顺序，这有助于后续的配置解析和组件扫描。

4. Web应用类型推断：

   • 调用WebApplicationType.deduceFromClasspath()方法自动检测应用的Web类型，是Servlet-based、Reactive-based还是None（非Web应用）。这一决策影响了Spring Boot如何初始化Web环境。

5. ApplicationContext Initializers设置：

   • 调用getSpringFactoriesInstances方法来获取所有实现了ApplicationContextInitializer接口的实例，并将其设置为SpringApplication的initializers。这些initializers会在ApplicationContext创建过程中被调用，用于自定义上下文的初始化。

6. Application Listeners设置：

   • 同样地，通过getSpringFactoriesInstances方法获取所有实现了ApplicationListener接口的实例，并将其设置为SpringApplication的listeners。这些listeners会在应用生命周期的不同阶段被触发，如启动、停止等。

7. 主应用类推断：

   • 调用deduceMainApplicationClass方法来确定应用的主类，通常是启动应用的那个类，用于在某些情况下（如生成文档）标识应用本身。

 3.1.1、WebApplicationType.deduceFromClasspath()

检测应用的Web类型，在下文ConfigurableApplicationContext的实例化中会使用到

 3.1.2、setInitializers

初始化classpath下 META-INF/spring.factories中已配置的ApplicationContextInitializer

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

1、getSpringFactoriesInstances有什么用，做了什么，这个方法是根据给定的类型type和ClassLoader，从spring-core提供的FACTORIES_RESOURCE_LOCATION=META-INF/spring.factories文件中加载所有该类型的工厂类名，即获取指定的类（key）的同一入口方法。这里使用了LinkedHashSet来存储这些名字，确保它们是唯一的且按插入顺序排序。这一块在SpringFactoriesLoader.loadFactoryNames/loadSpringFactories中实现

public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
		String factoryClassName = factoryClass.getName();
		return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
	}

	private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
		MultiValueMap<String, String> result = cache.get(classLoader);
		if (result != null) {
			return result;
		}

		try {
			Enumeration<URL> urls = (classLoader != null ?
					classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
					ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
			result = new LinkedMultiValueMap<>();
			while (urls.hasMoreElements()) {
				URL url = urls.nextElement();
				UrlResource resource = new UrlResource(url);
				Properties properties = PropertiesLoaderUtils.loadProperties(resource);
				for (Map.Entry<?, ?> entry : properties.entrySet()) {
					String factoryClassName = ((String) entry.getKey()).trim();
					for (String factoryName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
						result.add(factoryClassName, factoryName.trim());
					}
				}
			}
			cache.put(classLoader, result);
			return result;
		}
		catch (IOException ex) {
			throw new IllegalArgumentException("Unable to load factories from location [" +
					FACTORIES_RESOURCE_LOCATION + "]", ex);
		}
	}

在这里，获取的是key为 org.springframework.context.ApplicationContextInitializer 的类。ApplicationContextInitializer 是Spring框架的类, 这个类的主要目的就是在   ConfigurableApplicationContext 调用refresh()方法之前，回调这个类的initialize方法。通过  ConfigurableApplicationContext 的实例获取容器的环境Environment，从而实现对配置文件的修改完善等工作。

 

3.1.3 、setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));

 ApplicationListener 的加载过程和上面的 ApplicationContextInitializer 类的加载过程是一样的.ApplicationListener 是spring的事件监听器，典型的观察者模式，通过 ApplicationEvent 类和 ApplicationListener 接口，可以实现对spring容器全生命周期的监听

SpringApplication 类的实例化过程，我们可以在spring容器创建之前做一些预备工作，和定制化的需求。比如，自定义SpringBoot的Banner，比如自定义事件监听器，再比如在容器refresh之前通过自定义 ApplicationContextInitializer 修改配置一些配置或者获取指定的bean都是可以的

3.2、SpringApplication.run() 

如下面代码所示

/**
 * Run the Spring application, creating and refreshing a new
 * {@link ApplicationContext}.
 * @param args the application arguments (usually passed from a Java main method)
 * @return a running {@link ApplicationContext}
 */
public ConfigurableApplicationContext run(String... args) {
   StopWatch stopWatch = new StopWatch();
   stopWatch.start();
   ConfigurableApplicationContext context = null;
   Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
   configureHeadlessProperty();
   SpringApplicationRunListeners listeners = getRunListeners(args);
   listeners.starting();
   try {
      ApplicationArguments applicationArguments = new DefaultApplicationArguments(
            args);
      ConfigurableEnvironment environment = prepareEnvironment(listeners,
            applicationArguments);
      configureIgnoreBeanInfo(environment);
      Banner printedBanner = printBanner(environment);
      context = createApplicationContext();
      exceptionReporters = getSpringFactoriesInstances(
            SpringBootExceptionReporter.class,
            new Class[] { ConfigurableApplicationContext.class }, context);
      prepareContext(context, environment, listeners, applicationArguments,
            printedBanner);
      refreshContext(context);
      afterRefresh(context, applicationArguments);
      stopWatch.stop();
      if (this.logStartupInfo) {
         new StartupInfoLogger(this.mainApplicationClass)
               .logStarted(getApplicationLog(), stopWatch);
      }
      listeners.started(context);
      callRunners(context, applicationArguments);
   }
   catch (Throwable ex) {
      handleRunFailure(context, ex, exceptionReporters, listeners);
      throw new IllegalStateException(ex);
   }

   try {
      listeners.running(context);
   }
   catch (Throwable ex) {
      handleRunFailure(context, ex, exceptionReporters, null);
      throw new IllegalStateException(ex);
   }
   return context;
}

run方法详解：

• 计时和异常处理设置：

  • 创建一个StopWatch对象来测量应用启动所需的时间。

  • 初始化一个空列表exceptionReporters，用于存放异常报告器。

• 配置无头模式：

  • 调用configureHeadlessProperty方法确保应用在没有图形界面的环境中也能运行。

• 监听器初始化：

  • 获取SpringApplicationRunListeners监听器实例，并调用starting方法通知监听器应用即将开始启动。

• 解析命令行参数：

  • 创建ApplicationArguments实例，用于解析传入的命令行参数。

• 环境准备：

  • 准备ConfigurableEnvironment环境，这个环境包含了应用的配置信息。应用上下文环境包括什么呢？包括计算机的环境，Java环境，Spring的运行环境，Spring项目的配置（在SpringBoot中就是那个熟悉的application.properties/yml）等等。

• 忽略Bean信息配置：

  • 调用configureIgnoreBeanInfo方法，这通常用于性能优化，避免加载不必要的Bean信息。

• 打印Banner：

  • 打印应用的启动Banner，显示应用名、版本等信息。

• 创建ApplicationContext：

  • 创建ConfigurableApplicationContext上下文，这是Spring管理Bean的容器。

• 异常报告器获取：

  • 通过getSpringFactoriesInstances方法获取所有SpringBootExceptionReporter实例。

• 上下文准备：

  • 调用prepareContext方法进行上下文的准备工作，包括注册Bean后处理器、监听器等。

• 刷新上下文：

  • 调用refreshContext方法刷新上下文，这是Spring Bean生命周期的关键点。

• 启动后操作：

  • 调用afterRefresh方法执行一些应用启动后的操作，如初始化定时任务等。

• 日志记录：

  • 如果配置了记录启动信息，使用StartupInfoLogger记录应用启动完成的日志。

• 监听器回调：

  • 通知监听器应用已经启动。

• 运行Runners：

  • 调用callRunners方法执行定义好的ApplicationRunner或CommandLineRunner，它们通常用于执行一些启动后的初始化工作。

• 异常处理：

  • 在整个启动过程中捕获并处理可能发生的异常，确保应用能够优雅地处理错误。

• 返回ApplicationContext：

  • 最终返回创建的ConfigurableApplicationContext实例，这是Spring Boot应用的核心组件。

3.3、ConfigurableApplicationContext

ConfigurableApplicationContext是Spring框架中ApplicationContext接口的一个扩展，它提供了更多的配置和控制能力，是Spring应用程序上下文的高级接口。在Spring Boot中，ConfigurableApplicationContext扮演着核心角色，用于管理应用程序的生命周期和Bean的配置。下面是一些关键特性及其作用的详细解读：

 配置和定制

ConfigurableApplicationContext允许开发者在应用程序启动时对上下文进行更深入的定制，例如设置Environment、ResourceLoader、MessageSource、ApplicationEventPublisher等。这使得你可以更灵活地调整Spring容器的行为，以适应不同的应用场景。

 刷新上下文

与ApplicationContext不同的是，ConfigurableApplicationContext提供了refresh()方法，用于手动刷新上下文，重新加载配置并初始化Bean。这是非常有用的，特别是在测试场景中，你需要在每次测试之前重置Spring上下文的状态。

关闭上下文

ConfigurableApplicationContext提供了close()方法，允许你优雅地关闭上下文，释放资源。这对于那些不需要一直运行的应用程序尤其重要，比如批处理作业或命令行应用。

监听器支持

它支持ApplicationListener，允许你在上下文的生命周期事件（如启动、关闭、Bean实例化等）中注册监听器，以便于执行自定义逻辑。这对于集成日志记录、健康检查等功能非常有用。

环境感知

ConfigurableApplicationContext允许你访问和修改应用的Environment，这包括读取和设置配置属性、切换不同的配置文件（profiles）等。这对于多环境部署（如开发、测试、生产）的管理至关重要。

事件发布

除了标准的ApplicationEventPublisher功能，ConfigurableApplicationContext还提供了更细粒度的事件发布和监听机制，这对于实现复杂的业务逻辑和系统集成非常有帮助。

实例化

在Spring Boot中，SpringApplication的run方法通过createApplicationContext返回一个ConfigurableApplicationContext实例，这通常是应用程序的主要入口点，可以通过这个上下文访问到所有由Spring管理的Bean和资源。下面则是createApplicationContext的具体实现：

Strategy method used to create the ApplicationContext. By default this method will respect any explicitly set application context or application context class before falling back to a suitable default.
返回值:
the application context (not yet refreshed)
请参阅:
setApplicationContextClass(Class)
protected ConfigurableApplicationContext createApplicationContext() {
		Class<?> contextClass = this.applicationContextClass;
		if (contextClass == null) {
			try {
				switch (this.webApplicationType) {
				case SERVLET:
					contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);
					break;
				case REACTIVE:
					contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
					break;
				default:
					contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
				}
			}
			catch (ClassNotFoundException ex) {
				throw new IllegalStateException(
						"Unable create a default ApplicationContext, "
								+ "please specify an ApplicationContextClass",
						ex);
			}
		}
		return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
	}

3.2.1、WebApplicationType详解 

WebApplicationType,一个枚举，且里面定义了三个枚举值，分别是 NONE、SERVLET、REACTIVE

SERVLET:传统的Servlet-based web应用，内嵌基于 servlet 的 web 服务器（如：Tomcat，Jetty，Undertow 等，其实现在大多Java网站应用都是采用的基于 Tomcat 的 servlet 类型服务器）,默认使用AnnotationConfigServletWebServerApplicationContext作为上下文。

REACTIVE:响应式web应用，在 servlet 容器当中，采用命令式编程方式，代码一句一句的执行，这样更有利于理解与调试，而在反应式的 web 编程中，是基于异步响应式，现在 WebFlux 框架就是一个较为流行的反应式编程,默认使用AnnotationConfigReactiveWebServerApplicationContext作为上下文。

NONE:既不是SERVLET也不是REACTIVE:即非Web应用，非 web 应用程序（不内嵌服务器）,则默认使用AnnotationConfigApplicationContext作为上下文。

而关于Springboot 如何确定程序的应用类型 WebApplicationType 的?

在SpringApplication构造方法:

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
		this.resourceLoader = resourceLoader;
		Assert.notNull(primarySources, "PrimarySources must not be null");
		this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
		this.webApplicationType = WebApplicationType.deduceFromClasspath();
		setInitializers((Collection) getSpringFactoriesInstances(
				ApplicationContextInitializer.class));
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
		this.mainApplicationClass = deduceMainApplicationClass();
	}

this.webApplicationType = WebApplicationType.deduceFromClasspath();其中 WebApplicationType.deduceFromClasspath() 这个方法实现如下

	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()?干什么的?用来判断一个类的存在性的，当这个类存在，那么返回的就是 true；当这个类不存在时，返回的结果就是 fasle。

(1)WEBFLUX_INDICATOR_CLASS,WEBMVC_INDICATOR_CLASS,JERSEY_INDICATOR_CLASS常量值又分别是什么?看源码

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";

当项目中存在 DispatcherHandler 这个类，且不存在 DispatcherServlet 类和ServletContainer时，程序的应用类型就是 REACTIVE，也就是他会加载嵌入一个反应式的 web 服务器。

(2)而SERVLET_INDICATOR_CLASSES

private static final String[] SERVLET_INDICATOR_CLASSES = { "javax.servlet.Servlet",
			"org.springframework.web.context.ConfigurableWebApplicationContext" };

当项目中 Servlet 和 ConfigurableWebApplicationContext 其中一个不存在时，则程序的应用类型为 NONE，它并不会加载内嵌任何 web 服务器。

(3)除了上面两种情况外，其余的都按 SERVLET 类型处理，会内嵌一个 servlet 类型的 web 服务器

上面的这些类的判定，都来源于 Spring 的相关依赖包，而这依赖包是否需要导入，也是开发者所决定的，所以说开发者可以决定程序的应用类型，并不是 Srpingboot 本身决定的。

 3.4、refreshContext