Spring Boot核心特性（一）——SpringApplication

最新推荐文章于 2024-04-27 14:50:57 发布

CoderSheng

最新推荐文章于 2024-04-27 14:50:57 发布

阅读量1k

点赞数 30

分类专栏： Spring 文章标签： spring boot 后端 java

本文链接：https://blog.csdn.net/shxy17/article/details/135791523

版权

Spring 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

本章节对应SpringBoot官方学习文档v3.2.1中第七章

Spring Boot核心特性（一）——SpringApplication

1 SpringApplication

1 SpringApplication

SpringApplication类提供了一种方便的方法来引导从main（）方法启动的Spring应用程序。在许多情况下，您可以委托给静态的SpringApplication.run方法，如以下示例所示

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MyApplication {
  public static void main(String[] args) {
  SpringApplication.run(MyApplication.class, args);
  }
}

当您的应用程序启动时，您应该会看到类似于以下输出的内容：

  . ____ _ __ _ _
 /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/ ___)| |_)| | | | | || (_| | ) ) ) )
  ' |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot :: (v3.2.1)
2023-12-21T12:10:16.604Z INFO 36090 --- [ main]
o.s.b.d.f.logexample.MyApplication : Starting MyApplication using Java 17.0.9
with PID 36090 (/opt/apps/myapp.jar started by myuser in /opt/apps/)
2023-12-21T12:10:16.609Z INFO 36090 --- [ main]
o.s.b.d.f.logexample.MyApplication : No active profile set, falling back to 1
default profile: "default"
2023-12-21T12:10:17.724Z INFO 36090 --- [ main]
o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat initialized with port 8080 (http)
2023-12-21T12:10:17.740Z INFO 36090 --- [ main]
o.apache.catalina.core.StandardService : Starting service [Tomcat]
2023-12-21T12:10:17.740Z INFO 36090 --- [ main]
o.apache.catalina.core.StandardEngine : Starting Servlet engine: [Apache
Tomcat/10.1.17]
2023-12-21T12:10:17.806Z INFO 36090 --- [ main]
o.a.c.c.C.[Tomcat].[localhost].[/] : Initializing Spring embedded
WebApplicationContext
2023-12-21T12:10:17.807Z INFO 36090 --- [ main]
w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization
completed in 1131 ms
2023-12-21T12:10:18.302Z INFO 36090 --- [ main]
o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat started on port 8080 (http) with
context path ''
2023-12-21T12:10:18.317Z INFO 36090 --- [ main]
o.s.b.d.f.logexample.MyApplication : Started MyApplication in 2.173 seconds
(process running for 2.504)

默认情况下，会显示INFO日志记录消息，包括一些相关的启动详细信息，例如启动应用程序的用户。如果您需要INFO以外的日志级别，您可以设置它，如下文日志记录中所述。应用程序版本是使用主应用程序类的包中的实现版本来确定的。可以通过将spring.main.log-Startup-info设置为false来关闭启动信息日志记录。这也将关闭应用程序活动配置文件的日志记录。
要在启动期间添加额外的日志记录，可以覆盖SpringApplication子类中的logStartupInfo（布尔值）。

1.1 启动错误处置

如果您的应用程序无法启动，注册的FailureAnalyzers将有机会提供专用的错误消息和解决问题的具体操作。例如，如果您在端口8080上启动web应用程序，并且该端口已在使用中，您应该会看到类似于以下消息的内容：

***************************
APPLICATION FAILED TO START
***************************
Description:
Embedded servlet container failed to start. Port 8080 was already in use.
Action:
Identify and stop the process that is listening on port 8080 or configure this
application to listen on another port.

Spring Boot提供了许多FailureAnalyzer实现，您可以添加自己的实现。
如果没有故障分析器能够处理异常，您仍然可以显示完整的条件报告，以更好地了解问题所在。为此，您需要为org.springframework.boot.autoconfig.logging.ConditionEvaluationReportLoggingListener启用调试属性或启用debug日志记录。

例如，如果您正在使用java-jar运行应用程序，则可以启用debug属性，如下所示：

$ java -jar myproject-0.0.1-SNAPSHOT.jar --debug

1.2 延迟初始化

SpringApplication允许对应用程序进行延迟初始化。当启用延迟初始化时，将根据需要而不是在应用程序启动期间创建bean。因此，启用延迟初始化可以减少应用程序启动所需的时间。在web应用程序中，启用延迟初始化将导致许多与web相关的bean在收到HTTP请求之前无法初始化。

