Spring Boot 动态定时任务管理系统（轻量级实现）

Spring Boot项目中，实现动态增删和启停定时任务的功能对于许多应用场景来说至关重要。固然Quartz框架是一个广泛利用的解决方案，但其复杂性和重量级特性可能使得项目变得痴肥和难以维护。为了解决这个问题，本项目旨在实现一个轻量级的定时任务管理系统，不依赖外部框架，仅利用Spring Boot和Java尺度库的功能，特别实用于单体项目。

数据库

1. DROP TABLE IF EXISTS `scheduled_jobs`;
2. CREATE TABLE `scheduled_jobs`  (
3.   `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '任务ID，唯一标识每个定时任务',
4.   `method_name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '方法名称，执行定时任务时调用的方法名',
5.   `cron_expression` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT 'cron表达式，定义定时任务的执行时间规则',
6.   `status` int(11) NOT NULL DEFAULT 1 COMMENT '任务状态，1为正常运行，0为暂停',
7.   `content` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL DEFAULT '1' COMMENT '任务正文，具体需要执行的内筒',
8.   `remark` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '任务的备注信息，描述任务的其他细节',
9.   `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '任务创建时间，自动设置为当前时间',
10.   `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '任务最后更新时间，每次更新时自动更新时间',
11.   PRIMARY KEY (`id`) USING BTREE
12. ) ENGINE = InnoDB AUTO_INCREMENT = 1391804419 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;

复制代码

POM依赖

1.   <dependency>
2.             <groupId>org.springframework.boot</groupId>
3.             <artifactId>spring-boot-starter-jdbc</artifactId>
4.         </dependency>
5.         <dependency>
6.             <groupId>org.springframework.boot</groupId>
7.             <artifactId>spring-boot-starter-web</artifactId>
8.         </dependency>
11.         <!-- mybatis-plus -->
12.         <dependency>
13.             <groupId>com.baomidou</groupId>
14.             <artifactId>mybatis-plus-boot-starter</artifactId>
15.             <version>3.5.9</version>
16.         </dependency>
18.         <!--lombok依赖-->
19.         <dependency>
20.             <groupId>org.projectlombok</groupId>
21.             <artifactId>lombok</artifactId>
22.             <optional>true</optional>
23.         </dependency>
25.         <!--MySQL数据库的依赖-->
26.         <dependency>
27.             <groupId>mysql</groupId>
28.             <artifactId>mysql-connector-java</artifactId>
29.             <version>8.0.33</version>
30.         </dependency>
32.         <!--hutool工具依赖-->
33.         <dependency>
34.             <groupId>cn.hutool</groupId>
35.             <artifactId>hutool-all</artifactId>
36.             <version>5.8.26</version>
37.         </dependency>

复制代码

项目启动类

1. import org.mybatis.spring.annotation.MapperScan;
2. import org.springframework.boot.SpringApplication;
3. import org.springframework.boot.autoconfigure.SpringBootApplication;
5. @SpringBootApplication
6. @MapperScan("com.sws.dynamicscheduler.mapper")
7. public class DynamicSchedulerApplication {
9.     public static void main(String[] args) {
10.         SpringApplication.run(DynamicSchedulerApplication.class, args);
11.     }
13. }

复制代码

任务管理器类

1. import com.sws.dynamicscheduler.mapper.ScheduledJobMapper;
2. import com.sws.dynamicscheduler.model.ScheduledJob;
3. import lombok.extern.slf4j.Slf4j;
4. import org.springframework.beans.factory.annotation.Autowired;
5. import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
6. import org.springframework.scheduling.support.CronTrigger;
7. import org.springframework.stereotype.Service;
9. import javax.annotation.PostConstruct;
10. import java.util.HashMap;
11. import java.util.List;
12. import java.util.Map;
13. import java.util.Optional;
14. import java.util.concurrent.ScheduledFuture;
16. @Service
17. @Slf4j
18. public class DynamicTaskManager {
20.     private final ThreadPoolTaskScheduler taskScheduler;
21.     private final ScheduledJobMapper scheduledJobMapper;
22.     private final Map<String, ScheduledFuture<?>> scheduledTasks;
24.     @Autowired
25.     public DynamicTaskManager(ScheduledJobMapper scheduledJobMapper, ThreadPoolTaskScheduler taskScheduler) {
26.         this.scheduledJobMapper = scheduledJobMapper;
27.         this.taskScheduler = taskScheduler;
28.         this.scheduledTasks = new HashMap<>();
29.     }
32.     @PostConstruct
33.     public void init() {
34.         // 初始化时加载数据库中的所有定时任务并调度
35.         List<ScheduledJob> jobs = scheduledJobMapper.selectList(null);
36.         for (ScheduledJob job : jobs) {
37.             if (job.getStatus() == 1) {
38.                 addTask(job.getCronExpression(), job.getMethodName(),job.getContent(), job.getId().toString());
39.             }
40.         }
41.     }
43.     // 动态新增任务
44.     public String addTask(String cronExpression, String methodName, String content,String taskId) {
45.         Runnable task = () -> {
46.             // 执行定时任务的逻辑
47.            log.info("执行了定时任务：{},执行内容是：{}",methodName,content);
48.         };
50.         ScheduledFuture<?> scheduledFuture = taskScheduler.schedule(task, new CronTrigger(cronExpression));
51.         scheduledTasks.put(taskId, scheduledFuture);
52.         return taskId;
53.     }
55.     // 动态删除任务
56.     public void removeTask(String taskId) {
57.         ScheduledFuture<?> scheduledFuture = scheduledTasks.get(taskId);
58.         if (scheduledFuture != null) {
59.             scheduledFuture.cancel(false); // 取消任务
60.             scheduledTasks.remove(taskId); // 从集合中删除
61.         }
62.     }
64.     // 停止任务
65.     public void stopTask(Integer jobId) {
66.         Optional<ScheduledJob> jobOptional = Optional.ofNullable(scheduledJobMapper.selectById(jobId));
67.         jobOptional.ifPresent(job -> {
68.             job.setStatus(0); // 设置为暂停状态
69.             scheduledJobMapper.insert(job);
70.             removeTask(jobId.toString()); // 停止定时任务
71.         });
72.     }
74.     // 恢复任务
75.     public void resumeTask(Integer jobId) {
76.         Optional<ScheduledJob> jobOptional = Optional.ofNullable(scheduledJobMapper.selectById(jobId));
77.         jobOptional.ifPresent(job -> {
78.             job.setStatus(1); // 设置为正常状态
79.             scheduledJobMapper.insert(job);
80.             addTask(job.getCronExpression(), job.getMethodName(), job.getContent(),jobId.toString()); // 恢复定时任务
81.         });
82.     }
83. }

