Spring Boot启动后执行任务的8种方式

在软件开发中，Spring Boot已成为创建健壮且高效的 Java 应用程序的高度首选框架。一种常见的要求是在应用程序启动后执行特定任务。这可能包括初始化数据、设置连接或执行健全性检查。在本文中，我们将深入研究可用于在 Spring Boot 启动后执行任务的各种选项，确保您的应用程序不仅可以正常运行，而且从一开始就可以实现最佳性能。


1、使用 CommandLineRunner 界面
CommandLineRunner是在 Spring Boot 应用程序启动后运行代码的一种简单有效的方法。这是一个接口，您可以实现它来在Spring 应用程序上下文完全加载后执行代码。其主要功能之一是以简单字符串数组的形式提供对应用程序参数的访问。这使得CommandLineRunner成为需要在应用程序启动并运行后立即执行初始化或健全性检查的开发人员的理想选择。

以下是如何在 Spring Boot 应用程序中使用CommandLineRunner的简单示例：

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MyApp implements CommandLineRunner {

    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        // Your custom logic here
        System.out.println("Executing logic after Spring Boot startup...");
        
        // Example: printing the command line arguments
        for (String arg : args) {
            System.out.println("arg = " + arg);
        }
    }
}

在此代码片段中：
  • 我们有一个用@SpringBootApplication注解的MyApp类，这是 Spring Boot 应用程序的标准注解。
  • MyApp实现了CommandLineRunner接口，需要实现run方法。
  • run方法包含加载应用程序上下文后要执行的代码。您可以在此处放置初始化逻辑或任何启动任务。
  • run方法中的String ...args参数允许您访问传递给应用程序的命令行参数。

通过使用CommandLineRunner，您可以确保您的代码在应用程序生命周期的正确时刻运行，利用完全初始化的 Spring 上下文。

2、ApplicationRunner：精致的替代方案
ApplicationRunner是 Spring Boot 提供的另一个优雅选项，用于在应用程序启动后执行代码。它与CommandLineRunner具有相似之处，但因其更复杂的ApplicationArguments接口而脱颖而出，该接口取代了原始字符串数组。此功能使得ApplicationRunner对于需要复杂参数解析和处理的场景特别有价值。它允许开发人员以更加结构化和方便的方式处理命令行参数。

以下是如何在 Spring Boot 应用程序中使用ApplicationRunner的示例：

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MyApp implements ApplicationRunner {

    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args);
    }

    @Override
    public void run(ApplicationArguments args) throws Exception {
        // Your custom logic here
        System.out.println("Executing logic after Spring Boot startup...");

        // Example: processing the command line arguments
        if (args.containsOption("myOption")) {
            System.out.println("myOption = " + args.getOptionValues("myOption"));
        }

        // Listing non-option arguments
        System.out.println("Non-option arguments: " + args.getNonOptionArgs());
    }
}

在此代码中：
  • MyApp类标有@SpringBootApplication ，表明它是一个 Spring Boot 应用程序。
  • MyApp实现了ApplicationRunner接口，因此需要实现run方法。
  • run方法接收一个ApplicationArguments对象，该对象封装了命令行参数。该对象提供了有效访问和处理这些参数的方法。
  • ApplicationArguments接口提供了诸如getOptionValues(String name)之类的方法来检索特定选项值，并提供getNonOptionArgs()来访问不是选项参数的参数（即没有键值对的参数）。

ApplicationRunner及其ApplicationArguments接口提供了一种更精细和结构化的方法来处理启动逻辑，特别是当您的应用程序需要处理复杂的命令行参数时。

3、@EventListener 和 ContextRefreshedEvent
Spring Boot 中的@EventListener注解提供了一种处理各种类型的应用程序事件的复杂方法。当你用@EventListener注解一个方法时，它就成为一个事件监听器，能够响应 Spring 应用程序中不同的生命周期事件。在这些事件中，ContextRefreshedEvent特别值得注意，因为它会在 Spring ApplicationContext初始化或刷新时触发。此功能对于执行需要完全初始化 Bean 的任务非常有用，使其成为某些类型的初始化逻辑的首选。