延迟初始化的一个缺点是，它可能会延迟发现应用程序的问题。

如果延迟初始化配置错误的bean，则在启动期间将不再发生故障，并且只有在初始化bean时问题才会变得明显。还必须注意确保JVM有足够的内存来容纳应用程序的所有bean，而不仅仅是那些在启动期间初始化的bean。由于这些原因，默认情况下不会启用延迟初始化，建议在启用延迟初始化之前对JVM的堆大小进行微调。
可以使用SpringApplicationBuilder上的lazyInitialization方法或SpringApplication上的setLazyInitialize方法以编程方式启用Lazy初始化。或者，可以使用spring.main.lazy-initialization属性启用它，如下例所示：
properties

spring.main.lazy-initialization=true

yaml

spring:
  main:
  lazy-initialization: true

如果您想对某些bean禁用延迟初始化，同时对应用程序的其余部分使用延迟初始化，则可以使用@lazy（false）注释将其延迟属性显式设置为false。

1.3 自定义Banner图

启动时打印的Banner图可以通过将banner.txt文件添加到类路径或将spring.banner.location属性设置为此类文件的位置来更改。如果文件的编码不是UTF-8，则可以设置spring.anner.charset。
在banner.txt文件中，您可以使用环境中可用的任何密钥以及以下任何占位符：
表1 Banner图属性设置

序号	变量	描述
1	${application.version}	MANIFEST.MF中声明的应用程序的版本号.例如，Implementation Version:1.0打印为1.0。
2	${application.formatted-version}	MANIFEST.MF中声明的应用程序的版本号，并格式化为显示（用括号括起来，前缀为v）。例如（v1.0）。
3	${spring-boot.version}	您正在使用的Spring Boot版本。例如3.2.1。
4	${spring-boot.formatted-version}	您正在使用的Spring Boot版本，格式化为显示（用括号括起来，前缀为v）。例如（v3.2.1）。
5	${Ansi.NAME} (or ${AnsiColor.NAME},${AnsiBackground.NAME}, ${AnsiStyle.NAME})	其中NAME是ANSI转义码的名称。有关详细信息，请参见AnsiPropertySource.
6	${application.title}	MANIFEST.MF中声明的应用程序的标题.例如，Implementation-Title: MyApp打印为MyApp。

如果您想以编程方式生成Banner图，可以使用SpringApplication.setBanner（…）方法。使用org.springframework.boot.Banner接口并实现您自己的printBanner（）方法
您还可以使用spring.main.banner-mode属性来确定是否必须在System.out（控制台）上打印Banner图、将其发送到配置的记录器（日志）或根本不生成Banner图（关闭）。
打印的Banner图以以下名称注册为singleton bean：springBootBanner。
application.title、application.version和application.formated-version属性仅在将java-jar或java-cp与Spring Boot启动器一起使用时可用。如果您正在运行一个未打包的jar并使用java-cp＜classpath＞＜mainclass＞启动它，或者将应用程序作为本机映像运行，则这些值将不会得到解析。
使用应用程序。属性，使用java-jar将应用程序作为打包的jar或使用java org.springframework.boot.loader.launch.jar将应用程序启动为未打包的jar。这将初始化应用程序。构建类路径和启动应用程序之前的Banner图属性

1.4 自定义SpringApplication

如果您不喜欢SpringApplication的默认设置，您可以创建一个本地实例并对其进行自定义。例如，要关闭Banner图，您可以写道：

import org.springframework.boot.Banner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MyApplication {
  public static void main(String[] args) {
  SpringApplication application = new SpringApplication(MyApplication.class);
  application.setBannerMode(Banner.Mode.OFF);
  application.run(args);
  }
}

传递给SpringApplication的构造函数参数是Spring bean的配置源。在大多数情况下，这些是对@Configuration类的引用，但也可以是对@Component类的直接引用
也可以使用application.properties文件来配置SpringApplication。有关详细信息，请参阅第二节《外部配置》章节
有关配置选项的完整列表，请参阅SpringApplication Javadoc文档。

1.5 快速构建API

如果您需要构建ApplicationContext层次结构（具有父/子关系的多个上下文），或者如果您更喜欢使用“流利”的生成器API，则可以使用SpringApplicationBuilder。
SpringApplicationBuilder允许您将多个方法调用链接在一起，并包括用于创建层次结构的父方法和子方法，如以下示例所示：

