SpringBoot自定义cron表达式注册定时任务

springBoot自定义cron表达式注册定时任务

一、原理

• 1、使用Spring自带的TaskScheduler注册任务
  
• 2、注册后返回：ScheduledFuture，用于取消定时任务
  
• 3、注册任务后不会马上取消任务，所以将任务缓存。在需要取消任务的时候调用取消接口取消
  
• 4、cron表达式可以由前端或者后端生成。实现中会校验cron表达式
  

1. public class TestScheduled {
3.     /**
4.      * 1、使用Spring自带的TaskScheduler注册任务
5.      * 2、注册后返回：ScheduledFuture，用于取消定时任务
6.      */
7.     @Resource
8.     private TaskScheduler taskScheduler;
10.     public void registrarTask() {
11.         //具体的任务Runnable（一般使用类实现Runnable接口）
12.         Runnable taskRunnable = new Runnable() {
13.             @Override
14.             public void run() {
16.             }
17.         };
18.         //cron表达式触发器
19.         CronTrigger trigger = new CronTrigger("0/5 * * * * ?");
20.         //开启定时任务的真正方法
21.         ScheduledFuture<?> future = this.taskScheduler.schedule(taskRunnable, trigger);
22.         //取消定时任务
23.         future.cancel(true);
24.     }
25. }

复制代码

二、具体实现

1、配置任务调度器

• 作用：设置：核心线程数：可同时执行任务数；设置线程名称前缀
  
• 可以不配置。不配置就默认使用spring自带的
  

1. package com.cc.ssd.config;
3. import org.springframework.context.annotation.Bean;
4. import org.springframework.context.annotation.Configuration;
5. import org.springframework.scheduling.TaskScheduler;
6. import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
8. /** TaskScheduler任务调度器配置类
9. * @since 2023/4/21 0021
10. * @author CC
11. **/
12. @Configuration
13. public class CronTaskConfig {
15.     /**
16.      * 任务调度器自定义配置
17.      */
18.     @Bean(name = "taskScheduler")
19.     public TaskScheduler taskScheduler() {
20.         // 任务调度线程池
21.         ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
22.         // 定时任务执行线程池核心线程数：可同时执行4个任务
23.         taskScheduler.setPoolSize(4);
24.         taskScheduler.setRemoveOnCancelPolicy(true);
25.         // 线程名称前缀
26.         taskScheduler.setThreadNamePrefix("Cs-ThreadPool-");
27.         return taskScheduler;
28.     }
30. }

复制代码

2、定时任务注册类

• 作用：缓存、注册定时任务；还可以查询、删除定时任务
  

