之前写过文章记录怎么在SpringBoot项目中简单使用定时任务，不过由于要借助cron表达式且都提前定义好放在配置文件里，不能在项目运行中动态修改任务执行时间，实在不太灵活。
    经过网上搜索学习后，特此记录如何在SpringBoot项目中实现动态定时任务。
    因为只是一个demo，所以只引入了需要的依赖：

    1. <dependencies>
    2.         <dependency>
    3.             <groupId>org.springframework.boot</groupId>
    4.             <artifactId>spring-boot-starter-web</artifactId>
    5.         </dependency>
    7.         <dependency>
    8.             <groupId>org.springframework.boot</groupId>
    9.             <artifactId>spring-boot-starter-log4j2</artifactId>
    10.             <optional>true</optional>
    11.         </dependency>
    13.         <!-- spring boot 2.3版本后，如果需要使用校验，需手动导入validation包-->
    14.         <dependency>
    15.             <groupId>org.springframework.boot</groupId>
    16.             <artifactId>spring-boot-starter-validation</artifactId>
    17.         </dependency>
    19.         <dependency>
    20.             <groupId>org.projectlombok</groupId>
    21.             <artifactId>lombok</artifactId>
    22.             <optional>true</optional>
    23.         </dependency>
    24.     </dependencies>

    启动类：

    1. package com.wl.demo;
    3. import org.springframework.boot.SpringApplication;
    4. import org.springframework.boot.autoconfigure.SpringBootApplication;
    5. import org.springframework.scheduling.annotation.EnableScheduling;
    7. /**
    8.  * @author wl
    9.  * @date 2022/3/22
    10.  */
    11. @EnableScheduling
    12. @SpringBootApplication
    13. public class DemoApplication {
    15.     public static void main(String[] args) {
    16.         SpringApplication.run(DemoApplication.class, args);
    17.         System.out.println("(*^▽^*)启动成功!!!(〃'▽'〃)");
    18.     }
    19. }

    配置文件application.yml，只定义了服务端口：

    1. server:
    2.     port: 8089

    定时任务执行时间配置文件：task-config.ini:

    printTime.cron=0/10 ?

    定时任务执行类：

    1. package com.wl.demo.task;
    3. import lombok.Data;
    4. import lombok.extern.slf4j.Slf4j;
    5. import org.springframework.beans.factory.annotation.Value;
    6. import org.springframework.context.annotation.PropertySource;
    7. import org.springframework.scheduling.Trigger;
    8. import org.springframework.scheduling.TriggerContext;
    9. import org.springframework.scheduling.annotation.SchedulingConfigurer;
    10. import org.springframework.scheduling.config.ScheduledTaskRegistrar;
    11. import org.springframework.scheduling.support.CronTrigger;
    12. import org.springframework.stereotype.Component;
    14. import java.time.LocalDateTime;
    15. import java.util.Date;
    17. /**
    18. * 定时任务
    19. * @author wl
    20. * @date 2022/3/22
    21. */
    22. @Data
    23.     @Slf4j
    24.     @Component
    25.     @PropertySource("classpath:/task-config.ini")
    26.     public class ScheduleTask implements SchedulingConfigurer {
    28.         @Value("${printTime.cron}")
    29.         private String cron;
    31.         @Override
    32.         public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
    33.             // 动态使用cron表达式设置循环间隔
    34.             taskRegistrar.addTriggerTask(new Runnable() {
    35.                 @Override
    36.                 public void run() {
    37.                     log.info("Current time： {}", LocalDateTime.now());
    38.                 }
    39.             }, new Trigger() {
    40.                 @Override
    41.                 public Date nextExecutionTime(TriggerContext triggerContext) {
    42.                     // 使用CronTrigger触发器，可动态修改cron表达式来操作循环规则
    43.                     CronTrigger cronTrigger = new CronTrigger(cron);
    44.                     Date nextExecutionTime = cronTrigger.nextExecutionTime(triggerContext);
    45.                     return nextExecutionTime;
    46.                 }
    47.             });
    48.         }
    49.     }

    编写一个接口，使得可以通过调用接口动态修改该定时任务的执行时间：

    1. package com.wl.demo.controller;
    3. import com.wl.demo.task.ScheduleTask;
    4. import lombok.extern.slf4j.Slf4j;
    5. import org.springframework.beans.factory.annotation.Autowired;
    6. import org.springframework.web.bind.annotation.GetMapping;
    7. import org.springframework.web.bind.annotation.RequestMapping;
    8. import org.springframework.web.bind.annotation.RestController;
    10. /**
    11.  * @author wl
    12.  * @date 2022/3/22
    13.  */
    14. @Slf4j
    15. @RestController
    16. @RequestMapping("/test")
    17. public class TestController {
    19.     private final ScheduleTask scheduleTask;
    21.     @Autowired
    22.     public TestController(ScheduleTask scheduleTask) {
    23.         this.scheduleTask = scheduleTask;
    24.     }
    26.     @GetMapping("/updateCron")
    27.     public String updateCron(String cron) {
    28.         log.info("new cron :{}", cron);
    29.         scheduleTask.setCron(cron);
    30.         return "ok";
    31.     }
    32. }

    启动项目，可以看到任务每10秒执行一次：
    SpringBoot 设置动态定时任务 - 图1
    访问接口，传入请求参数cron表达式，将定时任务修改为15秒执行一次：
    SpringBoot 设置动态定时任务 - 图2
    可以看到任务变成了15秒执行一次
    SpringBoot 设置动态定时任务 - 图3
    除了上面的借助cron表达式的方法，还有另一种触发器，区别于CronTrigger触发器，该触发器可随意设置循环间隔时间，不像cron表达式只能定义小于等于间隔59秒。需要开通正版IDEA的可以加我微信：poxiaozhiai6，56元一年。

    1. package com.wl.demo.task;
    3. import lombok.Data;
    4. import lombok.extern.slf4j.Slf4j;
    5. import org.springframework.beans.factory.annotation.Value;
    6. import org.springframework.context.annotation.PropertySource;
    7. import org.springframework.scheduling.Trigger;
    8. import org.springframework.scheduling.TriggerContext;
    9. import org.springframework.scheduling.annotation.SchedulingConfigurer;
    10. import org.springframework.scheduling.config.ScheduledTaskRegistrar;
    11. import org.springframework.scheduling.support.CronTrigger;
    12. import org.springframework.scheduling.support.PeriodicTrigger;
    13. import org.springframework.stereotype.Component;
    15. import java.time.LocalDateTime;
    16. import java.util.Date;
    18. /**
    19.  * 定时任务
    20.  * @author wl
    21.  * @date 2022/3/22
    22.  */
    23. @Data
    24. @Slf4j
    25. @Component
    26. @PropertySource("classpath:/task-config.ini")
    27. public class ScheduleTask implements SchedulingConfigurer {
    29.     @Value("${printTime.cron}")
    30.     private String cron;
    32.     private Long timer = 10000L;
    34.     @Override
    35.     public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
    36.         // 动态使用cron表达式设置循环间隔
    37.         taskRegistrar.addTriggerTask(new Runnable() {
    38.             @Override
    39.             public void run() {
    40.                 log.info("Current time： {}", LocalDateTime.now());
    41.             }
    42.         }, new Trigger() {
    43.             @Override
    44.             public Date nextExecutionTime(TriggerContext triggerContext) {
    45.                 // 使用CronTrigger触发器，可动态修改cron表达式来操作循环规则
    46. //                CronTrigger cronTrigger = new CronTrigger(cron);
    47. //                Date nextExecutionTime = cronTrigger.nextExecutionTime(triggerContext);
    49.                 // 使用不同的触发器，为设置循环时间的关键，区别于CronTrigger触发器，该触发器可随意设置循环间隔时间，单位为毫秒
    50.                 PeriodicTrigger periodicTrigger = new PeriodicTrigger(timer);
    51.                 Date nextExecutionTime = periodicTrigger.nextExecutionTime(triggerContext);
    52.                 return nextExecutionTime;
    53.             }
    54.         });
    55.     }
    56. }

    增加一个修改时间的接口：

    1. package com.wl.demo.controller;
    3. import com.wl.demo.task.ScheduleTask;
    4. import lombok.extern.slf4j.Slf4j;
    5. import org.springframework.beans.factory.annotation.Autowired;
    6. import org.springframework.web.bind.annotation.GetMapping;
    7. import org.springframework.web.bind.annotation.RequestMapping;
    8. import org.springframework.web.bind.annotation.RestController;
    10. /**
    11.  * @author wl
    12.  * @date 2022/3/22
    13.  */
    14. @Slf4j
    15. @RestController
    16. @RequestMapping("/test")
    17. public class TestController {
    19.     private final ScheduleTask scheduleTask;
    21.     @Autowired
    22.     public TestController(ScheduleTask scheduleTask) {
    23.         this.scheduleTask = scheduleTask;
    24.     }
    26.     @GetMapping("/updateCron")
    27.     public String updateCron(String cron) {
    28.         log.info("new cron :{}", cron);
    29.         scheduleTask.setCron(cron);
    30.         return "ok";
    31.     }
    33.     @GetMapping("/updateTimer")
    34.     public String updateTimer(Long timer) {
    35.         log.info("new timer :{}", timer);
    36.         scheduleTask.setTimer(timer);
    37.         return "ok";
    38.     }
    39. }

    测试结果：
    SpringBoot 设置动态定时任务 - 图4