Spring Boot 应用（官网文档解读）

Spring Boot 启动方式

SpringApplication.run(MyApplication.class, args);

Spring Boot 故障分析器

        在Spring Boot 项目启动发生错误的时候，我们通常可以看到上面的内容，即 APPLICATION FAILED TO START，以及后面的错误描述。这个功能是通过众多的FailureAnalyzer 故障分析器beans 实现来处理的。我们可以在Spring Boot 中的spring.factories 配置文件中看到 Failure Analyzers bean 的具体实现类。

​

​

Spring Boot 自定义故障分析器

• 创建一个自定义错误

package person.wend.springbootlearnexample2.failureanalyzer;import org.springframework.boot.diagnostics.AbstractFailureAnalyzer;
import org.springframework.boot.diagnostics.FailureAnalysis;public class CustomFailureAnalyzer extends AbstractFailureAnalyzer<CustomStartupException> {@Overrideprotected FailureAnalysis analyze(Throwable rootFailure, CustomStartupException cause) {// 错误描述String description = "自定义启动错误：" + cause.getMessage();// 操作建议String action = "请检查相关配置或联系系统管理员。";return new FailureAnalysis(description, action, cause);}
}

• 创建一个自定义故障分析器类

package person.wend.springbootlearnexample2.failureanalyzer;import org.springframework.boot.diagnostics.AbstractFailureAnalyzer;
import org.springframework.boot.diagnostics.FailureAnalysis;public class CustomFailureAnalyzer extends AbstractFailureAnalyzer<CustomStartupException> {@Overrideprotected FailureAnalysis analyze(Throwable rootFailure, CustomStartupException cause) {// 错误描述String description = "自定义启动错误：" + cause.getMessage();// 操作建议String action = "请检查相关配置或联系系统管理员。";return new FailureAnalysis(description, action, cause);}
}

• 在META-INF\spring.factories 配置文件中注册该bean

org.springframework.boot.diagnostics.FailureAnalyzer=\
person.wend.springbootlearnexample2.failureanalyzer.CustomFailureAnalyzer

• 启动报错示例
• 

延迟初始化

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

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

实现延迟初始化的方式

• 配置文件

spring: main: lazy-initialization: true

• 启动项目时配置

 public static void main(String[] args) {SpringApplication springApplication = new SpringApplication(SpringBootLearnExample2Application.class);springApplication.setLazyInitialization(true);}

• 使用注解@Lazy(true)

自定义横幅

        在Spring Boot 中，我们可以使用banner.txt定义自定义横幅，一般将banner.txt 放在resource文件夹即可。以下是关于自定义横幅的属性列表：

• spring.banner.location：定义banner.txt 的文件位置

• spring.banner.charset：定义banner.txt 的编码类型

• banner.txt可以使用Environment 配置中的任何属性，以及支持一些默认的属性

• 变量	描述
  ${application.version}	应用程序版本号
  ${application.formatted-version}	应用程序格式化的版本号
  ${spring-boot.version}	您正在使用的 Spring Boot 版本。例如3.4.2。
  ${spring-boot.formatted-version}	您正在使用的 Spring Boot 格式化的版本号
  ${Ansi.NAME}（或者${AnsiColor.NAME}，${AnsiBackground.NAME}，${AnsiStyle.NAME}）	AnsiPropertySource 类是 Spring Boot 框架里用于处理 ANSI（美国国家标准化组织）转义序列相关属性源的类，主要在处理控制台输出样式方面发挥作用。
  ${application.title}	应用程序标题

编程方式实现横幅

• 启动类增加Banner配置

springApplication.setBanner(…​)

•  自定义Banner 类

package person.wend.springbootlearnexample.config;import org.springframework.boot.Banner;
import org.springframework.core.env.Environment;import java.io.PrintStream;public class CustomBanner implements Banner {@Overridepublic void printBanner(Environment environment, Class<?> sourceClass, PrintStream out) {StringBuilder banner = new StringBuilder();banner.append("==================================================\n");banner.append("*                                                *\n");banner.append("*           Welcome to My Custom App             *\n");banner.append("*                                                *\n");banner.append("==================================================\n");out.println(banner.toString());}
}

• 实现效果

关闭横幅

springApplication.setBannerMode(Banner.Mode.OFF);

 SpringApplicationBuilder

        我们可以使用 SpringApplicationBuilder 来构建SpringBoot 的启动类。

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

• sources(Parent.class)：指定父上下文的主配置类为 Parent.class，Spring Boot 会根据这个类来创建和初始化父应用上下文。

• child(Application.class)：创建一个子应用上下文，并将 Application.class 作为子上下文的主配置类。子上下文会继承父上下文的 Bean 定义，并且可以有自己独立的配置。

• bannerMode(Banner.Mode.OFF)：设置启动时不显示 Spring Boot 的 Banner。

• run(args)：启动应用，同时启动父上下文和子上下文。

Spring Boot 可用性状态概述

        Spring Boot 支持 “存活”（Liveness）和 “就绪”（Readiness）两种可用性状态。当应用部署在如 Kubernetes 这样的平台上时，可通过这些状态向平台提供自身的可用性信息。若使用 Spring Boot 的 “actuator” 支持，这些状态会作为健康端点组暴露出来，也可通过注入 ApplicationAvailability 接口到自定义 Bean 中获取可用性状态。

存活状态（Liveness State）

• 含义：表明应用的内部状态是否允许其正常工作，或者在当前出现故障时能否自行恢复。若存活状态不佳，意味着应用处于无法恢复的状态，平台基础设施应重启该应用。

• 判断依据：通常不应基于外部检查（如健康检查）来确定存活状态，因为外部系统（如数据库、Web API、外部缓存）故障可能会导致平台大规模重启和级联故障。Spring Boot 应用的内部状态主要由 Spring ApplicationContext 表示，一旦应用上下文成功刷新，就认为应用处于有效状态，即存活。

就绪状态（Readiness State）

• 含义：表示应用是否准备好处理流量。若就绪状态不佳，告知平台目前不应将流量路由到该应用。这通常发生在应用启动期间（如 CommandLineRunner 和 ApplicationRunner 组件正在处理时），或者应用认为自身过于繁忙无法处理额外流量时。

• 判断依据：一旦调用了应用和命令行运行器，就认为应用已就绪。启动期间预期运行的任务应通过 CommandLineRunner 和 ApplicationRunner 组件执行，而不是使用 @PostConstruct 等 Spring 组件生命周期回调。

使用示例

• 添加 spring-boot-actuator依赖

<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

• 创建一个 Bean 来注入 ApplicationAvailability 接口，并检查存活和就绪状态：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.availability.ApplicationAvailability;
import org.springframework.boot.availability.LivenessState;
import org.springframework.boot.availability.ReadinessState;
import org.springframework.stereotype.Component;@Component
public class AvailabilityChecker {private final ApplicationAvailability applicationAvailability;@Autowiredpublic AvailabilityChecker(ApplicationAvailability applicationAvailability) {this.applicationAvailability = applicationAvailability;}public void checkAvailability() {LivenessState livenessState = applicationAvailability.getLivenessState();ReadinessState readinessState = applicationAvailability.getReadinessState();System.out.println("Liveness State: " + livenessState);System.out.println("Readiness State: " + readinessState);}
}

• 在主类中调用检查方法

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication
public class MyApplication implements CommandLineRunner {@Autowiredprivate AvailabilityChecker availabilityChecker;public static void main(String[] args) {SpringApplication.run(MyApplication.class, args);}@Overridepublic void run(String... args) throws Exception {availabilityChecker.checkAvailability();}
}

管理应用程序可用性状态

• 应用程序组件可以随时通过注入接口ApplicationAvailability并调用其方法来检索当前可用性状态。更常见的是，应用程序希望监听状态更新或更新应用程序的状态。

• Spring Boot通过 Actuator Health Endpoints 为 Kubernetes 提供了“活跃度”和“就绪度”的 HTTP 探测。

• 例如，我们可以将应用程序的“就绪”状态导出到文件，以便 Kubernetes“exec Probe”可以查看此文件：

@Component
public class MyReadinessStateExporter {@EventListenerpublic void onStateChange(AvailabilityChangeEvent<ReadinessState> event) {switch (event.getState()) {case ACCEPTING_TRAFFIC -> {// create file /tmp/healthy}case REFUSING_TRAFFIC -> {// remove file /tmp/healthy}}}}

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

@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项目中，我们一般可以使用ContextRefreshedEvent来监听一个事件。ContextRefreshedEvent 是 Spring 框架中的一个事件，当 ApplicationContext 被初始化或者刷新时会发布该事件。

• 我们可以使用SpringApplication.addListeners(…​)或SpringApplicationBuilder.listeners(…​)注册一个监听器。

• 我们也可以通过在 META-INF/spring.factories添加监听器的方式注册一个监听器的Bean。

示例代码

package person.wend.springbootlearnexample2.event;import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;@Component
public class ContextRefreshedEventListener implements ApplicationListener<ContextRefreshedEvent> {@Overridepublic void onApplicationEvent(ContextRefreshedEvent event) {// 获取事件源，即 ApplicationContextvar applicationContext = event.getApplicationContext();// 可以在这里执行一些初始化操作，比如获取 Bean 等System.out.println("ContextRefreshedEvent 事件被触发，ApplicationContext 已刷新。");System.out.println("当前 ApplicationContext 中的 Bean 数量: " + applicationContext.getBeanDefinitionCount());}
}

Spring Boot 事件触发顺序

        Spring Boot 应用在运行过程中，各类事件按照以下顺序依次执行：

1. ApplicationStartingEvent：应用启动时触发，此时仅完成监听器和初始化器的注册，其他处理工作尚未开展。

2. ApplicationEnvironmentPreparedEvent：当明确了应用上下文要使用的环境配置，但上下文还未创建时触发该事件。

3. ApplicationContextInitializedEvent：应用上下文准备完毕，且上下文初始化器完成调用，但 Bean 定义尚未加载时触发此事件。

4. ApplicationPreparedEvent：Bean 定义加载完成后，上下文刷新操作启动之前触发该事件。

5. ApplicationStartedEvent：上下文刷新完成，但应用程序和命令行运行器还未调用时触发此事件。

6. AvailabilityChangeEvent（LivenessState.CORRECT）：在 ApplicationStartedEvent 之后立即触发，表明应用处于存活状态。

7. ApplicationReadyEvent：应用程序和命令行运行器调用完成后触发此事件。

8. AvailabilityChangeEvent（ReadinessState.ACCEPTING_TRAFFIC）：在 ApplicationReadyEvent 之后立即触发，意味着应用已准备好处理请求。

9. ApplicationFailedEvent：若应用在启动过程中出现异常，则触发该事件。

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

• WebServer就绪后发送WebServerInitializedEvent。ServletWebServerInitializedEvent和ReactiveWebServerIninitializedEvent分别是servlet和反应式变体。

• 刷新ApplicationContext时发送ContextRefreshedEvent。

Web环境

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

• 如果存在Spring MVC，则使用AnnotationConfigServletWebServerApplicationContext

• 如果Spring MVC不存在，并且Spring WebFlux存在，则使用AnnotationConfigReactiveWebServerApplicationContext

• 否则，将使用AnnotationConfigApplicationContext

        这意味着，如果您在同一应用程序中使用SpringMVC和SpringWebFlux中的新WebClient，则默认情况下将使用Spring MVC。

• 您可以通过调用setWebApplicationType（WebApplicationType）轻松地覆盖它。

• 还可以完全控制通过调用setApplicationContextFactory（…）修改使用的ApplicationContext类型。

ApplicationArguments 访问应用程序命令参数

   ApplicationArguments 是 Spring Boot 中的一个接口，用于在应用启动时访问传递给应用的命令行参数。以下从功能、使用场景、使用方式等方面详细介绍其作用。

主要功能

• 解析命令行参数：ApplicationArguments 接口可以将传递给 Spring Boot 应用的命令行参数解析为选项参数（以 -- 开头的参数）和非选项参数，方便开发者对不同类型的参数进行处理。

• 提供参数访问方法：该接口提供了一系列方法，用于获取选项参数的名称、值，以及非选项参数的列表，开发者可以根据需要灵活使用这些方法。

使用场景

• 配置应用行为：通过命令行参数可以动态配置应用的行为，例如指定应用的运行模式（开发模式、生产模式）、数据库连接信息等。

• 传递自定义参数：在应用启动时传递一些自定义的参数，用于执行特定的任务或进行初始化操作。

• 测试和调试：在测试和调试过程中，可以通过命令行参数传递不同的配置，方便对应用进行测试和排查问题。

示例代码

import org.springframework.boot.ApplicationArguments;
import org.springframework.stereotype.Component;@Component
public class MyCommandLineArgsHandler {public MyCommandLineArgsHandler(ApplicationArguments args) {// 获取所有选项参数的名称System.out.println("选项参数名称: " + args.getOptionNames());// 检查是否包含某个选项参数if (args.containsOption("debug")) {System.out.println("应用以调试模式启动。");}// 获取某个选项参数的值if (args.containsOption("port")) {System.out.println("指定的端口号: " + args.getOptionValues("port"));}// 获取非选项参数的列表System.out.println("非选项参数: " + args.getNonOptionArgs());}
}

ACommandLineRunner

  CommandLineRunner 接口位于 org.springframework.boot 包下，是一个函数式接口，只包含一个抽象方法 run，定义如下：

package org.springframework.boot;@FunctionalInterface
public interface CommandLineRunner {void run(String... args) throws Exception;
}

   run 方法接收一个 String 数组参数 args，这个参数包含了应用程序启动时传递的命令行参数。该方法会在 Spring 应用上下文完全初始化之后被调用。

• 使用示例：

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;@Component
public class MyCommandLineRunner implements CommandLineRunner {@Overridepublic void run(String... args) throws Exception {System.out.println("应用启动后执行的代码逻辑...");for (String arg : args) {System.out.println("命令行参数: " + arg);}}
}

ApplicationRunner

   ApplicationRunner 接口同样位于 org.springframework.boot 包下，也是一个函数式接口，其抽象方法 run 接收一个 ApplicationArguments 类型的参数，定义如下：

package org.springframework.boot;import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;@FunctionalInterface
public interface ApplicationRunner extends Ordered {void run(ApplicationArguments args) throws Exception;
}

   ApplicationArguments 是一个封装了命令行参数的对象，它提供了更方便的方法来处理选项参数和非选项参数。

• 使用示例

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;@Component
public class MyApplicationRunner implements ApplicationRunner {@Overridepublic void run(ApplicationArguments args) throws Exception {System.out.println("应用启动后执行的代码逻辑...");System.out.println("选项参数: " + args.getOptionNames());System.out.println("非选项参数: " + args.getNonOptionArgs());}
}

使用场景

• 数据初始化：在应用启动后，你可能需要初始化一些数据到数据库或者缓存中，比如加载配置文件、初始化字典数据等。

• 资源预热：提前加载一些常用的资源，以减少后续请求的响应时间，例如预热缓存、初始化连接池等。

• 启动脚本：执行一些启动时的脚本任务，如检查系统环境、创建必要的文件目录等。

两者的区别

• 参数类型：CommandLineRunner 的 run 方法接收的是一个 String 数组，需要开发者自己解析命令行参数；而 ApplicationRunner 的 run 方法接收的是一个 ApplicationArguments 对象，它对命令行参数进行了封装，提供了更方便的方法来处理选项参数和非选项参数。

• 使用场景：如果只是简单地处理命令行参数，CommandLineRunner 就足够了；如果需要更复杂的参数处理，如区分选项参数和非选项参数，ApplicationRunner 会更合适。

@Order 控制顺序执行

        如果程序中存在多个CommandLineRunnner 或者 ApplicationRunner，我们可以使用@Order注解来控制bean 类的最终执行顺序。

应用程序退出

        在 Spring Boot 中，SpringApplication.exit() 方法用于优雅地关闭 Spring Boot 应用程序。该方法会执行一系列的关闭操作，包括：

• 触发 DisposableBean 接口的 destroy() 方法，让实现该接口的 Bean 有机会进行资源清理。

• 调用 SmartLifecycle 接口的 stop() 方法，停止那些实现了该接口的生命周期组件。

• 关闭 ApplicationContext，释放相关资源。

  SpringApplication.exit() 方法会返回一个退出码（int 类型），这个退出码可以用于指示应用程序的退出状态，通常 0 表示正常退出，非 0 表示异常退出。

使用场景

• 程序正常结束：当应用程序完成了它的任务，需要正常关闭时，可以调用该方法。例如，一个定时任务应用在完成所有任务后，主动退出。

• 异常处理：在应用程序遇到严重错误，无法继续运行时，可以调用该方法并返回一个非 0 的退出码，以指示应用程序异常退出。

• 自动化测试：在自动化测试中，测试完成后可以调用该方法关闭应用程序，确保资源被正确释放。

示例代码

正常退出

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;@SpringBootApplication
public class NormalExitExample implements CommandLineRunner {public static void main(String[] args) {ConfigurableApplicationContext context = SpringApplication.run(NormalExitExample.class, args);}@Overridepublic void run(String... args) throws Exception {System.out.println("应用程序开始执行任务...");// 模拟执行一些任务Thread.sleep(2000);System.out.println("任务执行完成，准备退出应用程序。");// 获取当前的应用上下文ConfigurableApplicationContext context = SpringApplication.run(NormalExitExample.class, args);// 调用 exit 方法正常退出应用程序，返回退出码 0int exitCode = SpringApplication.exit(context, () -> 0);System.exit(exitCode);}
}

异常退出

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;@SpringBootApplication
public class ExceptionExitExample implements CommandLineRunner {public static void main(String[] args) {ConfigurableApplicationContext context = SpringApplication.run(ExceptionExitExample.class, args);}@Overridepublic void run(String... args) throws Exception {System.out.println("应用程序开始执行任务...");try {// 模拟抛出异常throw new RuntimeException("发生了严重错误！");} catch (RuntimeException e) {System.err.println("捕获到异常: " + e.getMessage());System.err.println("准备异常退出应用程序。");// 获取当前的应用上下文ConfigurableApplicationContext context = SpringApplication.run(ExceptionExitExample.class, args);// 调用 exit 方法异常退出应用程序，返回退出码 1int exitCode = SpringApplication.exit(context, () -> 1);System.exit(exitCode);}}
}

ExitCodeGenerator 定义退出代码

 @Beanpublic ExitCodeGenerator exitCodeGenerator() {return () -> 42;}public static void main(String[] args) {System.exit(SpringApplication.exit(SpringApplication.run(SpringBootLearnExample2Application.class, args)));}

管理功能

        我们可以通过指定 spring.application.admin.enabled 属性可开启应用的管理相关功能，开启后会在平台的 MBeanServer 上暴露 SpringApplicationAdminMXBean，可用于远程管理 Spring Boot 应用，对服务包装器实现也有帮助。

应用程序启动追踪

        在应用启动期间，SpringApplication 和 ApplicationContext 会执行众多与应用生命周期、Bean 生命周期及应用事件处理相关的任务。借助 ApplicationStartup，Spring 框架允许使用 StartupStep 对象跟踪应用的启动序列，这些数据可用于性能分析或帮助更好地理解应用启动过程。

        在设置 SpringApplication 实例时可选择 ApplicationStartup 的实现类。例如，可使用 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 框架提供，它将 Spring 特定的启动事件添加到 Java Flight Recorder 会话中，用于分析应用程序并关联 Spring 上下文生命周期与 JVM 事件。配置后，可通过启用 Java Flight Recorder 来记录数据。

  • BufferingApplicationStartup：Spring Boot 自带的实现类，用于缓冲启动步骤并将其输出到外部指标系统。应用程序可在任何组件中获取该类型的 Bean。

• 额外配置：Spring Boot 还可配置暴露一个启动端点，以 JSON 文档形式提供启动跟踪信息。

虚拟线程

        在 Java 21 及更高版本中，Spring Boot 支持使用虚拟线程。虚拟线程是 Java 平台引入的轻量级线程，它旨在简化并发编程，提高应用程序的吞吐量和资源利用率。与传统的操作系统线程相比，虚拟线程的创建和销毁成本更低，能够在相同的硬件资源下处理更多的并发任务。

• 启用虚拟线程：要在 Spring Boot 应用中启用虚拟线程，需要设置 spring.threads.virtual.enabled 属性为 true。

• 线程池配置的变化：当启用虚拟线程后，配置线程池的属性将不再生效。这是因为虚拟线程是在 JVM 全局的平台线程池上进行调度，而不是在专用的线程池上。

• 处理守护线程问题：虚拟线程是守护线程，这意味着如果 JVM 中的所有线程都是守护线程，JVM 将退出。例如，当使用 @Scheduled 注解的 Bean 来保持应用程序运行时，可能会出现问题。因为调度器线程是虚拟线程，也就是守护线程，无法使 JVM 保持运行。为了解决这个问题，可以设置 spring.main.keep-alive 属性为 true，确保即使所有线程都是虚拟线程，JVM 也能保持运行。

示例代码

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;@SpringBootApplication
@EnableScheduling
public class VirtualThreadExampleApplication {public static void main(String[] args) {SpringApplication application = new SpringApplication(VirtualThreadExampleApplication.class);// 模拟在代码中设置属性application.setDefaultProperties(java.util.Map.of("spring.threads.virtual.enabled", "true","spring.main.keep-alive", "true"));application.run(args);}
}@Component
class ScheduledTask {@Scheduled(fixedRate = 5000)public void performTask() {System.out.println("Scheduled task is running...");}
}

        在上述示例中，我们启用了虚拟线程和定时任务，并设置了 spring.main.keep-alive 属性为 true，以确保 JVM 不会因为虚拟线程是守护线程而提前退出。

参考文献

SpringApplication :: Spring Boot