|
此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 Spring Boot 3.4.0！ |
SpringApplication 应用程序
这SpringApplication类提供了一种便捷的方法来引导从main()方法。
在许多情况下，您可以委托给 staticSpringApplication.run(Class, String…)方法，如以下示例所示：
-
Java
-
Kotlin
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);
}
}import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
@SpringBootApplication
class MyApplication
fun main(args: Array<String>) {
runApplication<MyApplication>(*args)
}当您的应用程序启动时，您应该会看到类似于以下输出的内容：
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v3.3.7-SNAPSHOT)
2024-11-29T09:35:40.572Z INFO 87201 --- [ main] o.s.b.d.f.logexample.MyApplication : Starting MyApplication using Java 17.0.13 with PID 87201 (/opt/apps/myapp.jar started by myuser in /opt/apps/)
2024-11-29T09:35:40.603Z INFO 87201 --- [ main] o.s.b.d.f.logexample.MyApplication : No active profile set, falling back to 1 default profile: "default"
2024-11-29T09:35:43.701Z INFO 87201 --- [ main] o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat initialized with port 8080 (http)
2024-11-29T09:35:43.756Z INFO 87201 --- [ main] o.apache.catalina.core.StandardService : Starting service [Tomcat]
2024-11-29T09:35:43.761Z INFO 87201 --- [ main] o.apache.catalina.core.StandardEngine : Starting Servlet engine: [Apache Tomcat/10.1.33]
2024-11-29T09:35:43.938Z INFO 87201 --- [ main] o.a.c.c.C.[Tomcat].[localhost].[/] : Initializing Spring embedded WebApplicationContext
2024-11-29T09:35:43.940Z INFO 87201 --- [ main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 3132 ms
2024-11-29T09:35:45.149Z INFO 87201 --- [ main] o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat started on port 8080 (http) with context path '/'
2024-11-29T09:35:45.169Z INFO 87201 --- [ main] o.s.b.d.f.logexample.MyApplication : Started MyApplication in 5.7 seconds (process running for 6.759)默认情况下，INFO将显示日志记录消息，包括一些相关的启动详细信息，例如启动应用程序的用户。
如果您需要的日志级别不是INFO中，您可以设置它，如 Log Levels 中所述。
应用程序版本是使用主应用程序类的包中的实现版本确定的。
可以通过设置spring.main.log-startup-info自false.
这还将关闭应用程序活动配置文件的日志记录。
要在启动期间添加其他日志记录，您可以覆盖logStartupInfo(boolean)在SpringApplication. |
启动失败
如果您的应用程序无法启动，请注册FailureAnalyzerbean 有机会提供专用的错误消息和解决问题的具体作。
例如，如果您在 port 上启动 Web 应用程序8080并且该端口已在使用中，您应该会看到类似于以下消息的内容：
***************************
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 提供了许多FailureAnalyzerimplementations，您可以添加自己的实现。 |
如果没有故障分析器能够处理异常，您仍然可以显示完整的条件报告，以更好地了解出了什么问题。
为此，您需要启用debug财产或使DEBUGLogging为ConditionEvaluationReportLoggingListener.
例如，如果您使用java -jar中，您可以启用debug属性，如下所示：
$ java -jar myproject-0.0.1-SNAPSHOT.jar --debug延迟初始化
SpringApplication允许延迟初始化应用程序。
启用延迟初始化后，将根据需要创建 bean，而不是在应用程序启动期间创建 bean。
因此，启用延迟初始化可以减少应用程序启动所需的时间。
在 Web 应用程序中，启用延迟初始化将导致许多与 Web 相关的 bean 在收到 HTTP 请求之前不会初始化。
延迟初始化的一个缺点是，它可能会延迟发现应用程序的问题。 如果延迟初始化了配置错误的 bean，则在启动期间将不再发生失败，并且只有在初始化 bean 时问题才会变得明显。 还必须注意确保 JVM 具有足够的内存来容纳应用程序的所有 bean，而不仅仅是在启动期间初始化的 bean。 由于这些原因，默认情况下不启用延迟初始化，建议在启用延迟初始化之前对 JVM 的堆大小进行微调。
可以使用lazyInitializationmethod 开启SpringApplicationBuilder或setLazyInitializationmethod 开启SpringApplication.
或者，也可以使用spring.main.lazy-initialization属性，如以下示例所示：
-
Properties
-
YAML
spring.main.lazy-initialization=truespring:
main:
lazy-initialization: true如果要对某些 bean 禁用惰性初始化，同时对应用程序的其余部分使用惰性初始化，则可以使用@Lazy(false)注解。 |
自定义横幅
启动时打印的横幅可以通过添加banner.txtfile 添加到你的 classpath 中，或者通过将spring.banner.location属性设置为此类文件的位置。
如果文件的编码不是 UTF-8，则可以设置spring.banner.charset.
在您的banner.txt文件中，您可以使用Environment以及以下任何占位符：
| 变量 | 描述 |
|---|---|
|
应用程序的版本号，如 |
|
应用程序的版本号，如 |
|
您正在使用的 Spring Boot 版本。
例如 |
|
您正在使用的 Spring Boot 版本，格式设置为显示（用括号括起来，前缀为 |
|
哪里 |
|
应用程序的标题，如 |
这SpringApplication.setBanner(…)method 来启用。
使用Banner接口并实现您自己的printBanner()方法。 |
您还可以使用spring.main.banner-mode属性来确定是否必须打印横幅System.out (console），发送到配置的记录器 （log）或根本不生产 （off).
打印的横幅将注册为以下名称下的单例 Bean：springBootBanner.
|
这 要使用 |
自定义 SpringApplication
如果SpringApplication默认值不符合您的口味，您可以改为创建本地实例并对其进行自定义。
例如，要关闭横幅，您可以编写：
-
Java
-
Kotlin
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);
}
}import org.springframework.boot.Banner
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
@SpringBootApplication
class MyApplication
fun main(args: Array<String>) {
runApplication<MyApplication>(*args) {
setBannerMode(Banner.Mode.OFF)
}
}传递给SpringApplication是 Spring bean 的配置源。
在大多数情况下，这些是对@Configuration类，但它们也可以是直接引用@Component类。 |
还可以配置SpringApplication通过使用application.properties文件。
有关详细信息，请参阅 外部化配置 。
有关配置选项的完整列表，请参阅SpringApplicationAPI 文档。
Fluent Builder API
如果您需要构建一个ApplicationContext层次结构（具有父/子关系的多个上下文），或者如果您更喜欢使用 Fluent Builder API，则可以使用SpringApplicationBuilder.
这SpringApplicationBuilder允许您将多个方法调用链接在一起，并包含parent和child方法，如以下示例所示：
-
Java
-
Kotlin
new SpringApplicationBuilder().sources(Parent.class)
.child(Application.class)
.bannerMode(Banner.Mode.OFF)
.run(args); SpringApplicationBuilder()
.sources(Parent::class.java)
.child(Application::class.java)
.bannerMode(Banner.Mode.OFF)
.run(*args)创建ApplicationContext等级制度。
例如，Web 组件必须包含在子上下文中，并且相同的Environment用于父上下文和子上下文。
请参阅SpringApplicationBuilderAPI 文档了解完整详细信息。 |
应用程序可用性
在平台上部署时，应用程序可以使用 Kubernetes 探针等基础设施向平台提供有关其可用性的信息。 Spring Boot 包括对常用的“liveness”和“readiness”可用性状态的开箱即用支持。 如果您使用的是 Spring Boot 的“actuator”支持，则这些状态将作为运行状况端点组公开。
此外，您还可以通过注入ApplicationAvailability接口连接到您自己的 bean 中。
活动状态
应用程序的 “Liveness” 状态表明其内部状态是否允许它正常工作，或者如果当前出现故障，则自行恢复。 损坏的 “Liveness” 状态意味着应用程序处于无法恢复的状态，基础设施应重新启动应用程序。
| 通常，“Liveness” 状态不应基于外部检查，例如运行状况检查。 如果是这样，则失败的外部系统（数据库、Web API、外部缓存）将在整个平台上触发大规模重启和级联故障。 |
Spring Boot 应用程序的内部状态主要由 SpringApplicationContext.
如果应用程序上下文已成功启动，则 Spring Boot 假定应用程序处于有效状态。
一旦刷新上下文，应用程序就被视为实时应用程序，请参阅 Spring Boot 应用程序生命周期和相关应用程序事件。
就绪状态
应用程序的 “Readiness” 状态表明应用程序是否已准备好处理流量。
失败的 “Readiness” 状态告诉平台它暂时不应将流量路由到应用程序。
这通常发生在启动期间，而CommandLineRunner和ApplicationRunner组件正在处理中，或者如果应用程序决定它太忙而无法进行其他流量，则随时处理。
一旦调用了应用程序和命令行运行器，应用程序就被视为准备就绪，请参阅 Spring Boot 应用程序生命周期和相关应用程序事件。
预期在启动期间运行的任务应由CommandLineRunner和ApplicationRunner组件，而不是使用 Spring 组件生命周期回调，例如@PostConstruct. |
管理应用程序可用性状态
应用程序组件可以随时检索当前可用性状态，方法是将ApplicationAvailability接口并调用方法。
更常见的是，应用程序需要侦听状态更新或更新应用程序的状态。
例如，我们可以将应用程序的 “Readiness” 状态导出到一个文件中，以便 Kubernetes “exec Probe” 可以查看此文件：
-
Java
-
Kotlin
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.ReadinessState
import org.springframework.context.event.EventListener
import org.springframework.stereotype.Component
@Component
class MyReadinessStateExporter {
@EventListener
fun onStateChange(event: AvailabilityChangeEvent<ReadinessState?>) {
when (event.state) {
ReadinessState.ACCEPTING_TRAFFIC -> {
// create file /tmp/healthy
}
ReadinessState.REFUSING_TRAFFIC -> {
// remove file /tmp/healthy
}
else -> {
// ...
}
}
}
}当应用程序中断且无法恢复时，我们还可以更新应用程序的状态：
-
Java
-
Kotlin
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);
}
}
}import org.springframework.boot.availability.AvailabilityChangeEvent
import org.springframework.boot.availability.LivenessState
import org.springframework.context.ApplicationEventPublisher
import org.springframework.stereotype.Component
@Component
class MyLocalCacheVerifier(private val eventPublisher: ApplicationEventPublisher) {
fun checkLocalCache() {
try {
// ...
} catch (ex: CacheCompletelyBrokenException) {
AvailabilityChangeEvent.publish(eventPublisher, ex, LivenessState.BROKEN)
}
}
}应用程序事件和侦听器
除了通常的 Spring Framework 事件（例如ContextRefreshedEvent一个SpringApplication发送一些其他应用程序事件。
|
有些事件实际上是在 如果您希望自动注册这些侦听器，而不管应用程序是如何创建的，您可以添加 |
应用程序事件在应用程序运行时按以下顺序发送：
-
一
ApplicationStartingEvent在运行开始时发送，但在任何处理之前发送，侦听器和初始值设定项的注册除外。 -
一
ApplicationEnvironmentPreparedEvent在Environmentto be used in the context 是已知的，但在创建上下文之前。 -
一
ApplicationContextInitializedEvent在ApplicationContext已准备好并调用ApplicationContextInitializers，但在加载任何 bean 定义之前。 -
一
ApplicationPreparedEvent在刷新开始之前发送，但在加载 Bean 定义之后发送。 -
一
ApplicationStartedEvent在刷新上下文之后，但在调用任何应用程序和命令行运行程序之前发送。 -
一
AvailabilityChangeEvent紧随其后发送LivenessState.CORRECT，表示应用程序被视为 Live。 -
一
ApplicationReadyEvent在调用任何应用程序和命令行运行程序后发送。 -
一
AvailabilityChangeEvent紧随其后发送ReadinessState.ACCEPTING_TRAFFIC以指示应用程序已准备好为请求提供服务。 -
一
ApplicationFailedEvent如果启动时出现异常，则发送。
以上列表仅包括SpringApplicationEvents 绑定到SpringApplication.
除此之外，以下事件还会在ApplicationPreparedEvent和之前ApplicationStartedEvent:
-
一个
WebServerInitializedEvent在WebServer已准备就绪。ServletWebServerInitializedEvent和ReactiveWebServerInitializedEvent分别是 servlet 和 reactive 变体。
| 您通常不需要使用应用程序事件，但知道它们存在会很方便。 在内部， Spring Boot 使用事件来处理各种任务。 |
| 事件侦听器不应运行可能很长的任务，因为它们默认在同一线程中执行。 请考虑改用应用程序和命令行运行程序。 |
应用程序事件是使用 Spring Framework 的事件发布机制发送的。
此机制的一部分可确保发布到子上下文中的侦听器的事件也发布到任何祖先上下文中的侦听器。
因此，如果您的应用程序使用SpringApplication实例，则侦听器可能会接收同一类型应用程序事件的多个实例。
要使侦听器能够区分其上下文的事件和后代上下文的事件，它应请求注入其应用程序上下文，然后将注入的上下文与事件的上下文进行比较。
可以通过实现ApplicationContextAware或者，如果侦听器是一个 Bean，则通过使用@Autowired.
Web 环境
一个SpringApplication尝试创建正确类型的ApplicationContext代表您。
用于确定WebApplicationType如下所示：
-
如果存在 Spring MVC，则
AnnotationConfigServletWebServerApplicationContext已使用 -
如果 Spring MVC 不存在，而 Spring WebFlux 存在，则
AnnotationConfigReactiveWebServerApplicationContext已使用
这意味着，如果您使用的是 Spring MVC 和新的WebClient来自同一应用程序中的 Spring WebFlux，则默认情况下将使用 Spring MVC。
您可以通过调用setWebApplicationType(WebApplicationType).
也可以完全控制ApplicationContexttype 使用，该setApplicationContextFactory(…).
通常希望调用setWebApplicationType(WebApplicationType.NONE)使用SpringApplication在 JUnit 测试中。 |
访问应用程序参数
如果您需要访问传递给SpringApplication.run(…)，您可以注入ApplicationArguments豆。
这ApplicationArguments接口提供对原始String[]参数以及 parsedoption和non-option参数，如以下示例所示：
-
Java
-
Kotlin
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"]
}
}import org.springframework.boot.ApplicationArguments
import org.springframework.stereotype.Component
@Component
class MyBean(args: ApplicationArguments) {
init {
val debug = args.containsOption("debug")
val files = args.nonOptionArgs
if (debug) {
println(files)
}
// if run with "--debug logfile.txt" prints ["logfile.txt"]
}
}Spring Boot 还会注册一个CommandLinePropertySource带弹簧Environment.
这样，您还可以使用@Value注解。 |
使用 ApplicationRunner 或 CommandLineRunner
如果您需要运行某个特定的代码一次，SpringApplication已启动，您可以实现ApplicationRunner或CommandLineRunner接口。
这两个接口以相同的方式工作，并提供单个run方法，该方法在SpringApplication.run(…)完成。
| 此协定非常适合应在应用程序启动之后但在开始接受流量之前运行的任务。 |
这CommandLineRunnerinterfaces 以字符串数组的形式提供对应用程序参数的访问，而ApplicationRunner使用ApplicationArguments接口。
以下示例显示了CommandLineRunner替换为run方法：
-
Java
-
Kotlin
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
@Component
public class MyCommandLineRunner implements CommandLineRunner {
@Override
public void run(String... args) {
// Do something...
}
}import org.springframework.boot.CommandLineRunner
import org.springframework.stereotype.Component
@Component
class MyCommandLineRunner : CommandLineRunner {
override fun run(vararg args: String) {
// Do something...
}
}如果多个CommandLineRunner或ApplicationRunnerbean 必须按特定顺序调用，您还可以实现Ordered界面或使用Order注解。
应用程序退出
每SpringApplication向 JVM 注册一个关闭钩子，以确保ApplicationContext退出时正常关闭。
所有标准的 Spring 生命周期回调（例如DisposableBeaninterface 或@PreDestroyannotation） 的 intent 调用。
此外，bean 可以实现ExitCodeGenerator接口，如果他们希望在SpringApplication.exit()被调用。
然后，可以将此退出代码传递给System.exit()将其作为状态代码返回，如以下示例所示：
-
Java
-
Kotlin
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)));
}
}import org.springframework.boot.ExitCodeGenerator
import org.springframework.boot.SpringApplication
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
import org.springframework.context.annotation.Bean
import kotlin.system.exitProcess
@SpringBootApplication
class MyApplication {
@Bean
fun exitCodeGenerator() = ExitCodeGenerator { 42 }
}
fun main(args: Array<String>) {
exitProcess(SpringApplication.exit(
runApplication<MyApplication>(*args)))
}此外，ExitCodeGeneratorinterface 可以通过 exceptions 实现。
当遇到这样的异常时， Spring Boot 返回由实现的getExitCode()方法。
如果有多个ExitCodeGenerator，则使用生成的第一个非零退出代码。
要控制生成器的调用顺序，请另外实现Ordered界面或使用Order注解。
管理员功能
可以通过指定spring.application.admin.enabled财产。
这将公开SpringApplicationAdminMXBean在平台上MBeanServer.
您可以使用此功能远程管理 Spring Boot 应用程序。
此功能对于任何服务包装器实现也很有用。
如果您想知道应用程序正在哪个 HTTP 端口上运行，请获取键为local.server.port. |
应用程序启动跟踪
在应用程序启动期间，SpringApplication和ApplicationContext执行许多与应用程序生命周期相关的任务，
bean 生命周期，甚至处理应用程序事件。
跟ApplicationStartup，Spring Framework 允许您使用 StartupStep对象。
收集此数据可以用于分析目的，或者只是为了更好地了解应用程序启动过程。
您可以选择ApplicationStartup在设置SpringApplication实例。
例如，要使用BufferingApplicationStartup，你可以写成：
-
Java
-
Kotlin
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);
}
}import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.context.metrics.buffering.BufferingApplicationStartup
import org.springframework.boot.runApplication
@SpringBootApplication
class MyApplication
fun main(args: Array<String>) {
runApplication<MyApplication>(*args) {
applicationStartup = BufferingApplicationStartup(2048)
}
}第一个可用的实现FlightRecorderApplicationStartup由 Spring Framework 提供。
它将特定于 Spring 的启动事件添加到 Java Flight Recorder 会话中，用于分析应用程序并将其 Spring 上下文生命周期与 JVM 事件（例如分配、GC、类加载等）相关联。
配置后，您可以通过在启用 Flight Recorder 的情况下运行应用程序来记录数据：
$ java -XX:StartFlightRecording:filename=recording.jfr,duration=10s -jar demo.jarSpring Boot 附带了BufferingApplicationStartup变体;此实现用于缓冲启动步骤并将其排空到外部 Metrics 系统中。
应用程序可以请求BufferingApplicationStartup在任何组件中。
Spring Boot 也可以配置为公开startup端点，该文档以 JSON 文档的形式提供此信息。
虚拟线程
如果您在 Java 21 或更高版本上运行，则可以通过将属性spring.threads.virtual.enabled自true.
在为您的应用程序启用此选项之前，您应该考虑阅读官方 Java 虚拟线程文档。
在某些情况下，由于“固定虚拟线程”，应用程序的吞吐量可能会降低;本页还介绍了如何使用 JDK Flight Recorder 或jcmdCLI 的
| 如果启用了虚拟线程，则配置线程池的属性将不再有效。 这是因为虚拟线程被调度在 JVM 范围的平台线程池上，而不是在专用线程池上。 |
虚拟线程的一个副作用是它们是守护程序线程。
如果 JVM 的所有线程都是守护程序线程，则 JVM 将退出。
当您依赖@Scheduledbean 来保持应用程序处于活动状态。
如果使用虚拟线程，则调度程序线程是虚拟线程，因此是守护程序线程，不会使 JVM 保持活动状态。
这不仅会影响调度，其他技术也可能如此。
要使 JVM 在所有情况下都运行，建议将spring.main.keep-alive自true.
这可确保 JVM 保持活动状态，即使所有线程都是虚拟线程也是如此。 |