以下是如何将@EventListener注释与ContextRefreshedEvent结合使用：

import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

@Component
public class MyStartupTasks {

    @EventListener
    public void onApplicationEvent(ContextRefreshedEvent event) {
        // Your custom logic here
        System.out.println("Executing logic after ApplicationContext is initialized or refreshed...");

        // Perform some initialization tasks
        // For example, initializing a cache or checking service health
    }
}

在这个例子中：
  • MyStartupTasks是一个 Spring 管理的组件，由@Component注解指示。
  • onApplicationEvent方法用@EventListener注释。这将其标记为将由 Spring 触发的事件侦听器方法。
  • onApplicationEvent方法采用ContextRefreshedEvent参数。当应用程序上下文初始化或刷新时会引发此事件，使其成为执行初始化后逻辑的理想位置。
  • 在该方法内部，您可以放置​​自定义初始化逻辑或需要在应用程序上下文准备就绪后立即执行的任务。

将@EventListener与ContextRefreshedEvent结合使用提供了一种干净且可管理的方式来处理 Spring Boot 应用程序中的特定启动场景。这种方法确保您的代码在应用程序生命周期的正确时刻运行，利用完全初始化和配置的 Spring 上下文。

4、InitializingBean 和 afterPropertiesSet() 方法
对于喜欢将初始化逻辑直接封装在 Spring Bean 中的开发人员来说，InitializingBean接口提供了一个出色的解决方案。当 bean 实现此接口时，它允许重写 afterPropertiesSet ()方法。在设置了所有 bean 属性并且完全构造了 bean 后，Spring 容器将调用此方法。此功能对于执行任何依赖于 bean 属性的初始化任务特别有用。

下面的示例演示了如何使用InitializingBean和afterPropertiesSet()方法：

import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;

@Component
public class MyBean implements InitializingBean {

    // Example property
    private String someProperty;

    // Setter for the property
    public void setSomeProperty(String someProperty) {
        this.someProperty = someProperty;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        // Your custom initialization logic here
        System.out.println("Performing initialization logic after property setting...");

        // For instance, validate or initialize based on the property value
        if (someProperty != null) {
            System.out.println("Initializing with property: " + someProperty);
        } else {
            System.out.println("Property is not set. Initializing with defaults.");
        }
    }
}

在此代码中：
  • MyBean是一个 Spring 管理的组件，如@Component注释所示。
  • 该类实现了InitializingBean接口，该接口需要实现afterPropertiesSet方法。
  • 在afterPropertiesSet方法中，您可以放置​​自定义初始化逻辑。设置 bean 的所有属性后将调用此方法，使其成为依赖这些属性的初始化逻辑的合适位置。
  • 在示例中，有一个带有 setter 方法的简单属性someProperty。afterPropertiesSet中的初始化逻辑检查此属性并执行相应的操作。

使用InitializingBean和afterPropertiesSet()方法是处理Spring Bean 中初始化的一种干净且直接的方法。这种方法可确保您的初始化逻辑与 bean 生命周期紧密耦合，从而提供清晰、简洁的方法来管理 bean 初始化。

5、自定义事件监听器
在复杂的 Spring Boot 应用程序领域，经常会出现对定制解决方案的需求。自定义事件监听器完美地满足了这个目的，允许开发人员完全控制启动后任务的执行。通过定义您自己的自定义事件，您可以准确指定何时以及在什么条件下触发这些任务。这种方法对于具有复杂启动序列的应用程序或需要在执行某些初始化步骤之前满足特定条件的应用程序特别有益。

以下是如何在 Spring Boot 中创建和使用自定义事件的示例：

import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

// Step 1: Define a custom event
public class CustomStartupEvent extends ApplicationEvent {
    public CustomStartupEvent(Object source) {
        super(source);
    }
    // Additional fields and methods can be added as needed
}

