SpringBoot如何實現定時任務

Jae1995發表於2021-10-13
Spring Boot

寫在前面

SpringBoot建立定時任務的方式很簡單，主要有兩種方式：一、基於註解的方式（@Scheduled）二、資料庫動態配置。實際開發中，第一種需要在程式碼中寫死表示式，如果修改起來，又得重啟會顯示很麻煩；所以我們往往會採取第二種方式，可以直接從資料庫中讀取定時任務的指定執行時間，無需重啟。

 

下面就來介紹下這兩種方式吧

一、基於註解（@Scheduled）

基於註解是一種靜態的方式，只需要幾行程式碼就可以搞定了

新增一個配置類

 1 @Configuration  //標記配置類
 2 @EnableScheduling   //開啟定時任務
 3 public class MyScheduleConfig {
 4 
 5     //新增定時任務
 6     @Scheduled(cron = "0/5 * * * * ?")
 7     private void myTasks() {
 8         System.out.println("執行定時任務 " + LocalDateTime.now());
 9     }
10 }

上面程式碼的cron表示式表示每5秒執行一次，可以通過這個網站（https://qqe2.com/cron）去生成要的cron表示式

啟動應用，控制檯看效果

 

這個方式的確很簡單方便，但前面介紹也說到了，有個缺點就是當我們需要去修改定時任務的執行週期或者停止的時候，我們需要到程式碼層去修改，重啟。

 

二、資料庫動態配置

這裡使用MySQL資料庫

1、表資料新增，資源配置

1.1 新增表

