SpringBoot自定义cron表达式注册定时任务
一、原理
- 1、使用Spring自带的TaskScheduler注册任务
- 2、注册后返回：ScheduledFuture，用于取消定时任务
- 3、注册任务后不会马上取消任务，所以将任务缓存。在需要取消任务的时候调用取消接口取消
- 4、cron表达式可以由前端或者后端生成。实现中会校验cron表达式
public class TestScheduled {
/**
* 1、使用Spring自带的TaskScheduler注册任务
* 2、注册后返回：ScheduledFuture，用于取消定时任务
*/
@Resource
private TaskScheduler taskScheduler;
public void registrarTask() {
//具体的任务Runnable（一般使用类实现Runnable接口）
Runnable taskRunnable = new Runnable() {
@Override
public void run() {
}
};
//cron表达式触发器
CronTrigger trigger = new CronTrigger("0/5 * * * * ?");
//开启定时任务的真正方法
ScheduledFuture future = this.taskScheduler.schedule(taskRunnable, trigger);
//取消定时任务
future.cancel(true);
}
}
二、具体实现
1、配置任务调度器
- 作用：设置：核心线程数：可同时执行任务数；设置线程名称前缀
- 可以不配置。不配置就默认使用spring自带的
package com.cc.ssd.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
/** TaskScheduler任务调度器配置类
* @since 2023/4/21 0021
* @author CC
**/
@Configuration
public class CronTaskConfig {
/**
* 任务调度器自定义配置
*/
@Bean(name = "taskScheduler")
public TaskScheduler taskScheduler() {
// 任务调度线程池
ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
// 定时任务执行线程池核心线程数：可同时执行4个任务
taskScheduler.setPoolSize(4);
taskScheduler.setRemoveOnCancelPolicy(true);
// 线程名称前缀
taskScheduler.setThreadNamePrefix("Cs-ThreadPool-");
return taskScheduler;
}
}
2、定时任务注册类
- 作用：缓存、注册定时任务；还可以查询、删除定时任务
package com.cc.ssd.registrar;
import com.cc.ssd.task.CronTaskFuture;
import com.cc.ssd.task.CronTaskRunnable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.scheduling.config.CronTask;
import org.springframework.scheduling.support.CronExpression;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;
import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
/** 注册定时任务：缓存定时任务、注册定时任务到调度中心
* @author CC
**/
@Component
public class CronTaskRegistrar implements DisposableBean {
private static final Logger log = LoggerFactory.getLogger(CronTaskRegistrar.class);
/**
* 缓存任务
* key：具体的任务
* value：注册定时任务后返回的ScheduledFuture
*/
private final Map scheduledTasks = new ConcurrentHashMap<>(16);
/**
* 使用自定义的任务调度配置
*/
@Resource(name = "taskScheduler")
private TaskScheduler taskScheduler;
/** 获取任务调度配置
* @return 任务调度配置
*/
public TaskScheduler getTaskScheduler() {
return this.taskScheduler;
}
/** 新增定时任务1
* 存在任务：删除此任务，重新新增这个任务
* @param taskRunnable 执行的具体任务定义：taskRunnable 实现Runnable
* @param cronExpression cron表达式
*/
public void addCronTask(Runnable taskRunnable, String cronExpression) {
//验证cron表达式是否正确
boolean validExpression = CronExpression.isValidExpression(cronExpression);
if (!validExpression) {
throw new RuntimeException("cron表达式验证失败！");
}
//获取下次执行时间
CronExpression parse = CronExpression.parse(cronExpression);
LocalDateTime next = parse.next(LocalDateTime.now());
if (Objects.nonNull(next)) {
//定时任务下次执行的时间
String format = next.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
log.info("定时任务下次执行的时间：{}", format);
}
//封装成 CronTask（cron任务）
CronTask cronTask = new CronTask(taskRunnable, cronExpression);
this.addCronTask(cronTask);
}
/** 新增定时任务2
* @param cronTask ：CronTask用于在指定时间间隔内执行定时任务。
* 它是通过CronTrigger来实现的，CronTrigger是一个基于cron表达式的触发器，
* 可以在指定的时间间隔内触发任务执行。
* @since 2023/4/21 0021
* @author CC
**/
private void addCronTask(CronTask cronTask) {
if (Objects.nonNull(cronTask)) {
//1有这个任务，先删除这个任务。再新增
Runnable task = cronTask.getRunnable();
String taskId = null;
if (task instanceof CronTaskRunnable) {
taskId = ((CronTaskRunnable) task).getTaskId();
}
//通过任务id获取缓存的任务，如果包含则删除，然后新增任务
Runnable taskCache = this.getTaskByTaskId(taskId);
if (Objects.nonNull(taskCache) && this.scheduledTasks.containsKey(taskCache)) {
this.removeCronTaskByTaskId(taskId);
}
//2注册定时任务到调度中心
CronTaskFuture scheduledFutureTask = this.scheduleCronTask(cronTask);
//3缓存定时任务
this.scheduledTasks.put(task, scheduledFutureTask);
//todo cc 4可以将任务保存到数据库中……重新启动程序然后加载数据库中的任务到缓存中……
}
}
/** 注册 ScheduledTask 定时任务
* @param cronTask cronTask
* @return 注册定时任务后返回的 ScheduledFutureTask
*/
private CronTaskFuture scheduleCronTask(CronTask cronTask) {
//注册定时任务后记录的Future
CronTaskFuture scheduledTask = new CronTaskFuture();
//开启定时任务的真正方法
scheduledTask.future = this.taskScheduler.schedule(cronTask.getRunnable(), cronTask.getTrigger());
// scheduledTask.setThreadLocal(this.taskScheduler.schedule(cronTask.getRunnable(), cronTask.getTrigger()));
return scheduledTask;
}
/** 获取任务列表
* @return
*/
public List getScheduledTasks() {
List tasks = new ArrayList<>();
Set keySet = scheduledTasks.keySet();
keySet.forEach(key -> {
CronTaskRunnable task = new CronTaskRunnable();
if (key instanceof CronTaskRunnable) {
CronTaskRunnable taskParent = (CronTaskRunnable) key;
BeanUtils.copyProperties(taskParent, task);
}
tasks.add(task);
});
return tasks.stream()
.sorted(Comparator.comparing(CronTaskRunnable::getTaskId))
.collect(Collectors.toList());
}
/** 根据任务id删除单个定时任务
* @param taskId 任务id
*/
public void removeCronTaskByTaskId(String taskId) {
//通过任务id获取任务
Runnable task = this.getTaskByTaskId(taskId);
//需要通过任务id获取任务，然后再移除
CronTaskFuture cronTaskFuture = this.scheduledTasks.remove(task);
if (Objects.nonNull(cronTaskFuture)) {
cronTaskFuture.cancel();
}
}
/** 通过任务id获取任务。未查询到返回null
* @param taskId 任务id
* @return java.lang.Runnable
* @since 2023/4/21 0021
* @author CC
**/
private Runnable getTaskByTaskId(String taskId) {
Assert.notNull(taskId, "任务id不能为空！");
Set> entries = scheduledTasks.entrySet();
//根据任务id获取该任务缓存
Map.Entry rcf = entries.stream().filter(rf -> {
Runnable key = rf.getKey();
String taskId1 = null;
if (key instanceof CronTaskRunnable) {
taskId1 = ((CronTaskRunnable) key).getTaskId();
}
return taskId.equals(taskId1);
}).findAny().orElse(null);
if (Objects.nonNull(rcf)) {
return rcf.getKey();
}
return null;
}
/** 删除所有的定时任务
* DisposableBean是Spring框架中的一个接口，它定义了一个destroy()方法，
* 用于在Bean销毁时执行清理工作。
* 当一个Bean实现了DisposableBean接口时，
* Spring容器会在该Bean销毁时自动调用destroy()方法，
* 以便进行一些清理工作，例如释放资源等。
* 如果您的Bean需要在销毁时执行一些清理工作，
* 那么实现DisposableBean接口是一个很好的选择。
*/
@Override
public void destroy() {
//关闭所有定时任务
for (CronTaskFuture task : this.scheduledTasks.values()) {
task.cancel();
}
//清空缓存
this.scheduledTasks.clear();
log.info("取消所有定时任务！");
//todo cc 修改或删除数据库的任务
}
}
3、定时任务的执行结果ScheduledFuture
- 作用：CronTaskFuture类中使用的是ScheduledFuture对象来表示定时任务的执行结果。
package com.cc.ssd.task;
import java.util.Objects;
import java.util.concurrent.ScheduledFuture;
/** CronTaskFuture类中使用的是ScheduledFuture对象来表示定时任务的执行结果。
* ——最后ps：也可以不要这个记录类，直接缓存ScheduledFuture对象。
* 用来记录单独的Future、定时任务注册任务后产生的
* @author CC
**/
public final class CronTaskFuture {
/** 每个线程一个副本
* 经过测试这里不能使用ThreadLocal
*/
// private static final ThreadLocal> THREAD_LOCAL = new ThreadLocal<>();
/** 最后ps：由于ScheduledFuture是线程安全的。这里不用 volatile 或者 ThreadLocal
* 注册任务后返回的：ScheduledFuture 用于记录并取消任务
* 这两个都可以不使用。直接给future赋值
* volatile：线程之间可见：volatile用于实现多线程之间的可见性和一致性，保证数据的正确性。
* ThreadLocal：用于实现线程封闭，保证线程安全
* 使用建议：
* CronTaskFuture类中使用的是ScheduledFuture对象来表示定时任务的执行结果。
* ScheduledFuture对象是线程安全的，因此不需要使用volatile关键字来保证多线程同步。
* 如果需要在多线程中使用线程本地变量，可以使用ThreadLocal。
* 因此，建议在CronTaskFuture类中使用ScheduledFuture对象，而不是使用volatile或ThreadLocal。
* 另外，如果需要在Spring容器销毁时执行一些清理操作，可以实现DisposableBean接口，并在destroy()方法中进行清理操作。
*/
public ScheduledFuture future;
// public volatile ScheduledFuture future;
// public void setThreadLocal(ScheduledFuture future){
// THREAD_LOCAL.set(future);
// }
/**
* 取消当前定时任务
*/
public void cancel() {
try {
// ScheduledFuture future = THREAD_LOCAL.get();
ScheduledFuture future = this.future;
if (Objects.nonNull(future)) {
future.cancel(true);
}
} catch (Exception e) {
throw new RuntimeException("销毁定时任务失败！");
} finally {
// THREAD_LOCAL.remove();
}
}
}
4、具体的任务。
- 实现Runable接口
- 任务处理的方式按照自己的需求去实现即可
package com.cc.ssd.task;
import lombok.Data;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
/** 具体任务实现
* @author CC
* @since 2023/4/21 0021
*/
@Data
public class CronTaskRunnable implements Runnable {
private static final Logger log = LoggerFactory.getLogger(CronTaskRunnable.class);
/**
* 任务id（必须唯一）
*/
private String taskId;
/**
* 任务类型：自定义
*/
private Integer taskType;
/**
* 任务名字
*/
private String taskName;
/**
* 任务参数
*/
private Object[] params;
public CronTaskRunnable() {
}
public CronTaskRunnable(String taskId, Integer taskType, String taskName, Object... params) {
this.taskId = taskId;
this.taskType = taskType;
this.taskName = taskName;
this.params = params;
}
/** 执行任务
* @since 2023/4/21 0021
* @author CC
**/
@Override
public void run() {
long start = System.currentTimeMillis();
//具体的任务。
log.info("\n\t {}号.定时任务开始执行 - taskId：{}，taskName：{}，taskType：{}，params：{}",
taskType, taskId, taskName, taskType, params);
//任务处理的方式：
//todo cc 1就在这里执行：模拟任务
//todo cc 2开启策略模式，根据任务类型 调度不同的任务
//todo cc 3使用反射：传来bean名字，方法名字，调用不同的任务
//todo cc 4开启队列，把要执行的任务放到队列中，然后执行 —— 使用场景：每个任务执行很耗时的情况下使用
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
log.info("\n\t {}号.任务执行完成 - 耗时：{}，taskId：{}，taskType：{}",
taskType, System.currentTimeMillis() - start, taskId, taskType);
}
}
5、测试Controller
package com.cc.ssd.web.controller;
import com.cc.ssd.registrar.CronTaskRegistrar;
import com.cc.ssd.task.CronTaskRunnable;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
/**
* @author CC
* @since 2023/4/21 0021
*/
@RestController
@RequestMapping("/scheduled")
public class TestScheduledController {
@Resource
private CronTaskRegistrar cronTaskRegistrar;
/** 获取任务列表
* @return java.util.List
* @since 2023/4/21 0021
* @author CC
**/
@GetMapping
public List getScheduledTasks() {
return cronTaskRegistrar.getScheduledTasks();
}
/** 添加任务
* @param param param
* @return java.lang.String
* @since 2023/4/21 0021
* @author CC
**/
@PostMapping
public String addCronTask(@RequestBody Map param) {
//自己拿任务参数的逻辑：可以把每个任务保存到数据库，重新启动任务的同时，加载这些任务到任务调度中心
String taskId = (String) param.get("taskId");
Integer taskType = (Integer) param.get("taskType");
String taskName = (String) param.get("taskName");
Object params = param.get("params");
//添加任务参数
CronTaskRunnable task = new CronTaskRunnable(taskId, taskType, taskName, params);
//注册任务：cron表达式，可以从传入不一样的
cronTaskRegistrar.addCronTask(task, "0/5 * * * * ?");
return "ok";
}
/** 根据任务id删除定时任务
* @param taskId 任务id
* @return java.lang.String
* @since 2023/4/21 0021
* @author CC
**/
@DeleteMapping
public String removeCronTaskByTaskId(@RequestParam String taskId) {
cronTaskRegistrar.removeCronTaskByTaskId(taskId);
return "ok";
}
/** 删除全部任务
* @return java.lang.String
* @since 2023/4/21 0021
* @author CC
**/
@DeleteMapping("/removeAll")
public String removeCronTask() {
cronTaskRegistrar.destroy();
return "ok";
}
}
6、最后效果
- 自己用controller去测试一波吧
