对于最新的稳定版本，请使用 Spring Boot 3.4.0！spring-doc.cn

SpringApplication 应用程序

SpringApplication 类提供了一种便捷的方法来引导从方法启动的 Spring 应用程序。在许多情况下，你可以委托给静态SpringApplication.run（Class， String...）方法，如以下示例所示：main()spring-doc.cn

Javaspring-doc.cn
Kotlinspring-doc.cn

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-doc.cn

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/

 :: Spring Boot ::                (v3.3.6)

2024-11-21T11:03:45.263Z  INFO 118386 --- [           main] o.s.b.d.f.logexample.MyApplication       : Starting MyApplication using Java 17.0.13 with PID 118386 (/opt/apps/myapp.jar started by myuser in /opt/apps/)
2024-11-21T11:03:45.273Z  INFO 118386 --- [           main] o.s.b.d.f.logexample.MyApplication       : No active profile set, falling back to 1 default profile: "default"
2024-11-21T11:03:48.542Z  INFO 118386 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port 8080 (http)
2024-11-21T11:03:48.604Z  INFO 118386 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2024-11-21T11:03:48.610Z  INFO 118386 --- [           main] o.apache.catalina.core.StandardEngine    : Starting Servlet engine: [Apache Tomcat/10.1.33]
2024-11-21T11:03:48.784Z  INFO 118386 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2024-11-21T11:03:48.791Z  INFO 118386 --- [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 3413 ms
2024-11-21T11:03:50.465Z  INFO 118386 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port 8080 (http) with context path '/'
2024-11-21T11:03:50.481Z  INFO 118386 --- [           main] o.s.b.d.f.logexample.MyApplication       : Started MyApplication in 6.162 seconds (process running for 7.074)

默认情况下，将显示日志记录消息，包括一些相关的启动详细信息，例如启动应用程序的用户。如果您需要的日志级别不是，则可以设置它，如 Log Levels 中所述。应用程序版本是使用主应用程序类的包中的实现版本确定的。可以通过设置为来关闭启动信息记录。这还将关闭应用程序活动配置文件的日志记录。INFOINFOspring.main.log-startup-infofalsespring-doc.cn

要在启动期间添加其他日志记录，可以在SpringApplication的子类中覆盖。logStartupInfo(boolean)

启动失败

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

***************************
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实现，你可以添加自己的实现。

如果没有故障分析器能够处理异常，您仍然可以显示完整的条件报告，以更好地了解出了什么问题。为此，您需要为 ConditionEvaluationReportLoggingListener 启用 debug 属性或启用 DEBUG 日志记录。spring-doc.cn

例如，如果您使用运行应用程序，则可以按如下方式启用该属性：java -jardebugspring-doc.cn

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

延迟初始化

SpringApplication 允许延迟初始化应用程序。启用延迟初始化后，将根据需要创建 bean，而不是在应用程序启动期间创建 bean。因此，启用延迟初始化可以减少应用程序启动所需的时间。在 Web 应用程序中，启用延迟初始化将导致许多与 Web 相关的 bean 在收到 HTTP 请求之前不会初始化。spring-doc.cn

延迟初始化的一个缺点是，它可能会延迟发现应用程序的问题。如果延迟初始化了配置错误的 bean，则在启动期间将不再发生失败，并且只有在初始化 bean 时问题才会变得明显。还必须注意确保 JVM 具有足够的内存来容纳应用程序的所有 bean，而不仅仅是在启动期间初始化的 bean。由于这些原因，默认情况下不启用延迟初始化，建议在启用延迟初始化之前对 JVM 的堆大小进行微调。spring-doc.cn

可以使用 SpringApplicationBuilder 上的方法或 SpringApplication 上的方法以编程方式启用延迟初始化。或者，可以使用以下示例中所示的属性启用它：lazyInitializationsetLazyInitializationspring.main.lazy-initializationspring-doc.cn

Propertiesspring-doc.cn
YAMLspring-doc.cn

spring.main.lazy-initialization=true

spring:
  main:
    lazy-initialization: true

如果要对某些 bean 禁用延迟初始化，同时对应用程序的其余部分使用延迟初始化，则可以使用 Comments 将其 lazy 属性显式设置为 false。@Lazy(false)

可以通过将文件添加到 Classpath 或将属性设置为此类文件的位置来更改启动时打印的标题。如果文件的编码不是 UTF-8，则可以设置 .banner.txtspring.banner.locationspring.banner.charsetspring-doc.cn

在您的文件中，您可以使用 Environment （环境）中可用的任何键以及以下任何占位符：banner.txtspring-doc.cn

表 1.横幅变量
变量	描述
`${application.version}`spring-doc.cn	应用程序中声明的应用程序版本号。例如，打印为。`MANIFEST.MFImplementation-Version: 1.01.0`spring-doc.cn
`${application.formatted-version}`spring-doc.cn	应用程序的版本号，在中声明并格式化为显示（用括号括起来，前缀为）。例如。`MANIFEST.MFv(v1.0)`spring-doc.cn
`${spring-boot.version}`spring-doc.cn	您正在使用的 Spring Boot 版本。例如。`3.3.6`spring-doc.cn
`${spring-boot.formatted-version}`spring-doc.cn	您正在使用的 Spring Boot 版本，格式化为显示（用括号括起来，前缀为）。例如。`v(v3.3.6)`spring-doc.cn
`${Ansi.NAME}`（或、、`${AnsiColor.NAME}${AnsiBackground.NAME}${AnsiStyle.NAME}`)spring-doc.cn	其中是 ANSI 转义码的名称。有关详细信息，请参阅 `AnsiPropertySource`。`NAME`spring-doc.cn
`${application.title}`spring-doc.cn	应用程序中声明的应用程序标题。例如，打印为 .`MANIFEST.MFImplementation-Title: MyAppMyApp`spring-doc.cn