1. package com.cc.ssd.registrar;
3. import com.cc.ssd.task.CronTaskFuture;
4. import com.cc.ssd.task.CronTaskRunnable;
5. import org.slf4j.Logger;
6. import org.slf4j.LoggerFactory;
7. import org.springframework.beans.BeanUtils;
8. import org.springframework.beans.factory.DisposableBean;
9. import org.springframework.scheduling.TaskScheduler;
10. import org.springframework.scheduling.config.CronTask;
11. import org.springframework.scheduling.support.CronExpression;
12. import org.springframework.stereotype.Component;
13. import org.springframework.util.Assert;
15. import javax.annotation.Resource;
16. import java.time.LocalDateTime;
17. import java.time.format.DateTimeFormatter;
18. import java.util.*;
19. import java.util.concurrent.ConcurrentHashMap;
20. import java.util.stream.Collectors;
22. /** 注册定时任务：缓存定时任务、注册定时任务到调度中心
23. * @author CC
24. **/
25. @Component
26. public class CronTaskRegistrar implements DisposableBean {
28.     private static final Logger log = LoggerFactory.getLogger(CronTaskRegistrar.class);
30.     /**
31.      * 缓存任务
32.      * key：具体的任务
33.      * value：注册定时任务后返回的ScheduledFuture
34.      */
35.     private final Map<Runnable, CronTaskFuture> scheduledTasks = new ConcurrentHashMap<>(16);
37.     /**
38.      * 使用自定义的任务调度配置
39.      */
40.     @Resource(name = "taskScheduler")
41.     private TaskScheduler taskScheduler;
43.     /** 获取任务调度配置
44.      * @return 任务调度配置
45.      */
46.     public TaskScheduler getTaskScheduler() {
47.         return this.taskScheduler;
48.     }
50.     /** 新增定时任务1
51.      *  存在任务：删除此任务，重新新增这个任务
52.      * @param taskRunnable 执行的具体任务定义：taskRunnable 实现Runnable
53.      * @param cronExpression cron表达式
54.      */
55.     public void addCronTask(Runnable taskRunnable, String cronExpression) {
56.         //验证cron表达式是否正确
57.         boolean validExpression = CronExpression.isValidExpression(cronExpression);
58.         if (!validExpression) {
59.             throw new RuntimeException("cron表达式验证失败！");
60.         }
61.         //获取下次执行时间
62.         CronExpression parse = CronExpression.parse(cronExpression);
63.         LocalDateTime next = parse.next(LocalDateTime.now());
64.         if (Objects.nonNull(next)) {
65.             //定时任务下次执行的时间
66.             String format = next.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
67.             log.info("定时任务下次执行的时间：{}", format);
68.         }
70.         //封装成 CronTask（cron任务）
71.         CronTask cronTask = new CronTask(taskRunnable, cronExpression);
72.         this.addCronTask(cronTask);
73.     }
75.     /** 新增定时任务2
76.      * @param cronTask ：<p>CronTask用于在指定时间间隔内执行定时任务。</p>
77.      *                   <p>它是通过CronTrigger来实现的，CronTrigger是一个基于cron表达式的触发器，</p>
78.      *                   <p>可以在指定的时间间隔内触发任务执行。</p>
79.      * @since 2023/4/21 0021
80.      * @author CC
81.      **/
82.     private void addCronTask(CronTask cronTask) {
83.         if (Objects.nonNull(cronTask)) {
84.             //1有这个任务，先删除这个任务。再新增
85.             Runnable task = cronTask.getRunnable();
86.             String taskId = null;
87.             if (task instanceof CronTaskRunnable) {
88.                 taskId = ((CronTaskRunnable) task).getTaskId();
89.             }
90.             //通过任务id获取缓存的任务，如果包含则删除，然后新增任务
91.             Runnable taskCache = this.getTaskByTaskId(taskId);
92.             if (Objects.nonNull(taskCache) && this.scheduledTasks.containsKey(taskCache)) {
93.                 this.removeCronTaskByTaskId(taskId);
94.             }
95.             //2注册定时任务到调度中心
96.             CronTaskFuture scheduledFutureTask = this.scheduleCronTask(cronTask);
98.             //3缓存定时任务
99.             this.scheduledTasks.put(task, scheduledFutureTask);
101.             //todo cc 4可以将任务保存到数据库中……重新启动程序然后加载数据库中的任务到缓存中……
103.         }
104.     }
106.     /** 注册 ScheduledTask 定时任务
107.      * @param cronTask cronTask
108.      * @return 注册定时任务后返回的 ScheduledFutureTask
109.      */
110.     private CronTaskFuture scheduleCronTask(CronTask cronTask) {
111.         //注册定时任务后记录的Future
112.         CronTaskFuture scheduledTask = new CronTaskFuture();
113.         //开启定时任务的真正方法
114.         scheduledTask.future = this.taskScheduler.schedule(cronTask.getRunnable(), cronTask.getTrigger());
115. //        scheduledTask.setThreadLocal(this.taskScheduler.schedule(cronTask.getRunnable(), cronTask.getTrigger()));
116.         return scheduledTask;
117.     }
119.     /** 获取任务列表
120.      * @return
121.      */
122.     public List<CronTaskRunnable> getScheduledTasks() {
123.         List<CronTaskRunnable> tasks = new ArrayList<>();
125.         Set<Runnable> keySet = scheduledTasks.keySet();
126.         keySet.forEach(key -> {
127.             CronTaskRunnable task = new CronTaskRunnable();
128.             if (key instanceof CronTaskRunnable) {
129.                 CronTaskRunnable taskParent = (CronTaskRunnable) key;
130.                 BeanUtils.copyProperties(taskParent, task);
131.             }
132.             tasks.add(task);
133.         });
135.         return tasks.stream()
136.                 .sorted(Comparator.comparing(CronTaskRunnable::getTaskId))
137.                 .collect(Collectors.toList());
138.     }
140.     /** 根据任务id删除单个定时任务
141.      * @param taskId 任务id
142.      */
143.     public void removeCronTaskByTaskId(String taskId) {
144.         //通过任务id获取任务
145.         Runnable task = this.getTaskByTaskId(taskId);
146.         //需要通过任务id获取任务，然后再移除
147.         CronTaskFuture cronTaskFuture = this.scheduledTasks.remove(task);
148.         if (Objects.nonNull(cronTaskFuture)) {
149.             cronTaskFuture.cancel();
150.         }
151.     }
153.     /** 通过任务id获取任务。未查询到返回null
154.      * @param taskId 任务id
155.      * @return java.lang.Runnable
156.      * @since 2023/4/21 0021
157.      * @author CC
158.      **/
159.     private Runnable getTaskByTaskId(String taskId) {
160.         Assert.notNull(taskId, "任务id不能为空！");
161.         Set<Map.Entry<Runnable, CronTaskFuture>> entries = scheduledTasks.entrySet();
162.         //根据任务id获取该任务缓存
163.         Map.Entry<Runnable, CronTaskFuture> rcf = entries.stream().filter(rf -> {
164.             Runnable key = rf.getKey();
165.             String taskId1 = null;
166.             if (key instanceof CronTaskRunnable) {
167.                 taskId1 = ((CronTaskRunnable) key).getTaskId();
168.             }
169.             return taskId.equals(taskId1);
170.         }).findAny().orElse(null);
172.         if (Objects.nonNull(rcf)) {
173.             return rcf.getKey();
174.         }
175.         return null;
176.     }
178.     /** 删除所有的定时任务
179.      *     DisposableBean是Spring框架中的一个接口，它定义了一个destroy()方法，
180.      *     用于在Bean销毁时执行清理工作。
181.      *     当一个Bean实现了DisposableBean接口时，
182.      *     Spring容器会在该Bean销毁时自动调用destroy()方法，
183.      *     以便进行一些清理工作，例如释放资源等。
184.      *     如果您的Bean需要在销毁时执行一些清理工作，
185.      *     那么实现DisposableBean接口是一个很好的选择。
186.      */
187.     @Override
188.     public void destroy() {
189.         //关闭所有定时任务
190.         for (CronTaskFuture task : this.scheduledTasks.values()) {
191.             task.cancel();
192.         }
193.         //清空缓存
194.         this.scheduledTasks.clear();
196.         log.info("取消所有定时任务！");
197.         //todo cc 修改或删除数据库的任务
198.     }
200. }

