|
对于最新的稳定版本，请使用 Spring Boot 3.5.5！ |
Spring应用
这SpringApplicationclass 提供了一种方便的方法来引导从main()方法。
在许多情况下，您可以委托给静态SpringApplication.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.4.9)
2025-08-21T06:48:57.964Z INFO 133589 --- [ main] o.s.b.d.f.logexample.MyApplication : Starting MyApplication using Java 17.0.16 with PID 133589 (/opt/apps/myapp.jar started by myuser in /opt/apps/)
2025-08-21T06:48:57.975Z INFO 133589 --- [ main] o.s.b.d.f.logexample.MyApplication : No active profile set, falling back to 1 default profile: "default"
2025-08-21T06:49:01.725Z INFO 133589 --- [ main] o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat initialized with port 8080 (http)
2025-08-21T06:49:01.850Z INFO 133589 --- [ main] o.apache.catalina.core.StandardService : Starting service [Tomcat]
2025-08-21T06:49:01.859Z INFO 133589 --- [ main] o.apache.catalina.core.StandardEngine : Starting Servlet engine: [Apache Tomcat/10.1.44]
2025-08-21T06:49:02.144Z INFO 133589 --- [ main] o.a.c.c.C.[Tomcat].[localhost].[/] : Initializing Spring embedded WebApplicationContext
2025-08-21T06:49:02.145Z INFO 133589 --- [ main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 3950 ms
2025-08-21T06:49:04.492Z INFO 133589 --- [ main] o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat started on port 8080 (http) with context path '/'
2025-08-21T06:49:04.542Z INFO 133589 --- [ main] o.s.b.d.f.logexample.MyApplication : Started MyApplication in 8.944 seconds (process running for 10.117)
2025-08-21T06:49:04.580Z INFO 133589 --- [ionShutdownHook] o.s.b.w.e.tomcat.GracefulShutdown : Commencing graceful shutdown. Waiting for active requests to complete
2025-08-21T06:49:04.602Z INFO 133589 --- [tomcat-shutdown] o.s.b.w.e.tomcat.GracefulShutdown : Graceful shutdown complete默认情况下，INFO将显示日志记录消息，包括一些相关的启动详细信息，例如启动应用程序的用户。
如果您需要的日志级别INFO，您可以设置它，如日志级别中所述。
应用程序版本是使用主应用程序类包中的实现版本确定的。
可以通过设置spring.main.log-startup-info自false.
这也将关闭应用程序活动配置文件的日志记录。
若要在启动期间添加其他日志记录，可以覆盖logStartupInfo(boolean)在SpringApplication. |
启动失败
如果您的应用程序无法启动，请注册FailureAnalyzerbean 有机会提供专用的错误消息和解决问题的具体作。
例如，如果您在端口上启动一个 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 提供了许多FailureAnalyzer实现，您可以添加自己的实现。 |
如果没有故障分析器能够处理异常，您仍然可以显示完整的条件报告，以更好地了解出了什么问题。
为此，您需要启用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 的堆大小进行微调。
可以使用lazyInitialization方法SpringApplicationBuilder或setLazyInitialization方法SpringApplication.
或者，可以使用spring.main.lazy-initialization属性，如以下示例所示：
-
Properties
-
YAML
spring.main.lazy-initialization=truespring:
main:
lazy-initialization: true如果要在对应用程序的其余部分使用延迟初始化时禁用某些 bean 的延迟初始化，则可以使用@Lazy(false)注解。 |
自定义横幅
启动时打印的横幅可以通过添加banner.txt文件添加到您的类路径或通过将spring.banner.location属性添加到此类文件的位置。
如果文件的编码不是 UTF-8，您可以将spring.banner.charset.
在您的内部banner.txt文件，您可以使用Environment以及以下任何占位符：
| 变量 | 描述 |
|---|---|
|
应用程序的版本号，如 |
|
应用程序的版本号，如 |
|
您正在使用的 Spring Boot 版本。
例如 |
|
您正在使用的 Spring Boot 版本，格式化为显示（用括号括起来，前缀为 |
|
哪里 |
|
您的应用程序的标题，如 |
这SpringApplication.setBanner(…)方法，如果要以编程方式生成横幅，则可以使用。
使用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 构建器 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 包括对常用的“活动”和“就绪”可用性状态的开箱即用支持。 如果您使用的是 Spring Boot 的“执行器”支持，则这些状态将作为运行状况端点组公开。
此外，您还可以通过注入ApplicationAvailability接口到你自己的 bean 中。
活跃状态
应用程序的“活跃”状态告诉它是否允许其内部状态正常工作，或者如果当前出现故障，是否允许它自行恢复。 损坏的“活动”状态意味着应用程序处于无法恢复的状态，基础结构应重新启动应用程序。
| 通常，“活跃度”状态不应基于外部检查，例如运行状况检查。 如果发生这种情况，出现故障的外部系统（数据库、Web API、外部缓存）将触发大规模重启和跨平台的级联故障。 |
Spring Boot 应用程序的内部状态主要由 SpringApplicationContext.
如果应用程序上下文已成功启动，Spring Boot 会假定应用程序处于有效状态。
一旦上下文刷新，应用程序就会被视为活动，请参阅 Spring Boot 应用程序生命周期和相关应用程序事件。
就绪状态
应用程序的“就绪”状态表明应用程序是否已准备好处理流量。
失败的“就绪”状态告诉平台，它目前不应将流量路由到应用程序。
这通常发生在启动期间，而CommandLineRunner和ApplicationRunner正在处理组件，或者如果应用程序认为它太忙而无法进行其他流量，则随时处理组件。
调用应用程序和命令行运行器后，应用程序就被视为就绪，请参阅 Spring Boot 应用程序生命周期和相关应用程序事件。
预期在启动期间运行的任务应由CommandLineRunner和ApplicationRunner组件，而不是使用 Spring 组件生命周期回调，例如@PostConstruct. |
管理应用程序可用性状态
应用程序组件可以随时检索当前可用性状态，方法是将ApplicationAvailability接口和调用方法。
更常见的是，应用程序将希望侦听状态更新或更新应用程序的状态。
例如，我们可以将应用程序的“就绪”状态导出到一个文件中，以便 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在Environment在上下文中使用是已知的，但在创建上下文之前。 -
一
ApplicationContextInitializedEvent在ApplicationContext已准备好，并且已调用 ApplicationContextInitializers，但在加载任何 bean 定义之前。 -
一
ApplicationPreparedEvent在刷新开始之前但在加载 Bean 定义之后发送。 -
一
ApplicationStartedEvent在刷新上下文之后，但在调用任何应用程序和命令行运行器之前发送。 -
一
AvailabilityChangeEvent紧随其后发送LivenessState.CORRECT以指示应用程序被视为活动。 -
一
ApplicationReadyEvent在调用任何应用程序和命令行运行器后发送。 -
一
AvailabilityChangeEvent紧随其后发送ReadinessState.ACCEPTING_TRAFFIC以指示应用程序已准备好处理请求。 -
一
ApplicationFailedEvent如果启动时出现异常，则发送。
以上列表仅包括SpringApplicationEvents 绑定到SpringApplication.
除了这些之外，以下事件还发布在之后ApplicationPreparedEvent和之前ApplicationStartedEvent:
-
一个
WebServerInitializedEvent在WebServer准备好了。ServletWebServerInitializedEvent和ReactiveWebServerInitializedEvent分别是 servlet 和 reactive 变体。
| 您通常不需要使用应用程序事件，但知道它们存在会很方便。 在内部，Spring Boot 使用事件来处理各种任务。 |
| 事件侦听器不应运行可能冗长的任务，因为它们默认在同一线程中执行。 请考虑改用应用程序和命令行运行器。 |
应用程序事件是使用 Spring Framework 的事件发布机制发送的。
此机制的一部分可确保在子上下文中发布到侦听器的事件也发布到任何祖先上下文中的侦听器。
因此，如果您的应用程序使用SpringApplication实例，侦听器可能会接收相同类型应用程序事件的多个实例。
为了允许您的侦听器区分其上下文的事件和后代上下文的事件，它应该请求注入其应用程序上下文，然后将注入的上下文与事件的上下文进行比较。
可以通过实现ApplicationContextAware或者，如果侦听器是 bean，则使用@Autowired.
网络环境
一个SpringApplication尝试创建正确类型的ApplicationContext代表您。
用于确定WebApplicationType如下：
-
如果存在 Spring MVC，则
AnnotationConfigServletWebServerApplicationContext被使用 -
如果 Spring MVC 不存在，而 Spring WebFlux 存在，则
AnnotationConfigReactiveWebServerApplicationContext被使用
这意味着，如果您使用的是 Spring MVC 和新的WebClient来自同一应用程序中的 Spring WebFlux，默认情况下将使用 Spring MVC。
您可以通过调用setWebApplicationType(WebApplicationType).
也可以完全控制ApplicationContext调用setApplicationContextFactory(…).
通常希望调用setWebApplicationType(WebApplicationType.NONE)使用时SpringApplication在 JUnit 测试中。 |
访问应用程序参数
如果您需要访问传递给SpringApplication.run(…)，您可以注入一个ApplicationArguments豆。
这ApplicationArguments接口提供对原始String[]参数以及解析的option和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与Spring一起Environment. 这还允许您使用@Value注解。 |
使用 ApplicationRunner 或 CommandLineRunner
如果您需要运行一些特定的代码，那么一旦SpringApplication已启动，您可以实现ApplicationRunner或CommandLineRunner接口。 两个接口的工作方式相同，并提供一个run方法，该方法在SpringApplication.run(…)完成。
| 此协定非常适合在应用程序启动后但在开始接受流量之前运行的任务。 |
这CommandLineRunner接口以字符串数组的形式提供对应用程序参数的访问，而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 定义了必须按特定顺序调用的 bean，您可以额外实现Ordered接口或使用Order注解。
应用程序退出
每SpringApplication向 JVM 注册一个 shutdown 钩子，以确保ApplicationContext在退出时优雅地关闭。
所有标准的 Spring 生命周期回调（例如DisposableBean接口或@PreDestroy注释）可以使用。
此外，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)))
}此外，ExitCodeGenerator接口可以通过异常实现。
当遇到此类异常时，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、类加载等）相关联。
配置完成后，您可以通过在启用飞行记录器的情况下运行应用程序来记录数据：
$ java -XX:StartFlightRecording:filename=recording.jfr,duration=10s -jar demo.jarSpring Boot 附带了BufferingApplicationStartup变体;此实现旨在缓冲启动步骤并将它们清空到外部指标系统中。
应用程序可以请求类型为BufferingApplicationStartup在任何组件中。
Spring Boot 也可以配置为公开startup端点以 JSON 文档的形式提供此信息。
虚拟线程
虚拟线程需要 Java 21 或更高版本。
为了获得最佳体验，强烈建议使用 Java 24 或更高版本。
要启用虚拟线程，请将spring.threads.virtual.enabled属性设置为true.
在为您的应用程序打开此选项之前，您应该考虑阅读官方的 Java 虚拟线程文档。
在某些情况下，应用程序可能会因为“固定虚拟线程”而遇到较低的吞吐量;本页还介绍了如何使用 JDK Flight Recorder 或jcmdCLI 中。
| 如果启用了虚拟线程，则配置线程池的属性将不再有效。 这是因为虚拟线程是在 JVM 范围的平台线程池上调度的，而不是在专用线程池上调度的。 |
虚拟线程的一个副作用是它们是守护线程。如果 JVM 的所有线程都是守护线程，则 JVM 将退出。当您依赖@Scheduledbean，以保持应用程序的活动状态。
如果使用虚拟线程，则调度程序线程是虚拟线程，因此是守护进程线程，不会使 JVM 保持活动状态。
这不仅会影响调度，其他技术也会出现这种情况。
为了使 JVM 在所有情况下都保持运行，建议将属性spring.main.keep-alive自true. 这确保了 JVM 保持活动状态，即使所有线程都是虚拟线程。 |