// Step 2: Create an ApplicationListener or use @EventListener to listen to the custom event
@Component
public class CustomEventListener implements ApplicationListener<CustomStartupEvent> {

    @Override
    public void onApplicationEvent(CustomStartupEvent event) {
        // Custom logic to be executed when the event is published
        System.out.println("CustomStartupEvent triggered");
    }
}

// Step 3: Publish the custom event at the desired point in your application
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Component;

@Component
public class CustomEventPublisher {

    @Autowired
    private ApplicationEventPublisher applicationEventPublisher;

    public void publishEvent() {
        CustomStartupEvent customEvent = new CustomStartupEvent(this);
        applicationEventPublisher.publishEvent(customEvent);
    }
}

在此代码中：
  • 定义自定义事件：CustomStartupEvent类扩展了ApplicationEvent，使其成为可以在 Spring 应用程序上下文中发布的自定义事件。
  • 为 Event 创建侦听器：CustomEventListener类实现ApplicationListener<CustomStartupEvent>，专门侦听CustomStartupEvent。它重写onApplicationEvent方法来定义发布事件时应执行的逻辑。或者，可以使用使用@EventListener注解的方法来监听自定义事件。
  • 发布自定义事件：CustomEventPublisher类使用ApplicationEventPublisher来发布CustomStartupEvent。这可以在应用程序中您认为适合触发自定义逻辑的任何位置完成，从而使您可以完全控制事件的时间。

在 Spring Boot 中使用自定义事件是在应用程序启动期间管理复杂初始化序列或条件逻辑的强大方法。它提供了一种灵活且解耦的方法来根据应用程序的精确需求执行特定任务。

6、使用@PostConstruct注释
@PostConstruct注解源自 Java EE，提供了一种在 Spring Boot 应用程序中执行初始化代码的简化且有效的方法。用@PostConstruct注解的方法在 bean 构造完成并且所有依赖项注入完成后执行。此功能对于执行依赖于完全解析和注入的依赖项的初始化任务特别有利。

以下是如何在 Spring Boot 应用程序中使用@PostConstruct注解的示例：

import javax.annotation.PostConstruct;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    // Dependency injection example
    private final SomeDependency someDependency;

    public MyBean(SomeDependency someDependency) {
        this.someDependency = someDependency;
    }

    @PostConstruct
    public void init() {
        // Your custom initialization logic here
        System.out.println("Performing post-construction initialization...");

        // For instance, initializing data or validating dependencies
        someDependency.initialize();
    }
}

// Dummy dependency class for demonstration
class SomeDependency {
    void initialize() {
        // Initialization logic for the dependency
        System.out.println("SomeDependency is initialized.");
    }
}

在此代码中：
  • MyBean是 Spring 管理的 bean，由@Component注释表示。
  • 该 bean 有一个依赖项 ( SomeDependency )，它是通过构造函数注入注入的。
  • init方法用@PostConstruct注释。该方法将在 bean 完全构建并注入其依赖项后执行。
  • 在init方法内部，您可以放置​​自定义初始化逻辑。这是任何依赖于注入依赖项的设置的理想位置，例如初始化数据或验证依赖项的状态。

@PostConstruct注解提供了一种清晰简洁的方法来定义 Spring Bean 中的初始化逻辑。此方法可确保您的初始化代码在 bean 生命周期的正确点执行，从而提供一种可靠的方法来基于完全解析的依赖关系来管理 bean 初始化。

7、延迟执行的计划任务
在 Spring Boot 应用程序中的任务不需要在启动后立即执行，而是需要定期或在指定的延迟后运行的情况下，@Scheduled注解变得非常有用。此注释提供了一种简单的方法来定义应按定义的时间间隔或在设置的延迟后执行的方法，使其非常适合定期维护任务、定期数据同步或应在应用程序启动后一段时间发生的延迟初始化。