复制代码

3、定时任务的执行结果ScheduledFuture

• 作用：CronTaskFuture类中使用的是ScheduledFuture对象来表示定时任务的执行结果。
  

1. package com.cc.ssd.task;
3. import java.util.Objects;
4. import java.util.concurrent.ScheduledFuture;
6. /** CronTaskFuture类中使用的是ScheduledFuture对象来表示定时任务的执行结果。
7. *  ——最后ps：也可以不要这个记录类，直接缓存ScheduledFuture对象。
8. *  用来记录单独的Future、定时任务注册任务后产生的
9. * @author CC
10. **/
11. public final class CronTaskFuture {
13.     /** 每个线程一个副本
14.      * 经过测试这里不能使用ThreadLocal
15.      */
16. //    private static final ThreadLocal<ScheduledFuture<?>> THREAD_LOCAL = new ThreadLocal<>();
18.     /** 最后ps：由于ScheduledFuture是线程安全的。这里不用 volatile 或者 ThreadLocal
19.      *      注册任务后返回的：ScheduledFuture 用于记录并取消任务
20.      *      这两个都可以不使用。直接给future赋值
21.      *          volatile：线程之间可见：volatile用于实现多线程之间的可见性和一致性，保证数据的正确性。
22.      *          ThreadLocal：用于实现线程封闭，保证线程安全
23.      * 使用建议：
24.      *      CronTaskFuture类中使用的是ScheduledFuture对象来表示定时任务的执行结果。
25.      *      ScheduledFuture对象是线程安全的，因此不需要使用volatile关键字来保证多线程同步。
26.      *      如果需要在多线程中使用线程本地变量，可以使用ThreadLocal。
27.      *      因此，建议在CronTaskFuture类中使用ScheduledFuture对象，而不是使用volatile或ThreadLocal。
28.      *      另外，如果需要在Spring容器销毁时执行一些清理操作，可以实现DisposableBean接口，并在destroy()方法中进行清理操作。
29.      */
30.     public ScheduledFuture<?> future;
31. //    public volatile ScheduledFuture<?> future;
32. //    public void setThreadLocal(ScheduledFuture<?> future){
33. //        THREAD_LOCAL.set(future);
34. //    }
36.     /**
37.      * 取消当前定时任务
38.      */
39.     public void cancel() {
40.         try {
41. //            ScheduledFuture<?> future = THREAD_LOCAL.get();
42.             ScheduledFuture<?> future = this.future;
43.             if (Objects.nonNull(future)) {
44.                 future.cancel(true);
45.             }
46.         } catch (Exception e) {
47.             throw new RuntimeException("销毁定时任务失败！");
48.         } finally {
49. //            THREAD_LOCAL.remove();
50.         }
52.     }
54. }

复制代码

4、具体的任务。

• 实现Runable接口
  
• 任务处理的方式按照自己的需求去实现即可
  