new SpringApplicationBuilder().sources(Parent.class)
  .child(Application.class)
  .bannerMode(Banner.Mode.OFF)
  .run(args);

创建ApplicationContext层次结构时存在一些限制。例如，Web组件必须包含在子上下文中，并且父上下文和子上下文都使用相同的环境。有关详细信息，请参阅SpringApplicationBuilder Javadoc文档。

1.6 Application的可用性

当部署在平台上时，应用程序可以使用Kubernetes Probes等基础设施向平台提供有关其可用性的信息。Spring Boot包括对常用的“活跃”和“就绪”可用性状态的开箱即用支持。如果您使用的是Spring Boot的“执行器”支持，那么这些状态将作为健康端点组公开。
此外，您还可以通过将ApplicationAvailability接口注入到自己的bean中来获得可用性状态。
存活状态——Liveness State
应用程序的“活跃”状态告诉其内部状态是否允许其正常工作，或者在当前出现故障时自行恢复。断开的“活动”状态意味着应用程序处于无法恢复的状态，基础结构应重新启动应用程序。
一般来说，“活力”状态不应基于外部检查，如健康检查。如果真的发生了，一个发生故障的外部系统（数据库、Web API、外部缓存）将触发整个平台的大规模重新启动和级联故障。
Spring Boot应用程序的内部状态主要由Spring ApplicationContext表示。如果应用程序上下文已成功启动，则Spring Boot会假定应用程序处于有效状态。上下文一刷新，应用程序就被认为是活动的，请参阅Spring Boot应用程序生命周期和相关的应用程序事件章节。
就绪状态——Readiness State
应用程序的“就绪”状态告诉应用程序是否准备好处理流量。失败的“准备就绪”状态告诉平台目前不应该将流量路由到应用程序。这种情况通常发生在启动期间，即CommandLineRunner和ApplicationRunner组件正在处理期间，或者在应用程序认为太忙而无法增加流量的任何时候。
一旦调用了应用程序和命令行运行程序，就认为应用程序已准备就绪，请参阅Spring Boot应用程序生命周期和相关的应用程序事件章节。
预期在启动期间运行的任务应由CommandLineRunner和ApplicationRunner组件执行，而不是使用Spring组件生命周期回调（如@PostConstruct）。
应用程序可用性状态——Application Availability State
应用程序组件可以通过注入ApplicationAvailability接口并在其上调用方法，随时检索当前可用性状态。更常见的情况是，应用程序希望侦听状态更新或更新应用程序的状态。
例如，我们可以将应用程序的“就绪”状态导出到一个文件中，以便Kubernetes的“exec Probe”可以查看此文件：

import org.springframework.boot.availability.AvailabilityChangeEvent;
import org.springframework.boot.availability.ReadinessState;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;
@Component
public class MyReadinessStateExporter {
  @EventListener
  public void onStateChange(AvailabilityChangeEvent<ReadinessState> event) {
  switch (event.getState()) {
  case ACCEPTING_TRAFFIC -> {
  // create file /tmp/healthy
  }
  case REFUSING_TRAFFIC -> {
  // remove file /tmp/healthy
  }
  }
  }
}

当应用程序中断且无法恢复时，我们还可以更新应用程序的状态：

import org.springframework.boot.availability.AvailabilityChangeEvent;
import org.springframework.boot.availability.LivenessState;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Component;
@Component
public class MyLocalCacheVerifier {
  private final ApplicationEventPublisher eventPublisher;
  public MyLocalCacheVerifier(ApplicationEventPublisher eventPublisher) {
  this.eventPublisher = eventPublisher;
  }
  public void checkLocalCache() {
  try {
  // ...
  }
  catch (CacheCompletelyBrokenException ex) {
  AvailabilityChangeEvent.publish(this.eventPublisher, ex,
LivenessState.BROKEN);
  }
  }
}

Spring Boot为具有执行器健康端点的“Liveness”和“Readiness”提供了Kubernetes HTTP探测。您可以在专用部分中获得更多关于在Kubernetes上部署Spring Boot应用程序的指导。

1.7 应用程序事件和侦听器

除了常见的Spring Framework事件（如ContextRefreshedEvent）之外，SpringApplication还会发送一些额外的应用程序事件。