复制代码

实体类

1. import com.baomidou.mybatisplus.annotation.TableName;
2. import lombok.Data;
5. import java.util.Date;
7. @Data
8. @TableName("`scheduled_jobs`")
9. public class ScheduledJob {
11.     private Integer id;                // 任务ID，唯一标识每个定时任务
12.     private String methodName;         // 方法名称，执行定时任务时调用的方法名
13.     private String cronExpression;    // cron表达式，定义定时任务的执行时间规则
14.     private Integer status;            // 任务状态，1为正常运行，0为暂停
15.     private String content;           // 任务正文，具体需要执行的内容
16.     private String remark;             // 任务的备注信息，描述任务的其他细节
17.     private Date createTime;           // 任务创建时间，自动设置为当前时间
18.     private Date updateTime;           // 任务最后更新时间，每次更新时自动更新时间
21. }

复制代码

设置类

1. import org.springframework.context.annotation.Bean;
2. import org.springframework.context.annotation.Configuration;
3. import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
5. @Configuration
6. public class SchedulerConfig {
8.     @Bean
9.     public ThreadPoolTaskScheduler taskScheduler() {
10.         ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
11.         scheduler.setPoolSize(10); // 设置线程池的大小
12.         scheduler.setThreadNamePrefix("scheduled-task-"); // 设置线程名称前缀
13.         return scheduler;
14.     }
15. }

复制代码

Mapper类

1. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
2. import com.sws.dynamicscheduler.model.ScheduledJob;
4. public interface ScheduledJobMapper extends BaseMapper<ScheduledJob> {
6. }

复制代码

控制类

1. import com.sws.dynamicscheduler.model.ScheduledJob;
2. import com.sws.dynamicscheduler.mapper.ScheduledJobMapper;
3. import com.sws.dynamicscheduler.scheduler.DynamicTaskManager;
4. import org.springframework.web.bind.annotation.*;
6. import javax.annotation.Resource;
7. import java.util.List;
9. @RestController
10. @RequestMapping("/tasks")
11. public class TaskController {
13.     @Resource
14.     DynamicTaskManager taskManager;
16.     @Resource
17.     ScheduledJobMapper scheduledJobMapper;
20.     // 动态添加任务
21.     @PostMapping("/add")
22.     public String addTask(@RequestParam String cronExpression, @RequestParam String methodName,@RequestParam String content) {
23.         ScheduledJob job = new ScheduledJob();
24.         job.setMethodName(methodName);
25.         job.setContent(content);
26.         job.setCronExpression(cronExpression);
27.         job.setStatus(1);
28.         scheduledJobMapper.insert(job); // 保存到数据库
30.         // 添加定时任务
31.         return taskManager.addTask(cronExpression, methodName,content,job.getId().toString());
32.     }
34.     // 动态删除任务
35.     @DeleteMapping("/remove")
36.     public void removeTask(@RequestParam Integer jobId) {
37.         taskManager.removeTask(jobId.toString());
38.         scheduledJobMapper.deleteById(jobId);
39.     }
41.     // 暂停任务
42.     @PostMapping("/pause")
43.     public void pauseTask(@RequestParam Integer jobId) {
44.         taskManager.stopTask(jobId);
45.     }
47.     // 恢复任务
48.     @PostMapping("/resume")
49.     public void resumeTask(@RequestParam Integer jobId) {
50.         taskManager.resumeTask(jobId);
51.     }
53.     // 获取所有任务
54.     @GetMapping("/all")
55.     public List<ScheduledJob> getAllTasks() {
56.         return scheduledJobMapper.selectList(null);
57.     }
58. }

复制代码

项目地点：神蛐/DynamicScheduler

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。