SpringApplication
这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 :: (v4.0.0)
2025-11-20T16:37:28.294Z INFO 128420 --- [ main] o.s.b.d.f.logexample.MyApplication : Starting MyApplication using Java 25.0.1 with PID 128420 (/opt/apps/myapp.jar started by myuser in /opt/apps/)
2025-11-20T16:37:28.322Z INFO 128420 --- [ main] o.s.b.d.f.logexample.MyApplication : No active profile set, falling back to 1 default profile: "default"
2025-11-20T16:37:31.896Z INFO 128420 --- [ main] o.s.boot.tomcat.TomcatWebServer : Tomcat initialized with port 8080 (http)
2025-11-20T16:37:31.952Z INFO 128420 --- [ main] o.apache.catalina.core.StandardService : Starting service [Tomcat]
2025-11-20T16:37:31.953Z INFO 128420 --- [ main] o.apache.catalina.core.StandardEngine : Starting Servlet engine: [Apache Tomcat/11.0.14]
2025-11-20T16:37:32.122Z INFO 128420 --- [ main] b.w.c.s.WebApplicationContextInitializer : Root WebApplicationContext: initialization completed in 3543 ms
2025-11-20T16:37:33.770Z INFO 128420 --- [ main] o.s.boot.tomcat.TomcatWebServer : Tomcat started on port 8080 (http) with context path '/'
2025-11-20T16:37:33.799Z INFO 128420 --- [ main] o.s.b.d.f.logexample.MyApplication : Started MyApplication in 7.034 seconds (process running for 8.198)
2025-11-20T16:37:33.856Z INFO 128420 --- [ionShutdownHook] o.s.boot.tomcat.GracefulShutdown : Commencing graceful shutdown. Waiting for active requests to complete
2025-11-20T16:37:33.915Z INFO 128420 --- [tomcat-shutdown] o.s.boot.tomcat.GracefulShutdown : Graceful shutdown complete默认情况下，信息日志消息显示，包括一些相关的启动信息，比如启动应用的用户。
如果你需要除信息你可以按照日志等级描述来设置它。
应用版本是通过主应用类包中的实现版本确定的。
启动信息记录可以通过设置关闭spring.main.log-startup-info自false.
这也会关闭对应用活跃配置文件的记录。
如果要在启动时添加额外的日志，可以覆盖logStartupInfo（boolean）在SpringApplication. |
创业失败
如果你的申请未能启动，请注册故障分析器BEANS有机会提供专门的错误信息和具体的解决方案来解决问题。
例如，如果你在端口上启动一个网页应用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.如果没有故障分析器能处理异常，你仍然可以显示完整的状况报告，更好地理解问题所在。
要做到这一点，你需要启用调试属性或使调试Logging为ConditionEvaluationReportLoggingListener.
例如，如果你运行应用程序时，使用Java -jar，你可以启用调试性质如下：
$ java -jar myproject-0.0.1-SNAPSHOT.jar --debug懒初始化
SpringApplication允许懒惰地初始化应用程序。
启用懒惰初始化时，豆子会按需创建，而非在应用启动时。
因此，启用懒惰初始化可以缩短应用启动时间。
在网页应用中，启用懒惰初始化会导致许多与网络相关的豆子直到收到HTTP请求才被初始化。
懒惰初始化的一个缺点是可能会延迟发现应用程序的问题。 如果错误配置的豆子被懒惰地初始化，启动时就不再发生故障，问题只有在豆子初始化时才会显现出来。 还必须确保JVM拥有足够的内存，以容纳应用程序中所有的豆子，而不仅仅是启动时初始化的豆子。 因此，默认情况下不启用懒惰初始化，建议在启用懒惰初始化前对JVM堆大小进行微调。
懒惰初始化可以通过编程方式启用懒惰初始化方法SpringApplicationBuilder或者setLazyInitialization方法SpringApplication.
或者，也可以通过spring.main.lazy-initialization如下例所示的性质：
-
Properties
-
YAML
spring.main.lazy-initialization=truespring:
main:
lazy-initialization: true如果你想禁用某些豆子的懒初始化，而对其他应用使用懒惰初始化，你可以用@Lazy（假）注解。 |
定制旗帜
启动时打印的横幅可以通过添加banner.txt文件存储到你的类路径，或者通过设置春季.横幅.位置属性到该文件的位置。
如果文件的编码不是 UTF-8，你可以设置春季.横ner.字符集.
在你的内部banner.txt文件中，你可以使用任何可用的密钥。环境以及以下任何占位符：
| 变量 | 描述 |
|---|---|
|
你的应用程序版本号，按声明的版本号 |
|
你的应用程序版本号，按声明的版本号 |
|
你用的就是Spring Boot版本。
例如 |
|
你用的Spring Boot版本，格式化以便显示（用括号围住，前缀为 |
|
哪里 |
|
您的申请标题，如申报 |
这SpringApplication.setBanner（...）如果你想用程序生成横幅，可以使用这种方法。
使用该旗帜并实现你自己的接口printBanner（）方法。 |
你也可以使用spring.main.banner-mode属性以确定是否必须印制横幅System.out (安慰），发送到配置好的记录器（日志），甚至根本不产生（不对劲).
印刷横幅以以下名称注册为单一豆子：春启旗帜.
|
这 使用 |
定制 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是春豆的配置源。
在大多数情况下，这些都是指@Configuration但它们也可以是直接的引用@Component类。 |
也可以配置SpringApplication通过使用application.properties文件。
详情请参见外部化配置。
完整的配置选项列表，请参见SpringApplicationAPI 文档。
Fluent Builder API
如果你需要建造一个应用上下文层级结构（多个上下文中具有父子关系）或者如果你更喜欢使用流流构建器API，可以使用SpringApplicationBuilder.
这SpringApplicationBuilder它让你可以串联多个方法调用和包含父母和孩子这些方法可以让你创建层级结构，如下示例所示：
-
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)创建应用上下文等级制度。
例如，Web组件必须包含在子上下文中，且同样环境用于父和子上下文。
参见SpringApplicationBuilder完整细节有API文档。 |
应用可用性
当应用部署在平台上时，可以通过 Kubernetes 探针等基础设施提供其对平台的可用性信息。 Spring Boot 开箱即用地支持常用的“活着”和“准备”可用状态。 如果你使用 Spring Boot 的“执行器”支持，那么这些状态会作为健康端点组暴露。
此外，你还可以通过注入应用可用性连接到你自己的豆子。
活态
应用程序的“存活”状态判断其内部状态是否允许其正常工作，或在当前失败时自行恢复。“存活状态”失效意味着应用处于无法恢复的状态，基础设施应重启应用。
| 一般来说，“活跃”状态不应基于外部检查，比如健康检查。如果是这样，失败的外部系统（数据库、Web API、外部缓存）将引发大规模重启和平台连锁故障。 |
Spring Boot 应用程序的内部状态主要由 Spring 表示应用上下文. 如果应用上下文成功启动，Spring Boot 假设应用处于有效状态。一旦上下文刷新，应用程序即被视为活跃，详见 Spring Boot 应用生命周期及相关应用事件。
准备状态
应用程序的“准备状态”表明应用是否准备好处理流量。失败的“准备状态”告诉平台暂时不应将流量路由到应用。这通常发生在启动时，而命令线跑者和应用运行者组件正在处理中，或者如果应用程序认为过于繁忙，可以随时处理。
应用程序一旦调用并调用命令行运行程序，即被视为准备就绪，详见 Spring Boot 应用生命周期及相关应用事件。
启动时预计运行的任务应由以下方式执行命令线跑者和应用运行者组件代替使用 Spring 组件生命周期回调，如@PostConstruct. |
管理应用可用性状态
应用组件可以随时通过注入应用可用性接口和调用方法。更常见的是，应用程序需要监听状态更新或更新应用程序的状态。
例如，我们可以将应用的“准备状态”导出为文件，使 Kubernetes 的“执行探测器”能够查看该文件：
-
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
}
}
}
}当应用程序崩溃无法恢复时，我们也可以更新其状态：
-
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 Boot 提供了用于执行器健康端点的 Kubernetes HTTP 探针，用于“活着”和“准备”。你可以在专门的部分获得关于如何在 Kubernetes 上部署 Spring Boot 应用的更多信息。
应用事件与听众
除了通常的春季框架活动外，例如ContextRefreshedEvent一个SpringApplication发送一些额外的申请事件。
|
有些事件实际上是在 如果你希望这些监听器自动注册，无论应用如何创建，你可以添加一个 |
应用事件按以下顺序发送，具体取决于您的应用运行：
-
一
ApplicationStartingEvent在运行开始时发送，但在任何处理之前发送，除了监听器和初始化器的注册。 -
一
ApplicationEnvironmentPreparedEvent当环境在上下文中被使用是已知的，但在上下文创建之前。 -
一
ApplicationContextInitializedEvent当应用上下文是准备好的，并且在加载任何 bean 定义之前，已经调用了 ApplicationContextInitializers。 -
一
ApplicationPreparedEvent在刷新开始前发送，但在 BEAN 定义加载后。 -
一
ApplicationStartedEvent在上下文刷新后发送，但在任何应用程序和命令行运行程序被调用之前。 -
一
ApplicationReadyEvent在任何应用程序和命令行运行程序被调用后才发送。 -
一
可用性变更事件紧接着发送ReadinessState.ACCEPTING_TRAFFIC以表示应用程序已准备好处理请求。 -
一
ApplicationFailedEvent如果启动时有异常，则发送。
上述列表仅包括SpringApplicationEvent与SpringApplication.
此外，以下事件也会在后续发布ApplicationPreparedEvent以及之前ApplicationStartedEvent:
-
一个
WebServer初始化事件在WebServer准备好了。ServletWebServerInitializedEvent和ReactiveWebServer初始化事件分别是servlet和响应式变体。 -
一个
ContextRefreshedEvent当应用上下文焕然一新。
| 你通常不需要使用应用事件，但知道它们存在会很方便。 在内部，Spring Boot 利用事件处理各种任务。 |
| 事件监听器不应执行可能较长的任务，因为它们默认在同一线程中执行。 考虑使用应用程序和命令行运行工具。 |
应用事件通过 Spring Framework 的事件发布机制发送。
该机制的一部分确保在子语境中发布给听者的事件，也会在任何祖先语境中发布给听者。
因此，如果你的应用程序使用以下层级结构SpringApplication监听者可能会接收多个同类型应用事件的实例。
为了让监听者区分其上下文中的事件和后代上下文的事件，应请求注入其应用上下文，然后将注入的上下文与事件上下文进行比较。
上下文可以通过实现应用上下文感知或者，如果听者是豆子，则使用@Autowired.
网页环境
一个SpringApplication尝试创造合适的类型应用上下文代表你。
用于确定WebApplicationType如下：
-
如果春季MVC存在，则
AnnotationConfigServletWebServerApplicationContext被使用 -
如果春季MVC不存在且春季WebFlux存在，则
AnnotationConfigReactiveWebServerApplicationContext被使用
这意味着如果你使用春季MVC和新的Web客户端在同一应用程序中，Spring WebFlux 默认使用 MVC。
你可以通过打电话轻松覆盖这个设置setWebApplicationType（WebApplicationType）.
也可以完全控制应用上下文通过调用所使用的类型setApplicationContextFactory（...）.
通常建议打电话setWebApplicationType（WebApplicationType.NONE）使用SpringApplication在JUnit测试中。 |
访问应用参数
-
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"]
}
}使用 ApplicationRunner 或 CommandLineRunner
如果你需要运行某个特定的代码一次，SpringApplication已经开始了，你可以实现应用运行者或命令线跑者接口。
这两个接口的工作原理相同，且仅提供一个统一的接口执行方法，在SpringApplication.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...
}
}应用退出
每SpringApplication向JVM注册一个关机钩子，以确保应用上下文在出口时优雅地关闭。
所有标准的春季生命周期回调（例如一次性豆接口或@PreDestroy注释）可以使用。
此外，豆子还可能实现出口代码生成器如果他们想返回特定的退出代码，就用接口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)))
}另外，还有出口代码生成器接口可以通过例外实现。
当遇到此类异常时，Spring Boot 返回已实现的退出代码getExitCode（）方法。
管理功能
可以通过指定spring.application.admin.enabled财产。
这揭示了SpringApplicationAdminMXBean站台上MBeanServer.
你可以利用这个功能远程管理你的 Spring Boot 应用。
该功能对任何服务包装实现也很有用。
如果你想知道应用程序运行在哪个 HTTP 端口上，获取带有local.server.port. |
应用启动跟踪
在应用启动过程中，SpringApplication以及应用上下文执行许多与应用生命周期相关的任务，
比如BEANS生命周期，甚至是处理应用事件。
跟ApplicationStartupSpring Framework 允许您通过 来跟踪应用程序启动序列 创业步对象。
这些数据可以用于分析，或仅仅是为了更好地理解应用启动流程。
你可以选择一个ApplicationStartup在设置SpringApplication实例。
例如，使用缓冲应用启动，你可以写成：
-
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)
}
}最早可用的实现，飞行记录应用启动由 Spring Framework 提供。
它将 Spring 特定的启动事件添加到 Java 飞行记录仪会话中，旨在对应用程序进行分析，并将其 Spring 上下文生命周期与 JVM 事件（如分配、GC、类加载等）关联起来。
配置完成后，您可以通过启用飞行记录仪运行应用程序来记录数据：
$ java -XX:StartFlightRecording:filename=recording.jfr,duration=10s -jar demo.jarSpring Boot 也可以配置为暴露启动端点该文件以 JSON 文档的形式提供这些信息。
虚拟线程
虚拟线程需要Java 21或更高版本。
为了获得最佳体验，强烈推荐使用 Java 24 或更高版本。
要启用虚拟线程，设置spring.threads.virtual.enabled属性到true.
在为您的应用开启此选项之前，您应考虑阅读官方的 Java 虚拟线程文档。
在某些情况下，应用程序可能会因“钉置虚拟线程”而经历吞吐量下降;本页还解释了如何使用JDK飞行记录仪或JCMDCLI。
| 如果启用了虚拟线程，配置线程池的属性就不再有影响了。 这是因为虚拟线程是在 JVM 平台的线程池中调度的，而不是在专用线程池上。 |
虚拟线程的一个副作用是它们属于守护进程线程。
如果JVM的所有线程都是守护进程线程，JVM就会退出。
当你依赖@Scheduled比如豆子，用来保持申请的存活期。
如果你用虚拟线程，调度线程是虚拟线程，因此是守护进程线程，无法维持JVM存活。
这不仅影响排班，其他技术也可能如此。
为了在所有情况下保持JVM运行，建议设置该属性spring.main.keep-alive（Spring）。保持生命自true.
这确保了JVM的存活状态，即使所有线程都是虚拟线程。 |