Spring Boot如何实现定时任务的动态增删启停详解

下面我会详细讲解“Spring Boot如何实现定时任务的动态增删启停详解”的完整攻略。

什么是定时任务？

定时任务（Scheduled Task）是指在指定的时间点或时间间隔内自动执行某个操作的任务。在很多场景下，我们经常需要定时执行某些操作，例如定时清理临时数据、定时发送邮件等。

Spring Boot如何实现定时任务

Spring Boot 提供了标准的方式来支持定时任务的实现，主要借助了 @EnableScheduling 注解和 @Scheduled 注解。

添加依赖

在 pom.xml 中添加 Spring Boot 定时任务的依赖：

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

启用定时任务

在启动类上添加 @EnableScheduling 注解，启用 Spring Boot 定时任务功能：

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

定义定时任务

定义定时任务使用 @Scheduled 注解，该注解可以标记在方法上，并可以设置定时任务的触发条件，例如：

@Component
public class MyTask {
    @Scheduled(fixedRate = 1000)
    public void doTask() {
        System.out.println("定时任务执行中...");
    }
}

上面的例子中，使用 @Scheduled(fixedRate = 1000) 设置了每隔 1000 毫秒执行一次 doTask 方法，该方法中的代码会在定时任务触发时被执行。

动态增删启停定时任务

通过上述的方式，我们可以实现简单的定时任务功能，但是如何实现动态增删启停定时任务呢？

方式一：使用 TaskScheduler 接口实现动态任务

Spring Boot 为我们提供了 TaskScheduler 接口，可以实现动态添加和删除任务的功能。我们只需要注入该接口的实例，然后借助 ScheduledFuture 对象控制任务的执行即可。

示例代码如下：

@Component
public class DynamicTask {
    @Autowired
    private TaskScheduler taskScheduler;

    private ScheduledFuture<?> future;

    /**
     * 开启任务
     * @param interval 任务间隔，毫秒数
     */
    public void start(long interval) {
        stop();
        this.future = taskScheduler.scheduleAtFixedRate(() -> {
            System.out.println("动态定时任务执行中...");
        }, interval);
    }

    /**
     * 停止任务
     */
    public void stop() {
        if (this.future != null) {
            this.future.cancel(true);
        }
    }
}

在上述代码中，我们定义了 DynamicTask 类，其中 start 方法用于启动任务，接收一个时间间隔参数 interval，该方法会先停止已存在的任务，再根据传入参数启动新任务，任务的执行内容是打印一条日志信息。stop 方法用于停止任务，基于 ScheduledFuture 对象实现。

方式二：使用 Quartz 框架实现动态任务

当具备更高的动态性能力时，我们可以选择使用 Quartz 框架。

在 Spring Boot 中，通过添加 spring-boot-starter-quartz 依赖，并在配置文件中设置各种参数即可使用 Quartz 实现定时任务。

下面是一个使用 Quartz 实现动态增删启停定时任务的示例代码：

@Component
public class DynamicQuartzTask extends QuartzJobBean {
    private static final Logger LOGGER = LoggerFactory.getLogger(DynamicQuartzTask.class);

    private Scheduler scheduler;

    private String schedulerName;

    private String jobName;

    private String groupName;

    private String cronExpression;

    public DynamicQuartzTask(Scheduler scheduler, String schedulerName, String jobName, String groupName, String cronExpression) {
        this.scheduler = scheduler;
        this.schedulerName = schedulerName;
        this.jobName = jobName;
        this.groupName = groupName;
        this.cronExpression = cronExpression;
    }

    /**
     * 启动任务
     * @throws Exception
     */
    public void start() throws Exception {
        // 如果 job 存在，则删除任务
        JobKey key = new JobKey(jobName, groupName);
        if (scheduler.checkExists(key)) {
            scheduler.deleteJob(key);
        }

        // 构造 jobDetail
        JobDetail jobDetail = JobBuilder.newJob(getClass()).withIdentity(jobName, groupName).build();

        // 构造 trigger
        CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobName, groupName)
                .withSchedule(CronScheduleBuilder.cronSchedule(cronExpression)).build();

        // 启动定时任务
        scheduler.scheduleJob(jobDetail, trigger);
    }

    /**
     * 停止任务
     * @throws Exception
     */
    public void stop() throws Exception {
        scheduler.deleteJob(new JobKey(jobName, groupName));
    }

    @Override
    public void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        LOGGER.info("动态定时任务执行中...");
    }
}

上述代码中，我们定义了 DynamicQuartzTask 类，构造方法中接收 Scheduler 对象和各种任务相关的参数，使用 checkExists 方法检查任务是否已存在，如果存在则删除任务，接着构造 JobDetail 和 Trigger，最后通过 scheduleJob 方法来启动任务。

具体使用可以参考下面的例子：

@Component
public class ScheduleTaskTest implements CommandLineRunner {

    @Autowired
    private Scheduler scheduler;

    @Autowired
    private DynamicQuartzTask dynamicQuartzTask;

    @Override
    public void run(String... args) throws Exception {
        // 动态添加定时任务
        dynamicQuartzTask.start();

        // 20 秒后停止定时任务
        TimeUnit.SECONDS.sleep(20);
        dynamicQuartzTask.stop();

        // 5 秒后重新启动定时任务
        TimeUnit.SECONDS.sleep(5);
        dynamicQuartzTask.start();

        // 20 秒后停止定时任务
        TimeUnit.SECONDS.sleep(20);
        dynamicQuartzTask.stop();

        // 关闭 scheduler
        scheduler.shutdown();
    }
}

在上述代码中，我们定义了 ScheduleTaskTest 类，实现了 CommandLineRunner 接口，重写了 run 方法，该方法会先启动 DynamicQuartzTask 定时任务，20 秒后停止，再等待 5 秒后重新启动，最后再停止任务。

总结

在本篇攻略中，我们详细讲述了如何使用 Spring Boot 实现定时任务的动态增删启停，使用了 TaskScheduler 接口和 Quartz 框架两种方式，其中 Quartz 方式在实现动态性能方面更佳。