1. package com.cc.ssd.task;
3. import lombok.Data;
4. import org.slf4j.Logger;
5. import org.slf4j.LoggerFactory;
6. import org.springframework.stereotype.Component;
8. /** 具体任务实现
9. * @author CC
10. * @since 2023/4/21 0021
11. */
12. @Data
13. public class CronTaskRunnable implements Runnable {
15.     private static final Logger log = LoggerFactory.getLogger(CronTaskRunnable.class);
17.     /**
18.      * 任务id（必须唯一）
19.      */
20.     private String taskId;
21.     /**
22.      * 任务类型：自定义
23.      */
24.     private Integer taskType;
25.     /**
26.      * 任务名字
27.      */
28.     private String taskName;
29.     /**
30.      * 任务参数
31.      */
32.     private Object[] params;
34.     public CronTaskRunnable() {
35.     }
37.     public CronTaskRunnable(String taskId, Integer taskType, String taskName, Object... params) {
38.         this.taskId = taskId;
39.         this.taskType = taskType;
40.         this.taskName = taskName;
41.         this.params = params;
42.     }
44.     /** 执行任务
45.      * @since 2023/4/21 0021
46.      * @author CC
47.      **/
48.     @Override
49.     public void run() {
50.         long start = System.currentTimeMillis();
52.         //具体的任务。
53.         log.info("\n\t {}号.定时任务开始执行 - taskId：{}，taskName：{}，taskType：{}，params：{}",
54.                 taskType, taskId, taskName, taskType, params);
56.         //任务处理的方式：
57.         //todo cc 1就在这里执行：模拟任务
58.         //todo cc 2开启策略模式，根据任务类型 调度不同的任务
59.         //todo cc 3使用反射：传来bean名字，方法名字，调用不同的任务
60.         //todo cc 4开启队列，把要执行的任务放到队列中，然后执行 —— 使用场景：每个任务执行很耗时的情况下使用
61.         try {
62.             Thread.sleep(1000);
63.         } catch (InterruptedException e) {
64.             throw new RuntimeException(e);
65.         }
67.         log.info("\n\t {}号.任务执行完成 - 耗时：{}，taskId：{}，taskType：{}",
68.                 taskType, System.currentTimeMillis() - start, taskId, taskType);
70.     }
73. }

复制代码

5、测试Controller

1. package com.cc.ssd.web.controller;
3. import com.cc.ssd.registrar.CronTaskRegistrar;
4. import com.cc.ssd.task.CronTaskRunnable;
5. import org.springframework.web.bind.annotation.*;
7. import javax.annotation.Resource;
8. import java.util.List;
9. import java.util.Map;
11. /**
12. * @author CC
13. * @since 2023/4/21 0021
14. */
15. @RestController
16. @RequestMapping("/scheduled")
17. public class TestScheduledController {
19.     @Resource
20.     private CronTaskRegistrar cronTaskRegistrar;
22.     /** 获取任务列表
23.      * @return java.util.List<com.cc.ssd.task.SchedulingRunnableTask>
24.      * @since 2023/4/21 0021
25.      * @author CC
26.      **/
27.     @GetMapping
28.     public List<CronTaskRunnable> getScheduledTasks() {
29.         return cronTaskRegistrar.getScheduledTasks();
30.     }
32.     /** 添加任务
33.      * @param param param
34.      * @return java.lang.String
35.      * @since 2023/4/21 0021
36.      * @author CC
37.      **/
38.     @PostMapping
39.     public String addCronTask(@RequestBody Map<String, Object> param) {
40.         //自己拿任务参数的逻辑：可以把每个任务保存到数据库，重新启动任务的同时，加载这些任务到任务调度中心
41.         String taskId = (String) param.get("taskId");
42.         Integer taskType = (Integer) param.get("taskType");
43.         String taskName = (String) param.get("taskName");
44.         Object params = param.get("params");
45.         //添加任务参数
46.         CronTaskRunnable task = new CronTaskRunnable(taskId, taskType, taskName, params);
47.         //注册任务：cron表达式，可以从传入不一样的
48.         cronTaskRegistrar.addCronTask(task, "0/5 * * * * ?");
49.         return "ok";
50.     }
52.     /** 根据任务id删除定时任务
53.      * @param taskId 任务id
54.      * @return java.lang.String
55.      * @since 2023/4/21 0021
56.      * @author CC
57.      **/
58.     @DeleteMapping
59.     public String removeCronTaskByTaskId(@RequestParam String taskId) {
60.         cronTaskRegistrar.removeCronTaskByTaskId(taskId);
61.         return "ok";
62.     }
64.     /** 删除全部任务
65.      * @return java.lang.String
66.      * @since 2023/4/21 0021
67.      * @author CC
68.      **/
69.     @DeleteMapping("/removeAll")
70.     public String removeCronTask() {
71.         cronTaskRegistrar.destroy();
72.         return "ok";
73.     }
75. }

复制代码

6、最后效果

• 自己用controller去测试一波吧
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！