SpringBoot 动态可配定时任务可实现不重启管理任务（动态定时任务）
本文主要介绍了SpringBoot架构下动态定时任务的使用，定时任务表达式配置在数据库中，其它项目架构也可以借鉴，实现思路是一样的。
支持查看任务状态，动态修改任务时间，停止任务等；
注：文章尾部附源码地址
1.前置准备
1.1创建任务表
CREATE TABLE `scheduled_task` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`task_key` varchar(128) NOT NULL COMMENT '任务key值（使用bean名称）',
`task_desc` varchar(128) DEFAULT NULL COMMENT '任务描述',
`task_cron` varchar(128) NOT NULL COMMENT '任务表达式',
`init_start_flag` int(2) NOT NULL DEFAULT '1' COMMENT '程序初始化是否启动 1 是 0 否',
`create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uniqu_task_key` (`task_key`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;
1.2添加初始化测试数据
INSERT INTO `cron`.`scheduled_task`(`id`, `task_key`, `task_desc`, `task_cron`, `init_start_flag`, `create_time`, `update_time`) VALUES (1, 'scheduledTask01', '定时任务01', '0/5 * * * * ?', 1, NOW(), NOW());
INSERT INTO `cron`.`scheduled_task`(`id`, `task_key`, `task_desc`, `task_cron`, `init_start_flag`, `create_time`, `update_time`) VALUES (2, 'scheduledTask02', '定时任务02', '0/2 * * * * ?', 0, NOW(), NOW());
INSERT INTO `cron`.`scheduled_task`(`id`, `task_key`, `task_desc`, `task_cron`, `init_start_flag`, `create_time`, `update_time`) VALUES (3, 'scheduledTask03', '定时任务03', '0/2 * * * * ?', 1, NOW(), NOW());
1.3创建Maven项目并添加Maven依赖
<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-parentartifactId>
<version>1.5.12.RELEASEversion>
parent>
<properties>
<fastjson.version>1.2.47fastjson.version>
<mybatis-spring-boot.version>1.3.1mybatis-spring-boot.version>
<mybatis-spring-boot-starter.version>1.3.0mybatis-spring-boot-starter.version>
<mybatis-plus.version>2.1-gammamybatis-plus.version>
<druid.version>1.1.2druid.version>
properties>
<dependencies>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.mybatis.spring.bootgroupId>
<artifactId>mybatis-spring-boot-starterartifactId>
<version>${mybatis-spring-boot.version}version>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<scope>runtimescope>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
<dependency>
<groupId>com.alibabagroupId>
<artifactId>fastjsonartifactId>
<version>${fastjson.version}version>
dependency>
dependencies>
1.4添加配置文件application.properties
server.port=8081
spring.datasource.url:jdbc:mysql://localhost:3306/cron?useSSL=false
spring.datasource.username:root
spring.datasource.password:root
1.5添加SpringBoot启动类
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
2.任务调度
2.1创建定时任务线程池,初始化任务Map
注：任务map，后续使用具体讲解
import com.scheduled.dynamic.enums.ScheduledTaskEnum;
import com.scheduled.dynamic.service.ScheduledTaskJob;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import java.util.Map;
@Configuration
public class ScheduledTaskConfig {
/**
* 日志
*/
private static final Logger LOGGER = LoggerFactory.getLogger(ScheduledTaskConfig.class);
@Bean
public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
LOGGER.info("创建定时任务调度线程池 start");
ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
threadPoolTaskScheduler.setPoolSize(20);
threadPoolTaskScheduler.setThreadNamePrefix("taskExecutor-");
threadPoolTaskScheduler.setWaitForTasksToCompleteOnShutdown(true);
threadPoolTaskScheduler.setAwaitTerminationSeconds(60);
LOGGER.info("创建定时任务调度线程池 end");
return threadPoolTaskScheduler;
}
/**
* 初始化定时任务Map
* key :任务key
* value : 执行接口实现
*/
@Bean(name = "scheduledTaskJobMap")
public Map<String, ScheduledTaskJob> scheduledTaskJobMap() {
return ScheduledTaskEnum.initScheduledTask();
}
}
2.2创建任务实体Bean
public class ScheduledTaskBean {
/**
* 任务key值 唯一
*/
private String taskKey;
/**
* 任务描述
*/
private String taskDesc;
/**
* 任务表达式
*/
private String taskCron;
/**
* 程序初始化是否启动 1 是 0 否
*/
private Integer initStartFlag;
/**
* 当前是否已启动
*/
private boolean startFlag;
//省略 get/set
2.3Mapper接口
/**
* 定时任务表 mapper
* demo 项目未使用 xml方式，使用注解方式查询数据以便演示
*/
@Mapper
public interface ScheduledTaskMapper {
/**
* 根据key 获取 任务信息
*/
@Select("select task_key as taskKey,task_desc as taskDesc,task_cron as taskCron,init_start_flag as initStartFlag from scheduled_task where task_key = '${taskKey}' ")
ScheduledTaskBean getByKey(@Param("taskKey") String taskKey);
/**
* 获取程序初始化需要自启的任务信息
*/
@Select("select task_key as taskKey,task_desc as taskDesc,task_cron as taskCron,init_start_flag as initStartFlag from scheduled_task where init_start_flag=1 ")
List<ScheduledTaskBean> getAllNeedStartTask();
/**
* 获取所有任务
*/
@Select("select task_key as taskKey,task_desc as taskDesc,task_cron as taskCron,init_start_flag as initStartFlag from scheduled_task ")
List<ScheduledTaskBean> getAllTask();
}
2.4创建调度任务公共父接口
/**
* 调度任务公共父接口
*/
public interface ScheduledTaskJob extends Runnable {
}
2.5实现父接口，重写run方法
注：ScheduledTask02与ScheduledTask03与当前ScheduledTask01 一致，不再重复写，复制几个即可
import com.scheduled.dynamic.service.ScheduledTaskJob;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 任务 01
*/
public class ScheduledTask01 implements ScheduledTaskJob {
/**
* 日志
*/
private static final Logger LOGGER = LoggerFactory.getLogger(ScheduledTask01.class);
@Override
public void run() {
LOGGER.info("ScheduledTask => 01 run 当前线程名称 {} ", Thread.currentThread().getName());
}
}
2.6创建定时任务枚举类
注：方便管理任务
import com.scheduled.dynamic.service.ScheduledTaskJob;
import com.scheduled.dynamic.task.*;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* 定时任务枚举值
* 注：key 需要与数据库保持一致
*/
public enum ScheduledTaskEnum {
/**
* 任务1
*/
TASK_01("scheduledTask01", new ScheduledTask01()),
/**
* 任务2
*/
TASK_02("scheduledTask02", new ScheduledTask02()),
/**
* 任务3
*/
TASK_03("scheduledTask03", new ScheduledTask03()),
;
/**
* 定时任务key
*/
private String taskKey;
/**
* 定时任务 执行实现类
*/
private ScheduledTaskJob scheduledTaskJob;
ScheduledTaskEnum(String taskKey, ScheduledTaskJob scheduledTaskJob) {
this.taskKey = taskKey;
this.scheduledTaskJob = scheduledTaskJob;
}
/**
* 初始化 所有任务
*/
public static Map<String, ScheduledTaskJob> initScheduledTask() {
if (ScheduledTaskEnum.values().length < 0) {
return new ConcurrentHashMap<>();
}
Map<String, ScheduledTaskJob> scheduledTaskJobMap = new ConcurrentHashMap<>();
for (ScheduledTaskEnum taskEnum : ScheduledTaskEnum.values()) {
scheduledTaskJobMap.put(taskEnum.taskKey, taskEnum.scheduledTaskJob);
}
return scheduledTaskJobMap;
}
}
2.7功能核心接口
/**
* 定时任务接口
*/
public interface ScheduledTaskService {
/**
* 所有任务列表
*/
List<ScheduledTaskBean> taskList();
/**
* 根据任务key 启动任务
*/
Boolean start(String taskKey);
/**
* 根据任务key 停止任务
*/
Boolean stop(String taskKey);
/**
* 根据任务key 重启任务
*/
Boolean restart(String taskKey);
/**
* 程序启动时初始化 ==> 启动所有正常状态的任务
*/
void initAllTask(List<ScheduledTaskBean> scheduledTaskBeanList);
}
/**
* 定时任务实现
*/
@Service
public class ScheduledTaskServiceImpl implements ScheduledTaskService {
/**
* 日志
*/
private static final Logger LOGGER = LoggerFactory.getLogger(ScheduledTaskServiceImpl.class);
@Autowired
private ScheduledTaskMapper taskMapper;
/**
* 可重入锁
*/
private ReentrantLock lock = new ReentrantLock();
/**
* 定时任务线程池
*/
@Autowired
private ThreadPoolTaskScheduler threadPoolTaskScheduler;
/**
* 所有定时任务存放Map
* key :任务 key
* value:任务实现
*/
@Autowired
@Qualifier(value = "scheduledTaskJobMap")
private Map<String, ScheduledTaskJob> scheduledTaskJobMap;
/**
* 存放已经启动的任务map
*/
private Map<String, ScheduledFuture> scheduledFutureMap = new ConcurrentHashMap<>();
/**
* 所有任务列表
*/
@Override
public List<ScheduledTaskBean> taskList() {
LOGGER.info(">>>>>> 获取任务列表开始 >>>>>> ");
//数据库查询所有任务 => 未做分页
List<ScheduledTaskBean> taskBeanList = taskMapper.getAllTask();
if (CollectionUtils.isEmpty(taskBeanList)) {
return new ArrayList<>();
}
for (ScheduledTaskBean taskBean : taskBeanList) {
String taskKey = taskBean.getTaskKey();
//是否启动标记处理
taskBean.setStartFlag(this.isStart(taskKey));
}
LOGGER.info(">>>>>> 获取任务列表结束 >>>>>> ");
return taskBeanList;
}
/**
* 根据任务key 启动任务
*/
@Override
public Boolean start(String taskKey) {
LOGGER.info(">>>>>> 启动任务 {} 开始 >>>>>>", taskKey);
//添加锁放一个线程启动，防止多人启动多次
lock.lock();
LOGGER.info(">>>>>> 添加任务启动锁完毕");
try {
//校验是否已经启动
if (this.isStart(taskKey)) {
LOGGER.info(">>>>>> 当前任务已经启动，无需重复启动！");
return false;
}
//校验任务是否存在
if (!scheduledTaskJobMap.containsKey(taskKey)) {
return false;
}
//根据key数据库获取任务配置信息
ScheduledTaskBean scheduledTask = taskMapper.getByKey(taskKey);
//启动任务
this.doStartTask(scheduledTask);
} finally {
// 释放锁
lock.unlock();
LOGGER.info(">>>>>> 释放任务启动锁完毕");
}
LOGGER.info(">>>>>> 启动任务 {} 结束 >>>>>>", taskKey);
return true;
}
/**
* 根据 key 停止任务
*/
@Override
public Boolean stop(String taskKey) {
LOGGER.info(">>>>>> 进入停止任务 {} >>>>>>", taskKey);
//当前任务实例是否存在
boolean taskStartFlag = scheduledFutureMap.containsKey(taskKey);
LOGGER.info(">>>>>> 当前任务实例是否存在 {}", taskStartFlag);
if (taskStartFlag) {
//获取任务实例
ScheduledFuture scheduledFuture = scheduledFutureMap.get(taskKey);
//关闭实例
scheduledFuture.cancel(true);
}
LOGGER.info(">>>>>> 结束停止任务 {} >>>>>>", taskKey);
return taskStartFlag;
}
/**
* 根据任务key 重启任务
*/
@Override
public Boolean restart(String taskKey) {
LOGGER.info(">>>>>> 进入重启任务 {} >>>>>>", taskKey);
//先停止
this.stop(taskKey);
//再启动
return this.start(taskKey);
}
/**
* 程序启动时初始化 ==> 启动所有正常状态的任务
*/
@Override
public void initAllTask(List<ScheduledTaskBean> scheduledTaskBeanList) {
LOGGER.info("程序启动 ==> 初始化所有任务开始 ！size={}", scheduledTaskBeanList.size());
if (CollectionUtils.isEmpty(scheduledTaskBeanList)) {
return;
}
for (ScheduledTaskBean scheduledTask : scheduledTaskBeanList) {
//任务 key
String taskKey = scheduledTask.getTaskKey();
//校验是否已经启动
if (this.isStart(taskKey)) {
continue;
}
//启动任务
this.doStartTask(scheduledTask);
}
LOGGER.info("程序启动 ==> 初始化所有任务结束 ！size={}", scheduledTaskBeanList.size());
}
/**
* 执行启动任务
*/
private void doStartTask(ScheduledTaskBean scheduledTask) {
//任务key
String taskKey = scheduledTask.getTaskKey();
//定时表达式
String taskCron = scheduledTask.getTaskCron();
//获取需要定时调度的接口
ScheduledTaskJob scheduledTaskJob = scheduledTaskJobMap.get(taskKey);
LOGGER.info(">>>>>> 任务 [ {} ] ,cron={}", scheduledTask.getTaskDesc(), taskCron);
ScheduledFuture scheduledFuture = threadPoolTaskScheduler.schedule(scheduledTaskJob,
new Trigger() {
@Override
public Date nextExecutionTime(TriggerContext triggerContext) {
CronTrigger cronTrigger = new CronTrigger(taskCron);
return cronTrigger.nextExecutionTime(triggerContext);
}
});
//将启动的任务放入 map
scheduledFutureMap.put(taskKey, scheduledFuture);
}
/**
* 任务是否已经启动
*/
private Boolean isStart(String taskKey) {
//校验是否已经启动
if (scheduledFutureMap.containsKey(taskKey)) {
if (!scheduledFutureMap.get(taskKey).isCancelled()) {
return true;
}
}
return false;
}
}
2.8 定时任务Controller
/**
* 定时任务 controller
*/
@RestController
@RequestMapping("/scheduled")
public class ScheduledController {
@Autowired
private ScheduledTaskService scheduledTaskService;
/**
* 所有任务列表
*/
@RequestMapping("/taskList")
public List<ScheduledTaskBean> taskList() {
return scheduledTaskService.taskList();
}
/**
* 根据任务key => 启动任务
*/
@RequestMapping("/start")
public String start(@RequestParam("taskKey") String taskKey) {
scheduledTaskService.start(taskKey);
return "start success";
}
/**
* 根据任务key => 停止任务
*/
@RequestMapping("/stop")
public String stop(@RequestParam("taskKey") String taskKey) {
scheduledTaskService.stop(taskKey);
return "stop success";
}
/**
* 根据任务key => 重启任务
*/
@RequestMapping("/restart")
public String restart(@RequestParam("taskKey") String taskKey) {
scheduledTaskService.restart(taskKey);
return "restart success";
}
}
效果图示
截止到这来，已经可以实现，动态管理任务了，包括动态修改启动表达式，停止任务，启动任务，重启任务等。
但是，还有一个问题，项目重启后，需要人工来启动需要启动的任务。
。。。
2.9实现项目启动时自启动
注：SpringBoot给我们提供了两个接口来帮助我们实现这种需求。这两个接口分别为CommandLineRunner和ApplicationRunner。他们的执行时机为容器启动完成的时候。
/**
* @see @Order注解的执行优先级是按value值从小到大顺序。
* 项目启动完毕后开启需要自启的任务
*/
@Component
@Order(value = 1)
public class ScheduledTaskRunner implements ApplicationRunner {
/**
* 日志
*/
private static final Logger LOGGER = LoggerFactory.getLogger(ScheduledTaskRunner.class);
@Autowired
private ScheduledTaskMapper taskMapper;
@Autowired
private ScheduledTaskService scheduledTaskService;
/**
* 程序启动完毕后,需要自启的任务
*/
@Override
public void run(ApplicationArguments applicationArguments) throws Exception {
LOGGER.info(" >>>>>> 项目启动完毕, 开启 => 需要自启的任务 开始!");
List<ScheduledTaskBean> scheduledTaskBeanList = taskMapper.getAllNeedStartTask();
scheduledTaskService.initAllTask(scheduledTaskBeanList);
LOGGER.info(" >>>>>> 项目启动完毕, 开启 => 需要自启的任务 结束！");
}
}
到这里，动态定时任务已经很完美了
总结
优点：动态启动任务，修改任务间隔时间
缺点：分布式多机部署，也只能实现对某一台机器的任务做动态处理，因为启动的定时任务，放在当前机器内存中了，欢迎大家一起优化！
源码地址：
https://github.com/mengq0815/spring-boot-example/tree/master/spring-boot-scheduled-task