如果要以编程方式生成横幅，可以使用该方法。使用 Banner 界面并实现您自己的方法。SpringApplication.setBanner(…)printBanner()

您还可以使用该属性来确定横幅是否必须打印在 System.out （）上，发送到配置的 Logger （），或者根本不生成（）。spring.main.banner-modeconsolelogoffspring-doc.cn

打印的横幅将注册为以下名称下的单例 Bean：。springBootBannerspring-doc.cn

这些，和属性仅在您使用 Spring Boot Starters或与之一起使用时可用。如果您运行的是解压缩的 jar 并使用本机映像启动它或将应用程序作为本机映像运行，则不会解析这些值。application.titleapplication.versionapplication.formatted-versionjava -jarjava -cpjava -cp <classpath> <mainclass>spring-doc.cn

要使用这些属性，请使用 java -jar 将应用程序启动为打包的 jar，或使用 java org.springframework.boot.loader.launch.JarLauncher 将应用程序启动为解压缩的 jar。这将初始化应用程序。banner 属性。application.spring-doc.cn

自定义 SpringApplication

如果 SpringApplication 默认值不符合您的口味，您可以改为创建一个本地实例并对其进行自定义。例如，要关闭横幅，您可以编写：spring-doc.cn

Javaspring-doc.cn
Kotlinspring-doc.cn

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.propertiesspring-doc.cn

有关配置选项的完整列表，请参阅 SpringApplication API 文档。spring-doc.cn

Fluent Builder API

如果需要构建ApplicationContext层次结构（具有父/子关系的多个上下文），或者更喜欢使用 Fluent Builder API，则可以使用SpringApplicationBuilder。spring-doc.cn

SpringApplicationBuilder允许你将多个方法调用和include以及允许你创建层次结构的方法链接在一起，如以下示例所示：parentchildspring-doc.cn

Javaspring-doc.cn
Kotlinspring-doc.cn

		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。有关完整详细信息，请参见 SpringApplicationBuilder API 文档。

应用程序可用性

在平台上部署时，应用程序可以使用 Kubernetes 探针等基础设施向平台提供有关其可用性的信息。 Spring Boot 包括对常用的“liveness”和“readiness”可用性状态的开箱即用支持。如果您使用的是 Spring Boot 的“actuator”支持，则这些状态将作为运行状况端点组公开。spring-doc.cn

