大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。
Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺
在Spring Framework时代，Spring应用上下文通常由容器启动，如ContextLoaderListener或WebApplicationInitializer的实现类由Servlet容器装载并驱动。到了Spring Boot时代，Spring应用上下文的启动则通过调用SpringApplication.run(Object,String …)或SpringApplicationBuilder.run(String …)方法并配合@SpringBootApplication或@EnableAutoConfiguration注解方式完成。
从Spring Boot应用进程来看，整体的生命周期大体上总结如下：
- SpringApplication初始化阶段
- SpringApplication运行阶段
- SpringApplication结束阶段
- SpringApplication应用退出
SpringApplication初始化阶段属于运行前的准备阶段，大多数Spring Boot应用直接或间接地使用SpringApplication API驱动Spring应用，SpringApplication 允许指定应用类型，Web还是非Web，Banner的输出、配置默认属性的内容等，这些状态变更的操作只要在run()方法之前指定即可。简单而言，SpringApplication 的准备阶段主要由两阶段完成：构造阶段和配置阶段。
1、SpringApplication构造阶段
SpringApplication构造阶段在其构造器中完成，在日常开发中，很少直接与SpringApplication构造器打交道，而是调用其静态方法run(Class,String …)来启动应用，实际上其构造过程就在其中：
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);
}
无论使用哪个方法都需要Class类型的primarySource 参数，这个参数有什么意义呢？
1.1、理解SpringApplication主配置类
SpringApplication主配置类的概念和实现是从Spring Boot2.0开始引入的。通常情况下，引导类将作为primarySource参数的内容，这些引导类基本上具备一个特点，不是标注@SpringBootApplication就是标注@EnableAutoConfiguration，由于@SpringBootApplication元标注@EnableAutoConfiguration，因此两者均被底层Spring应用上下文视作@EnableAutoConfiguration处理。当引导类作为primarySource参数时，Spring应用上下文将其视为Configuration Class处理。
主配置类属性primarySource除初始化构造器参数外，还能通过SpringApplication.addPrimarySources()方法追加修改：
private Set<Class<?>> primarySources;
public void addPrimarySources(Collection<Class<?>> additionalPrimarySources) {
this.primarySources.addAll(additionalPrimarySources);
}
1.2、SpringApplication的构造过程
已知SpringApplication.run()方法的执行会伴随SpringApplication对象的构造，其调用的构造器为：
public SpringApplication(Class<?>... primarySources) {
this(null, primarySources);
}
@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();
}
根据调用链路，实际执行的构造器为SpringApplication(ResourceLoader, Class<?>)，其中主配置类primarySources被SpringApplication对象primarySources属性存储，随后依次调用deduceFromClasspath()、setInitializers()、setListeners()和deduceMainApplicationClass()方法。按照方法名的语义，他们分别为：推断Web应用类型、加载Spring应用上下文初始化器、加载Spring应用事件监听器和推断应用引导类。
1.3、推断Web应用类型
推断Web应用类型属于当前Spring Boot应用Web类型的初始化过程，因为该类型可在SpringApplication构造后及run方法之前，再通setWebApplicationType(WebApplicationType)方法调整。在推断Web应用类型的过程中，由于当前Spring应用上下文尚未准备，所以实现采用的是检查当前ClassLoader下基准Class的存在性判断：
public enum WebApplicationType {
NONE,
SERVLET,
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";
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;
}
}
WebApplicationType.deduceFromClasspath()利用ClassUtils.isPresent(String,ClassLoader)方法依次判断DispatcherHandler、DispatcherServlet、ServletContainer、Servlet、ConfigurableWebApplicationContext的存在性组合情况，从而推断Web应用类型：
- 当DispatcherHandler存在，并且DispatcherServlet和ServletContainer不存在时，换言之，Spring Boot仅依赖WebFlux存在时，此时的Web应用类型为REACTIVE。
- 当Servlet和ConfigurableWebApplicationContext均不存在时，当前应用为非Web应用，即NONE。
- 其余情况为SERVLET。
当WebApplicationType.deduceFromClasspath()执行完毕，SpringApplication的构造进入加载Spring应用上下文初始化器的过程。
1.4、加载Spring应用上下文初始化器(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;
}
此处同样运用了Spring工厂加载机制方法SpringFactoriesLoader.loadFactoryNames(type, classLoader)。结合本例的场景，该方法将返回所有META-INF/spring.factory资源中配置的ApplicationContextInitializer实现类名单：
# Application Context Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,\
org.springframework.boot.context.ContextIdApplicationContextInitializer,\
org.springframework.boot.context.config.DelegatingApplicationContextInitializer,\
org.springframework.boot.rsocket.context.RSocketPortInfoApplicationContextInitializer,\
org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer
当getSpringFactoriesInstances方法获取实现类名单后，调用createSpringFactoriesInstances方法初始化这些实现类：
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;
}
传递空数组的parameterTyps和args方法参数，则ApplicationContextInitializer实现类必须存在默认构造器。挑选ContextIdApplicationContextInitializer进行检验：
public class ContextIdApplicationContextInitializer
implements ApplicationContextInitializer<ConfigurableApplicationContext>, Ordered {
private int order = Ordered.LOWEST_PRECEDENCE - 10;
public void setOrder(int order) {
this.order = order;
}
@Override
public int getOrder() {
return this.order;
}
@Override
public void initialize(ConfigurableApplicationContext applicationContext) {
ContextId contextId = getContextId(applicationContext);
applicationContext.setId(contextId.getId());
applicationContext.getBeanFactory().registerSingleton(ContextId.class.getName(), contextId);
}
private ContextId getContextId(ConfigurableApplicationContext applicationContext) {
ApplicationContext parent = applicationContext.getParent();
if (parent != null && parent.containsBean(ContextId.class.getName())) {
return parent.getBean(ContextId.class).createChildId();
}
return new ContextId(getApplicationId(applicationContext.getEnvironment()));
}
private String getApplicationId(ConfigurableEnvironment environment) {
String name = environment.getProperty("spring.application.name");
return StringUtils.hasText(name) ? name : "application";
}
static class ContextId {
private final AtomicLong children = new AtomicLong(0);
private final String id;
ContextId(String id) {
this.id = id;
}
ContextId createChildId() {
return new ContextId(this.id + "-" + this.children.incrementAndGet());
}
String getId() {
return this.id;
}
}
}
当SpringApplication构建器执行该方法后，加载Spring应用事件监听器的动作立即执行。
1.5、加载Spring应用事件监听器(ApplicationContextInitializer)
与加载ApplicationContextInitializer逻辑相同。
1.6、推断应用引导类
推断应用引导类是SpringApplication构造过程的末尾动作，其执行方法为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;
}
该方法根据当前线程执行栈来判断其栈中哪个类包含main方法。尽管这个方法的实现并不严谨，不过可覆盖绝大多数以Java的标准main方法引导的情况。
至此在SpringApplication构造的过程中，SpringApplication属性primarySources、webApplicationType、initializers、listeners和mainApplicationClass均得到了初始化，下面讨论他们在不同阶段所扮演的角色。
2、SpringApplication配置阶段
配置阶段位于构造阶段和运行阶段之间，该阶段是可选的，主要用于调整或补充构造阶段的状态、左右运行时行为，以SpringApplication setter方法为代表，用于调整SpringApplication的行为，补充行为则以add*方法为主，或许通过setter方法配置SpringApplication 过于繁琐，因此Spring Boot引入SpringApplicationBuilder以提升API的便利性，多数情况下无须调整SpringApplication的默认状态。
2.1、自定义SpringApplication
自定义SpringApplication一共有三种方式：
- 调整SpringApplication设置
- 增加SpringApplication配置源
- 调整Spring Boot外部化配置
2.2、调整SpringApplication设置
几乎所有SpringApplication调整应用行为的方法都与SpringApplicationBuilder方法一一对应：
2.3、增加SpringApplication配置源
SpringApplication构造参数primarySources是从Spring Boot2.0开始引入的，作为主配置类，还有一个sources属性充当配置源的角色，分别来自@Configuration Class、XML配置文件和package。
public void setSources(Set<String> sources) {
Assert.notNull(sources, "Sources must not be null");
this.sources = new LinkedHashSet<>(sources);
}
public Set<Object> getAllSources() {
Set<Object> allSources = new LinkedHashSet<>();
if (!CollectionUtils.isEmpty(this.primarySources)) {
allSources.addAll(this.primarySources);
}
if (!CollectionUtils.isEmpty(this.sources)) {
allSources.addAll(this.sources);
}
return Collections.unmodifiableSet(allSources);
}
2.4、调整Spring Boot外部化配置
Spring Boot允许将配置外部化，以便在不同的环境中使用相同的应用程序代码。可以使用各种外部配置源，包括Java属性文件、YAML文件、环境变量和命令行参数。
属性值可以通过@Value注释直接注入到bean中，通过Spring的环境抽象访问，或者通过@ConfigurationProperties绑定到结构化对象。
Spring Boot使用了一个非常特殊的PropertySource排序，它被设计成允许合理地重写值。属性按以下顺序考虑（来自较低项的值将覆盖较早项的值）：
- 默认属性（通过设置SpringApplication.setDefaultProperties指定）。
- @Configuration类上的@PropertySource注解。请注意，在刷新应用程序上下文之前，不会将此类属性源添加到环境中。现在配置某些属性（如logging.和spring.main.）为时已晚，这些属性将在刷新开始前读取。
- 配置数据（如application.properties文件）
- 一个RandomValuePropertySource，它只在random.*中具有属性。
- 操作系统环境变量。
- Java系统属性（System.getProperties()）。
- 来自的JNDI属性java:comp/env.
- ServletContext初始化参数。
- ServletConfig初始化参数。
- SPRING_APPLICATION_JSON属性（嵌入在环境变量或系统属性中的内联JSON）。
- 命令行参数。
- 属性属性。可在@SpringBootTest和测试注解上获得，用于测试应用程序的特定部分。
- 测试类上的@TestPropertySource注解。
- Devtools处于活动状态时，$HOME/.config/spring 引导目录中的Devtools全局设置属性。
配置数据文件按以下顺序考虑：
- 打包在jar中的应用程序属性（application.properties和YAML变体）。
- 打包在jar中的特定profile配置文件的应用程序属性（application-{profile}.properties和YAML变体）。
- 打包jar之外的应用程序属性（application.properties和YAML变体）。
- 在打包的jar之外配置特定于应用程序的属性（application-{profile}.properties和YAML变体）。
建议对整个应用程序使用一种格式。如果在同一位置有同时具有.properties和.yml格式的配置文件，则优先使用.properties。
发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/195673.html原文链接：https://javaforall.cn
【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛
【官方授权 正版激活】： 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...