以下是如何在 Spring Boot 应用程序中实现计划任务的示例：

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class ScheduledTasks {

    // Run this task every 5 seconds
    @Scheduled(fixedRate = 5000)
    public void performTaskAtFixedRate() {
        System.out.println("Executing fixed rate task...");
    }

    // Run this task with a fixed delay of 3 seconds after the completion of the last invocation
    @Scheduled(fixedDelay = 3000)
    public void performTaskWithFixedDelay() {
        System.out.println("Executing task with fixed delay...");
    }

    // Run this task at a specific time - e.g., every day at 10:15 AM
    @Scheduled(cron = "0 15 10 * * ?")
    public void performTaskUsingCronExpression() {
        System.out.println("Executing task based on cron expression...");
    }
}

在此代码中：
  • ScheduledTasks是一个包含用@Scheduled注释的方法的组件。
  • PerformTaskAtFixedRate方法计划每5秒运行一次，如fixedRate = 5000所示。这对于需要定期连续运行的任务非常有用。
  • PerformTaskWithFixedDelay方法将在每次执行完成后以 3 秒的固定延迟执行。这特别适合于上一次执行完成后下一次执行需要等待一定时间的任务。

PerformTaskUsingCronExpression方法使用CRON 表达式来计划任务。在此示例中，任务计划在每天上午 10:15 运行。 CRON 表达式提供了一种定义复杂计划的强大方法。

Spring Boot 中的@Scheduled注解是一个强大的工具，用于管理需要定期或在一定延迟后执行的任务。它提供了调度灵活性，非常适合各种用例，从简单的定期清理到基于特定时间模式的复杂作业调度。

8、异步任务执行
在效率和响应能力至关重要的现代软件环境中， Spring Boot 中的@Async注释提供了增强应用程序性能的重要工具。此注释使方法能够异步执行，这意味着它们在单独的线程中运行并且不会阻塞主应用程序流。这对于非阻塞操作特别有用，例如发送电子邮件、执行后台计算或调用外部 API，您希望在这些操作中避免阻碍主应用程序启动过程。

下面的示例演示了在 Spring Boot 应用程序中使用@Async注释：

import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;

@Service
@EnableAsync
public class AsyncService {

    @Async
    public CompletableFuture<String> performAsyncTask() {
        // Simulate a long-running task
        try {
            Thread.sleep(5000); // 5 seconds delay
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        // Return a result after the delay
        return CompletableFuture.completedFuture("Task completed!");
    }
}

在此代码中：
  • AsyncService是 Spring 管理的服务，由@Service注解表示。
  • 该类使用@EnableAsync进行注释，这使得能够在 Spring 上下文中处理异步方法调用。
  • PerformAsyncTask方法使用@Async注解进行标记。这确保了该方法将异步执行，即在单独的线程中执行。
  • 在performAsyncTask方法内部，有一个模拟的长时间运行的进程（例如，睡眠5 秒）。在现实场景中，这可能是任何耗时的操作，例如数据库调用或远程 Web 服务调用。
  • 该方法返回一个CompletableFuture<String>。CompletableFuture是 Java 并发 API 的一部分，此处用于处理异步操作的结果。

在 Spring Boot 中使用@Async执行任务对于需要高响应能力和效率的应用程序来说是一个游戏规则改变者。通过卸载某些任务以异步运行，主应用程序线程保持畅通无阻，从而增强整体性能和用户体验。

结论
总之，Spring Boot 提供了多种用于在启动后执行任务的选项，每个选项都针对不同的需求和场景进行了定制。从使用CommandLineRunner和ApplicationRunner立即执行，到使用@EventListener和自定义事件进行复杂的事件处理，甚至使用@Scheduled和@Async注释延迟或定期执行，Spring Boot 为开发人员提供了优化应用程序准备情况和效率所需的工具。为您的特定用例选择合适的方法对于充分利用 Spring Boot 的潜力至关重要，确保您的应用程序不仅健壮，而且从一开始就以最佳性能运行。