此外，您还可以通过将ApplicationAvailability接口注入到您自己的 bean 中来获取可用性状态。spring-doc.cn

活动状态

应用程序的 “Liveness” 状态表明其内部状态是否允许它正常工作，或者如果当前出现故障，则自行恢复。损坏的 “Liveness” 状态意味着应用程序处于无法恢复的状态，基础设施应重新启动应用程序。spring-doc.cn

通常，“Liveness” 状态不应基于外部检查，例如运行状况检查。如果是这样，则失败的外部系统（数据库、Web API、外部缓存）将在整个平台上触发大规模重启和级联故障。

Spring Boot 应用程序的内部状态主要由 Spring ApplicationContext表示。如果应用程序上下文已成功启动，则 Spring Boot 假定应用程序处于有效状态。一旦刷新了上下文，应用程序就被视为活动了，请参阅 Spring Boot 应用程序生命周期和相关应用程序事件。spring-doc.cn

就绪状态

应用程序的 “Readiness” 状态表明应用程序是否已准备好处理流量。失败的 “Readiness” 状态告诉平台它暂时不应将流量路由到应用程序。这通常发生在启动期间，当 CommandLineRunner 和 ApplicationRunner 组件正在处理时，或者如果应用程序决定它太忙而无法进行其他流量，则随时发生。spring-doc.cn

一旦调用了应用程序和命令行运行器，应用程序就被视为准备就绪，请参阅 Spring Boot 应用程序生命周期和相关应用程序事件。spring-doc.cn

预期在启动期间运行的任务应由 CommandLineRunner 和 ApplicationRunner 组件执行，而不是使用 Spring 组件生命周期回调（如 @PostConstruct）。

管理应用程序可用性状态

应用程序组件可以通过注入 ApplicationAvailability 接口并对其调用方法，随时检索当前可用性状态。更常见的是，应用程序需要侦听状态更新或更新应用程序的状态。spring-doc.cn

例如，我们可以将应用程序的 “Readiness” 状态导出到一个文件中，以便 Kubernetes “exec Probe” 可以查看此文件：spring-doc.cn

Javaspring-doc.cn
Kotlinspring-doc.cn

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 -> {
				// ...
			}
		}
	}

}

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

Javaspring-doc.cn
Kotlinspring-doc.cn

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 Boot 通过 Actuator Health Endpoints 为 “Liveness” 和 “Readiness” 提供 Kubernetes HTTP 探测。您可以在专用部分中获取有关在 Kubernetes 上部署 Spring Boot 应用程序的更多指导。spring-doc.cn

应用程序事件和侦听器

除了通常的 Spring Framework 事件（例如ContextRefreshedEvent）之外，SpringApplication还会发送一些其他应用程序事件。spring-doc.cn

有些事件实际上是在创建ApplicationContext之前触发的，因此你不能在这些事件上注册侦听器作为@Bean。您可以使用 method 或 method 注册它们。SpringApplication.addListeners(…)SpringApplicationBuilder.listeners(…)spring-doc.cn

如果您希望自动注册这些侦听器，而不管应用程序的创建方式如何，都可以将文件添加到项目中，并使用 ApplicationListener 键引用侦听器，如以下示例所示：META-INF/spring.factoriesspring-doc.cn

org.springframework.context.ApplicationListener=com.example.project.MyListener

应用程序事件在应用程序运行时按以下顺序发送：spring-doc.cn