注：
1、有些事件实际上是在创建ApplicationContext之前触发的，因此您无法将这些事件上的侦听器注册为@Bean。您可以使用SpringApplication.addListeners（…）方法或SpringApplicationBuilder.listeners（…）方式注册它们。
2、如果您希望这些侦听器自动注册，无论应用程序是以何种方式创建的，您都可以将META-INF/spring.factores文件添加到您的项目中，并使用org.springframework.context.ApplicationListener键引用您的侦听器，如下例所示：
org.springframework.context.ApplicationListener=com.example.project.MyLi
stener

应用程序事件在应用程序运行时按以下顺序发送：

ApplicationStartingEvent在运行开始时发送，但在任何处理之前发送，侦听器和初始化器的注册除外。
当要在上下文中使用的Environment是已知的但在创建上下文之前，会发送ApplicationEnvironmentPreparedEvent。
当ApplicationContext被准备好并且ApplicationContextInitializers已经被调用但在任何bean定义被加载之前，发送ApplicationContextInitializedEvent。
ApplicationPreparedEvent在上下文刷新开始之前但在bean定义加载之后发送。
在刷新上下文之后，但在调用任何应用程序和命令行运行程序之前，会发送ApplicationStartedEvent。
在LivenessState.CORRECT 之后立即发送AvailabilityChangeEvent。表示应用程序被视为存活。
在调用任何应用程序和命令行运行程序后，都会发送ApplicationReadyEvent。
AvailabilityChangeEvent在ReadinessState.ACCEPTING_TRAFFIC之后立即发送。以指示应用程序已准备好为请求提供服务。
如果启动时出现异常，则会发送ApplicationFailedEvent。

上面的列表只包括绑定到SpringApplication的SpringApplicationEvents。除此之外，以下事件也在ApplicationPreparedEvent之后和ApplicationStartedEvent之前发布：

WebServer准备就绪后，将发送WebServerInitializedEvent。ServletWebServerInitializedEvent和ReactiveWebServerInitializedEvent分别是servlet和reactive变体。
刷新ApplicationContext时会发送ContextRefreshedEvent。

您通常不需要使用应用程序事件，但知道它们的存在会很方便。在内部，Spring Boot使用事件来处理各种任务。
默认情况下，事件侦听器不应运行可能很长的任务，因为它们在同一线程中执行。请考虑改用应用程序和命令行运行程序。

应用程序事件是通过使用Spring Framework的事件发布机制发送的。此机制的一部分确保在子上下文中发布给侦听器的事件也在任何祖先上下文中发布到侦听器。因此，如果您的应用程序使用SpringApplication实例的层次结构，则侦听器可能会接收到同一类型应用程序事件的多个实例。

为了允许侦听器区分其上下文的事件和子上下文的事件，它应该请求注入其应用程序上下文，然后将注入的上下文与事件的上下文进行比较。上下文可以通过实现ApplicationContextAware来注入，如果侦听器是bean，则可以使用@Autowired来注入。

1.8 Web环境

SpringApplication试图代表您创建正确类型的ApplicationContext。用于确定WebApplicationType的算法如下：

如果存在Spring MVC，则AnnotationConfigServlet WebServerApplicationContext会被使用
如果不存在Spring MVC而存在Spring WebFlux，则AnnotationConfigReactiveWebServerApplicationContext会被使用
否则，Annotation ConfigApplicationContext会被使用

这意味着，如果您在同一应用程序中使用Spring MVC和Spring WebFlux的新WebClient，则默认情况下将使用Spring MVC。您可以通过调用setWebApplicationType（WebApplicationType）来轻松覆盖它。

也可以完全控制通过调用setApplicationContextFactory（…）使用的ApplicationContext类型

在JUnit测试中使用SpringApplication时，通常需要调用setWebApplicationType（WebApplicationType.NONE）。

1.9 访问应用程序参数

如果需要访问传递给SpringApplication.run（…）的应用程序参数，可以注入org.springframework.boot.ApplicationArguments bean。ApplicationArguments接口提供对原始String[]参数以及已解析的option和non-option参数的访问，如以下示例所示：

import java.util.List;
import org.springframework.boot.ApplicationArguments;
import org.springframework.stereotype.Component;
@Component
public class MyBean {
  public MyBean(ApplicationArguments args) {
  boolean debug = args.containsOption("debug");
  List<String> files = args.getNonOptionArgs();
  if (debug) {
  System.out.println(files);
  }
  // if run with "--debug logfile.txt" prints ["logfile.txt"]
  }
}

Spring Boot还向Spring Environment注册CommandLinePropertySource。这还允许您使用@Value注释注入单个应用程序参数。

1.10 ApplicationRunner和CommandLineRunner的使用

