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();
}对于构造函数的解读
参数初始化：
resourceLoader：这是一个资源加载器，用于从类路径或其他位置加载资源，如配置文件、静态资源等。
primarySources：这是应用程序的主要配置源，通常是一个或多个配置类的数组，用于引导Spring的自动配置和组件扫描。
非空检查：
对primarySources进行非空检查，确保至少有一个配置源被提供，否则将抛出IllegalArgumentException。
配置源存储：
将primarySources转换为LinkedHashSet集合并存储，保持插入顺序，这有助于后续的配置解析和组件扫描。
Web应用类型推断：
调用WebApplicationType.deduceFromClasspath()方法自动检测应用的Web类型，是Servlet-based、Reactive-based还是None（非Web应用）。这一决策影响了Spring Boot如何初始化Web环境。
ApplicationContext Initializers设置：
调用getSpringFactoriesInstances方法来获取所有实现了ApplicationContextInitializer接口的实例，并将其设置为SpringApplication的initializers。这些initializers会在ApplicationContext创建过程中被调用，用于自定义上下文的初始化。
Application Listeners设置：
同样地，通过getSpringFactoriesInstances方法获取所有实现了ApplicationListener接口的实例，并将其设置为SpringApplication的listeners。这些listeners会在应用生命周期的不同阶段被触发，如启动、停止等。
主应用类推断：
调用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 本身决定的。