CREATE TABLE `scheduled_job` (
  `job_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主鍵id',
  `job_key` varchar(128) NOT NULL COMMENT '定時任務完整類名',
  `cron_expression` varchar(20) NOT NULL COMMENT 'cron表示式',
  `task_explain` varchar(50) NOT NULL DEFAULT '' COMMENT '任務描述',
  `status` tinyint(4) NOT NULL DEFAULT '1' COMMENT '狀態,1:正常;-1:停用',
  PRIMARY KEY (`job_id`),
  UNIQUE KEY `job_key` (`job_key`),
  UNIQUE KEY `cron_key_unique_idx` (`job_key`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='定時任務表';

 

1.2 插入兩條資料，job_key根據是完整的類名

 

1.3 引入依賴 

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.49</version>
            <scope>runtime</scope>
        </dependency>
        <!--mybatis-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.3.1.tmp</version>
        </dependency>
        <!--lombok簡化程式碼-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
            <scope>provided</scope>
        </dependency>

 

1.4 配置application.yml

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/test?userUnicode=true&characterEncoding=UTF8&useSSL=false
    username: root
    password: 123
    driver-class-name: com.mysql.jdbc.Driver
server:
  servlet:
    context-path: /demo
  port: 8888

 

2、瘋狂貼程式碼

2.1 建立定時任務執行緒池

 1 @Configuration
 2 @Slf4j
 3 public class ScheduledConfig {
 4 
 5     @Bean
 6     public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
 7         log.info("建立定時任務排程執行緒池 start");
 8         ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
 9         threadPoolTaskScheduler.setPoolSize(20);
10         threadPoolTaskScheduler.setThreadNamePrefix("taskExecutor-");
11         threadPoolTaskScheduler.setWaitForTasksToCompleteOnShutdown(true);
12         threadPoolTaskScheduler.setAwaitTerminationSeconds(60);
13         log.info("建立定時任務排程執行緒池 end");
14         return threadPoolTaskScheduler;
15     }
16 
17 }

 

2.2 專案啟動時初始化定時任務

 1 @Slf4j
 2 @Component
 3 public class ScheduledTaskRunner implements ApplicationRunner {
 4     @Autowired
 5     private ScheduledTaskService scheduledTaskService;
 6 
 7     @Override
 8     public void run(ApplicationArguments args) throws Exception {
 9         log.info("----初始化定時任務開始----");
10         scheduledTaskService.initTask();
11         log.info("----初始化定時任務完成----");
12     }
13 }

 

2.3 定時任務公共介面

1 public interface ScheduledOfTask extends Runnable{
2 
3     void execute();
4 
5     @Override
6     default void run() {
7         execute();
8     }
9 }

 

2.4 建立兩個定時任務實現類

1 @Component
2 @Slf4j
3 public class TaskJob1 implements ScheduledOfTask{
4     @Override
5     public void execute() {
6         log.info("執行任務1 "+ LocalDateTime.now());
7     }
8 }

 

1 @Component
2 @Slf4j
3 public class TaskJob2 implements ScheduledOfTask{
4     @Override
5     public void execute() {
6         log.info("執行任務2 "+ LocalDateTime.now());
7     }
8 }

 

2.5 定時任務管理介面

 1 public interface ScheduledTaskService{
 2 
 3     Boolean start(ScheduledJob scheduledJob);
 4 
 5     Boolean stop(String jobKey);
 6 
 7     Boolean restart(ScheduledJob scheduledJob);
 8 
 9     void initTask();
10 }

 

2.6 定時任務管理實現類

  1 @Slf4j
  2 @Service
  3 public class ScheduledTaskServiceImpl implements ScheduledTaskService {
  4 
  5     /**
  6      * 可重入鎖
  7      */
  8     private ReentrantLock lock = new ReentrantLock();
  9 
 10     /**
 11      * 定時任務執行緒池
 12      */
 13     @Autowired
 14     private ThreadPoolTaskScheduler threadPoolTaskScheduler;
 15 
 16     /**
 17      * 啟動狀態的定時任務集合
 18      */
 19     public Map<String, ScheduledFuture> scheduledFutureMap = new ConcurrentHashMap<>();
 20 
 21     @Autowired
 22     private ScheduledJobService scheduledJobService;
 23 
 24     @Override
 25     public Boolean start(ScheduledJob scheduledJob) {
 26         String jobKey = scheduledJob.getJobKey();
 27         log.info("啟動定時任務"+jobKey);
 28         //新增鎖放一個執行緒啟動，防止多人啟動多次
 29         lock.lock();
 30         log.info("加鎖完成");
 31 
 32         try {
 33             if(this.isStart(jobKey)){
 34                 log.info("當前任務在啟動狀態中");
 35                 return false;
 36             }
 37             //任務啟動
 38             this.doStartTask(scheduledJob);
 39         } finally {
 40             lock.unlock();
 41             log.info("解鎖完畢");
 42         }
 43 
 44         return true;
 45     }
 46 
 47     /**
 48      * 任務是否已經啟動
 49      */
 50     private Boolean isStart(String taskKey) {
 51         //校驗是否已經啟動
 52         if (scheduledFutureMap.containsKey(taskKey)) {
 53             if (!scheduledFutureMap.get(taskKey).isCancelled()) {
 54                 return true;
 55             }
 56         }
 57         return false;
 58     }
 59 
 60     @Override
 61     public Boolean stop(String jobKey) {
 62         log.info("停止任務 "+jobKey);
 63         boolean flag = scheduledFutureMap.containsKey(jobKey);
 64         log.info("當前例項是否存在 "+flag);
 65         if(flag){
 66             ScheduledFuture scheduledFuture = scheduledFutureMap.get(jobKey);
 67 
 68             scheduledFuture.cancel(true);
 69 
 70             scheduledFutureMap.remove(jobKey);
 71         }
 72         return flag;
 73     }
 74 
 75     @Override
 76     public Boolean restart(ScheduledJob scheduledJob) {
 77         log.info("重啟定時任務"+scheduledJob.getJobKey());
 78         //停止
 79         this.stop(scheduledJob.getJobKey());
 80 
 81         return this.start(scheduledJob);
 82     }
 83 
 84     /**
 85      * 執行啟動任務
 86      */
 87     public void doStartTask(ScheduledJob sj){
 88         log.info(sj.getJobKey());
 89         if(sj.getStatus().intValue() != 1)
 90             return;
 91         Class<?> clazz;
 92         ScheduledOfTask task;
 93         try {
 94             clazz = Class.forName(sj.getJobKey());
 95             task = (ScheduledOfTask) SpringContextUtil.getBean(clazz);
 96         } catch (ClassNotFoundException e) {
 97             throw new IllegalArgumentException("spring_scheduled_cron表資料" + sj.getJobKey() + "有誤", e);
 98         }
 99         Assert.isAssignable(ScheduledOfTask.class, task.getClass(), "定時任務類必須實現ScheduledOfTask介面");
100         ScheduledFuture scheduledFuture = threadPoolTaskScheduler.schedule(task,(triggerContext -> new CronTrigger(sj.getCronExpression()).nextExecutionTime(triggerContext)));
101         scheduledFutureMap.put(sj.getJobKey(),scheduledFuture);
102     }
103 
104     @Override
105     public void initTask() {
106         List<ScheduledJob> list = scheduledJobService.list();
107         for (ScheduledJob sj : list) {
108             if(sj.getStatus().intValue() == -1) //未啟用
109                 continue;
110             doStartTask(sj);
111         }
112     }
113 }

 

2.8 上面用到的獲取Bean的工具類SpringContextUtil

 1 @Component
 2 public class SpringContextUtil implements ApplicationContextAware {
 3 
 4 
 5     private static ApplicationContext applicationContext = null;
 6     @Override
 7     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
 8         if(SpringContextUtil.applicationContext == null){
 9             SpringContextUtil.applicationContext  = applicationContext;
10         }
11     }
12 
13     public static ApplicationContext getApplicationContext() {
14         return applicationContext;
15     }
16 
17     public static Object getBean(String name){
18         return getApplicationContext().getBean(name);
19     }
20 
21     public static <T> T getBean(Class<T> clazz){
22         return getApplicationContext().getBean(clazz);
23     }
24 
25     public static <T> T getBean(String name,Class<T> clazz){
26         return getApplicationContext().getBean(name, clazz);
27     }
28 }

 

2.9 表操作對應的一些類

Pojo

 1 @Data
 2 @TableName("scheduled_job")
 3 public class ScheduledJob {
 4 
 5     @TableId(value = "job_id",type = IdType.AUTO)
 6     private Integer jobId;
 7 
 8     private String jobKey;
 9 
10     private String cronExpression;
11 
12     private String taskExplain;
13 
14     private Integer status;
15 
16 }

 ScheduledJobMapper

1 public interface ScheduledJobMapper extends BaseMapper<ScheduledJob> {
2 }

 

ScheduledJobService

1 public interface ScheduledJobService extends IService<ScheduledJob> {
2 
3     /**
4      * 修改定時任務，並重新啟動
5      * @param scheduledJob
6      * @return
7      */
8     boolean updateOne(ScheduledJob scheduledJob);
9 }

 

 1 @Service
 2 @Slf4j
 3 public class ScheduledJobServiceImpl extends ServiceImpl<ScheduledJobMapper, ScheduledJob> implements ScheduledJobService{
 4 
 5     @Autowired
 6     private ScheduledTaskService scheduledTaskService;
 7 
 8     @Override
 9     public boolean updateOne(ScheduledJob scheduledJob) {
10         if(updateById(scheduledJob))
11             scheduledTaskService.restart(getById(scheduledJob.getJobId()));
12         return true;
13     }
14 }

 

2.10 修改定時任務的介面

 1 @RestController
 2 @RequestMapping("/job")
 3 public class ScheduledJobController {
 4 
 5     @Autowired
 6     private ScheduledJobService scheduledJobService;
 7 
 8     @PostMapping(value = "/update")
 9     public CallBackResult update(HttpServletRequest request, ScheduledJob scheduledJob){
10          if(scheduledJobService.updateOne(scheduledJob))
11              return new CallBackResult(true,"修改成功");
12          return new CallBackResult(false,"修改失敗");
13     }
14 
15 }

 

3、測試結果

3.1 啟動專案，看下定時任務的執行結果，控制檯輸出結果

 

 

我們可以看到任務1是每5秒執行一次，任務2是12秒執行一次

 

3.2 修改任務1的cron引數或者狀態

 

 3.2.1 修改cron，執行週期改為20秒執行一次，狀態不變

 

再看控制檯輸出結果，任務2沒變化，任務1由5秒一次變成了20秒一次了

 

 3.2.1 修改狀態

 

 

 

 

 再看控制檯輸出結果，任務2沒變化，任務1已經不再執行了

 

最後

第二種方式支援通過介面的方式去改動，並且不需要重啟，當然啦，也可以直接在資料庫中新增或修改資料後重啟專案，配置更加靈活一點。

如果是一個固定的需求，執行週期一定不會變的了，推薦還是第一種寫法，畢竟簡單嘛。

 

如果覺得寫得還不錯的話，給個推薦鼓勵一下吧。

相關文章