如果您需要在SpringApplication启动后运行一些特定的代码，您可以实现ApplicationRunner或CommandLineRunner接口。两个接口的工作方式相同，提供了一个单次运行方法，该方法在SpringApplication.run（…）完成之前调用。
此约定非常适合在应用程序启动后但在开始接受流量之前运行的任务。
CommandLineRunner接口以字符串数组的形式提供对应用程序参数的访问，而ApplicationRunner使用前面讨论的ApplicationArguments接口。以下示例显示了带有run方法的CommandLineRunner：

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
@Component
public class MyCommandLineRunner implements CommandLineRunner {
  @Override
  public void run(String... args) {
  // Do something...
  }
}

如果定义了几个必须按特定顺序调用的CommandLineRunner或ApplicationRunner bean，则可以另外实现org.springframework.core.Ordered接口或使用org.springfframework.core.annotation.order注解。

1.11 应用程序退出

每个SpringApplication都向JVM注册一个关闭挂钩，以确保ApplicationContext在退出时正常关闭。所有标准的Spring生命周期回调（如DisposableBean接口或@PreDestroy注释）都可以使用。
此外，如果bean 希望在调用SpringApplication.exit（）时返回特定的退出代码，则它们可以实现org.springframework.boot.ExitCodeGenerator接口。然后可以将此退出代码传递给System.exit（），以将其作为状态代码返回，如以下示例所示：

import org.springframework.boot.ExitCodeGenerator;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
@SpringBootApplication
public class MyApplication {
  @Bean
  public ExitCodeGenerator exitCodeGenerator() {
  return () -> 42;
  }
  public static void main(String[] args) {
  System.exit(SpringApplication.exit(SpringApplication.run(MyApplication.class,
args)));
  }
}

此外，ExitCodeGenerator接口也可能由例外情况实现。当遇到这样的异常时，Spring Boot返回由实现的getExitCode（）方法提供的退出代码。
如果存在多个ExitCodeGenerator，则使用生成的第一个非零退出代码。要控制生成器的调用顺序，请另外实现org.springframework.core.Ordered接口或使用org.springfframework.core.annotation.order注解。

1.12 管理特性

在应用程序启动期间，SpringApplication和ApplicationContext执行许多与应用程序生命周期、bean生命周期甚至处理应用程序事件有关的任务。通过ApplicationStartup，Spring Framework允许您使用StartupStep对象跟踪应用程序启动顺序。收集这些数据可以用于分析目的，也可以只是为了更好地了解应用程序启动过程。
您可以在设置SpringApplication实例时选择ApplicationStartup实现。例如，要使用BufferingApplicationStartup，您可以编写：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.metrics.buffering.BufferingApplicationStartup;
@SpringBootApplication
public class MyApplication {
  public static void main(String[] args) {
  SpringApplication application = new SpringApplication(MyApplication.class);
  application.setApplicationStartup(new BufferingApplicationStartup(2048));
  application.run(args);
  }
}

第一个可用的实现FlightRecorderApplicationStartup由Spring Framework提供。它将特定于Spring的启动事件添加到Java Flight Recorder会话中，用于分析应用程序，并将其Spring上下文生命周期与JVM事件（如分配、GC、类加载…）关联起来。配置后，您可以在启用Flight Recorder的情况下运行应用程序来记录数据：

$ java -XX:StartFlightRecording:filename=recording.jfr,duration=10s -jar demo.jar

Spring Boot附带BufferingApplicationStartup变体；此实现旨在缓冲启动步骤，并将它们排入外部度量系统。应用程序可以在任何组件中请求BufferingApplicationStartup类型的bean。

Spring Boot还可以被配置为公开一个启动端点，该端点以JSON文档的形式提供这些信息。

1.14 虚拟线程

如果您在Java 21或更高版本上运行，您可以通过将属性spring.threads.virtual.enabled设置为true来启用虚拟线程。
虚拟线程的一个副作用是这些线程是守护进程线程。如果没有非守护进程线程，JVM将退出。当您依赖@Scheduled beans来保持应用程序的活力时，这种行为可能会成为一个问题。

注意：
如果使用虚拟线程，则调度程序线程是一个虚拟线程，因此是一个守护进程线程，不会使JVM保持活动状态。这不仅会影响调度，其他技术也可能如此！为了在所有情况下保持JVM的运行，建议将属性spring.main.keep-alive设置为true。这确保JVM保持活动状态，即使所有线程都是虚拟线程。