ApplicationStartingEvent 在运行开始时发送，但在任何处理之前发送，侦听器和初始值设定项的注册除外。spring-doc.cn
当要在上下文中使用的 Environment 已知但在创建上下文之前，将发送 ApplicationEnvironmentPreparedEvent。spring-doc.cn
在准备ApplicationContext并调用ApplicationContextInitializers时，但在加载任何 bean 定义之前，将发送ApplicationContextInitializedEvent。spring-doc.cn
ApplicationPreparedEvent在刷新开始之前发送，但在 Bean 定义加载之后发送。spring-doc.cn
ApplicationStartedEvent 在刷新上下文之后，但在调用任何应用程序和命令行运行程序之前发送。spring-doc.cn
紧接着发送一个 AvailabilityChangeEvent LivenessState.CORRECT，以指示应用程序被视为实时应用程序。spring-doc.cn
在调用任何应用程序和命令行运行程序后，将发送 ApplicationReadyEvent。spring-doc.cn
紧接着发送一个 AvailabilityChangeEvent，并带有 ReadinessState.ACCEPTING_TRAFFIC，以指示应用程序已准备好为请求提供服务。spring-doc.cn
如果启动时出现异常，则发送 ApplicationFailedEvent。spring-doc.cn

上面的列表仅包括绑定到SpringApplication的 s。除此之外，以下事件还会在 ApplicationPreparedEvent 之后和 ApplicationStartedEvent 之前发布：SpringApplicationEventspring-doc.cn

WebServerInitializedEvent 在 WebServer 准备就绪后发送。ServletWebServerInitializedEvent和ReactiveWebServerInitializedEvent分别是 servlet 和反应式变体。spring-doc.cn
刷新ApplicationContext时发送ContextRefreshedEvent。spring-doc.cn

您通常不需要使用应用程序事件，但知道它们存在会很方便。在内部， Spring Boot 使用事件来处理各种任务。

事件侦听器不应运行可能很长的任务，因为它们默认在同一线程中执行。请考虑改用应用程序和命令行运行程序。

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

要使侦听器能够区分其上下文的事件和后代上下文的事件，它应请求注入其应用程序上下文，然后将注入的上下文与事件的上下文进行比较。可以通过实现ApplicationContextAware来注入上下文，或者，如果侦听器是 bean，则通过使用@Autowired。spring-doc.cn

Web 环境

SpringApplication尝试代表您创建正确类型的ApplicationContext。用于确定 WebApplicationType 的算法如下：spring-doc.cn

如果存在 Spring MVC，则使用 AnnotationConfigServletWebServerApplicationContextspring-doc.cn
如果 Spring MVC 不存在而 Spring WebFlux 存在，则使用 AnnotationConfigReactiveWebServerApplicationContextspring-doc.cn
否则，使用 AnnotationConfigApplicationContextspring-doc.cn

这意味着，如果你在同一个应用程序中使用 Spring MVC 和 Spring WebFlux 的新 WebClient，则默认情况下将使用 Spring MVC。您可以通过调用 .setWebApplicationType(WebApplicationType)spring-doc.cn

还可以通过调用 .setApplicationContextFactory(…)spring-doc.cn

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

访问应用程序参数

如果需要访问传递给的应用程序参数，则可以注入 ApplicationArguments bean。 ApplicationArguments 接口提供对原始参数以及解析和参数的访问，如以下示例所示：SpringApplication.run(…)String[]optionnon-optionspring-doc.cn

Javaspring-doc.cn
Kotlinspring-doc.cn

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 还向 Spring Environment 注册了CommandLinePropertySource。这还允许您使用 @Value 注解注入单个应用程序参数。

使用 ApplicationRunner 或 CommandLineRunner

如果需要在 SpringApplication 启动后运行某些特定代码，则可以实现 ApplicationRunner 或 CommandLineRunner 接口。这两个接口的工作方式相同，并提供单个方法，该方法在完成之前调用。runSpringApplication.run(…)spring-doc.cn

此协定非常适合应在应用程序启动之后但在开始接受流量之前运行的任务。

CommandLineRunner 接口以字符串数组的形式提供对应用程序参数的访问，而 ApplicationRunner 使用前面讨论的 ApplicationArguments 接口。以下示例显示了一个带有方法的 CommandLineRunner：runspring-doc.cn

Javaspring-doc.cn
Kotlinspring-doc.cn

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 或 ApplicationRunner bean，则还可以实现 Ordered 接口或使用 Order 注释。spring-doc.cn

应用程序退出

每个SpringApplication都向 JVM 注册一个关闭钩子，以确保ApplicationContext在退出时正常关闭。可以使用所有标准的 Spring 生命周期回调（例如DisposableBean接口或@PreDestroy注释）。spring-doc.cn

此外，如果 bean 希望在调用时返回特定的退出代码，则可以实现ExitCodeGenerator接口。然后，可以将此退出代码传递给以将其作为状态代码返回，如以下示例所示：SpringApplication.exit()System.exit()spring-doc.cn

Javaspring-doc.cn
Kotlinspring-doc.cn

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

此外，ExitCodeGenerator 接口可能由异常实现。当遇到此类异常时， Spring Boot 返回已实现的方法提供的退出代码。getExitCode()spring-doc.cn

如果有多个 ExitCodeGenerator，则使用生成的第一个非零退出代码。要控制生成器的调用顺序，请另外实现 Ordered 接口或使用 Order 注释。spring-doc.cn

管理员功能

可以通过指定属性为应用程序启用与管理员相关的功能。这将在平台MBeanServer上公开SpringApplicationAdminMXBean。您可以使用此功能远程管理 Spring Boot 应用程序。此功能对于任何服务包装器实现也很有用。spring.application.admin.enabledspring-doc.cn

如果您想知道应用程序正在哪个 HTTP 端口上运行，请获取键为 .local.server.port

应用程序启动跟踪

在应用程序启动期间，SpringApplication 和 ApplicationContext 执行许多与应用程序生命周期相关的任务。 bean 生命周期，甚至处理应用程序事件。通过ApplicationStartup， Spring Framework 允许你使用StartupStep对象跟踪应用程序启动序列。收集此数据可以用于分析目的，或者只是为了更好地了解应用程序启动过程。spring-doc.cn

在设置 SpringApplication 实例时，您可以选择 ApplicationStartup 实现。例如，要使用 BufferingApplicationStartup，您可以编写：spring-doc.cn

Javaspring-doc.cn
Kotlinspring-doc.cn

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 的情况下运行应用程序来记录数据：spring-doc.cn

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

Spring Boot 附带了BufferingApplicationStartup变体;此实现用于缓冲启动步骤并将其排空到外部 Metrics 系统中。应用程序可以在任何组件中请求 BufferingApplicationStartup 类型的 Bean。spring-doc.cn

Spring Boot 还可以配置为公开一个启动端点，该端点将此信息作为 JSON 文档提供。spring-doc.cn

虚拟线程

如果您在 Java 21 或更高版本上运行，则可以通过将属性设置为 .spring.threads.virtual.enabledtruespring-doc.cn

在为您的应用程序启用此选项之前，您应该考虑阅读官方 Java 虚拟线程文档。在某些情况下，由于“固定虚拟线程”，应用程序的吞吐量可能会降低;本页还介绍了如何使用 JDK Flight Recorder 或 CLI 检测此类情况。jcmdspring-doc.cn

如果启用了虚拟线程，则配置线程池的属性将不再有效。这是因为虚拟线程被调度在 JVM 范围的平台线程池上，而不是在专用线程池上。

虚拟线程的一个副作用是它们是守护程序线程。如果 JVM 的所有线程都是守护程序线程，则 JVM 将退出。例如，当您依赖 @Scheduled bean 来保持应用程序活动状态时，此行为可能是一个问题。如果使用虚拟线程，则调度程序线程是虚拟线程，因此是守护程序线程，不会使 JVM 保持活动状态。这不仅会影响调度，其他技术也可能如此。要使 JVM 在所有情况下都运行，建议将属性设置为。这可确保 JVM 保持活动状态，即使所有线程都是虚拟线程也是如此。spring.main.keep-alivetrue

SpringApplication 应用程序

启动失败

延迟初始化

自定义横幅

自定义 SpringApplication

Fluent Builder API

应用程序可用性

活动状态

就绪状态

管理应用程序可用性状态

应用程序事件和侦听器

Web 环境

访问应用程序参数

使用 ApplicationRunner 或 CommandLineRunner

应用程序退出

管理员功能

应用程序启动跟踪

虚拟线程