【ThreadPoolTaskScheduler实现动态定时任务添加、删除、修改】

总体设计

在Springboot项目中使用ThreadPoolTaskScheduler添加定时任务，结合Cron表达式来实现

注册 ThreadPoolTaskScheduler

在配置文件中添加如下代码，并开启@EnableAsync 注解启动异步线程池

    @Bean
    @ConditionalOnMissingBean(ThreadPoolTaskScheduler.class)
    public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
        ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
        threadPoolTaskScheduler.setPoolSize(5);                        // 线程池大小,根据实际需要添加
        threadPoolTaskScheduler.setThreadNamePrefix("taskScheduler-");   // 线程名称
        threadPoolTaskScheduler.setAwaitTerminationSeconds(600);         // 等待时长
        // 调度器shutdown被调用时等待当前被调度的任务完成
        threadPoolTaskScheduler.setWaitForTasksToCompleteOnShutdown(false); 
        return threadPoolTaskScheduler;
    }

创建具体任务的执行对象 BaskTask

/**
 * 基础任务接口
 *
 * @author ryenlii
 */
public interface BaskTask extends Runnable {

    /**
     * 获取执行频率
     */
    String getCron();

    /**
     * 获取执行对象名称
     */
    String getName();

    /**
     * 执行任务逻辑
     */
    void execute();
}

创建定时任务处理中心 ScheduledTaskManager

import XXXX.ScheduledTask;
import XXXX.BaskTask;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 动态添加任务配置
 *
 * @author ryenlii
 */
@Slf4j
@Component
public class ScheduledTaskManager {

    /**
     * 以下都是线程安全的集合类。
     */
    private final Map<String, ScheduledTask> scheduledTasks = new ConcurrentHashMap<>();

    @Resource
    private ThreadPoolTaskScheduler syncScheduler;

    /**
     * 添加一个动态任务。
     *
     * @param task 要添加的任务对象。
     * @return 添加成功返回true，否则返回false。
     */
    public boolean add(BaskTask task) {
        // 记录任务总数。
        log.info("任务总数: {}", scheduledTasks.keySet());

        String taskName = task.getName();
        // 优化查找性能
        if (scheduledTasks.containsKey(taskName)) {
            updateCron(taskName, task.getCron());
        } else {
            // 新增
            addTask(taskName, task);
        }
        return true;
    }


    /**
     * 添加一个新的定时任务
     *
     * @param name 任务名称
     * @param task 定时任务（Runnable对象）
     */
    public void addTask(String name, BaskTask task) {
        if (scheduledTasks.containsKey(name)) {
            throw new IllegalArgumentException("A task with the same name already exists: " + name);
        }

        ScheduledTask scheduledTask = new ScheduledTask(syncScheduler, task);
        scheduledTask.schedule();
        scheduledTasks.put(name, scheduledTask);

        log.info("定时任务{}已成功创建，Cron表达式：{}", name, task.getCron());
    }

    /**
     * 更新已安排任务的Cron表达式
     *
     * @param name              任务名称
     * @param newCronExpression 新的Cron表达式
     */
    public void updateCron(String name, String newCronExpression) {
        ScheduledTask scheduledTask = scheduledTasks.get(name);
        if (scheduledTask == null) {
            throw new IllegalArgumentException("No scheduled task found with the given name: " + name);
        }

        scheduledTask.updateCronExpression(newCronExpression);

        log.info("定时任务{}的Cron表达式已成功更新为：{}", name, newCronExpression);
    }

    /**
     * 停止并移除一个定时任务
     *
     * @param name 任务名称
     */
    public void stopTask(String name) {
        ScheduledTask scheduledTask = scheduledTasks.remove(name);
        if (scheduledTask != null) {
            scheduledTask.cancel();
            log.info("定时任务{}已成功停止", name);
        } else {
            log.warn("尝试停止的任务{}不存在", name);
        }
    }

}

创建任务处理ScheduledTask

import XXX.BaskTask;
import cn.hutool.core.date.DateUtil;
import cn.hutool.log.Log;
import cn.hutool.log.LogFactory;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.scheduling.support.CronTrigger;

import java.util.Date;
import java.util.concurrent.ScheduledFuture;

/**
 * 定时任务处理对象
 *
 * @author ryenlii
 */
public class ScheduledTask {
    private final Log log = LogFactory.get();
    private final BaskTask task;
    private String cronExpression;
    private ScheduledFuture<?> scheduledFuture;
    private final TaskScheduler taskScheduler;

    public ScheduledTask(TaskScheduler taskScheduler, BaskTask task) {
        this.taskScheduler = taskScheduler;
        this.task = task;
        this.cronExpression = task.getCron();
    }

    public void schedule() {
        this.scheduledFuture = taskScheduler.schedule(task, scheduledConfig -> {
            Date nextExecutionTime = new CronTrigger(cronExpression).nextExecutionTime(scheduledConfig);
            log.info("{}执行定时任务【{}】的时间:{}", task.getName(), cronExpression, DateUtil.formatDateTime(nextExecutionTime));
            return nextExecutionTime;
        });
    }

    public void updateCronExpression(String newCronExpression) {
        cancel();
        this.cronExpression = newCronExpression;
        schedule();
    }

    public void cancel() {
        if (this.scheduledFuture != null) {
            this.scheduledFuture.cancel(false);
        }
    }

}

项目启动后执行定时任务

此处针对某些单独执行的任务，进行手动添加，也可以通过获取Spring的对象，批量添加

import XXX.BaskTask;
import XXX.DataCrawlerTask;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.core.annotation.Order;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.stereotype.Component;


@Order(-1)
@Component
@SuppressWarnings("all")
@Slf4j
@EnableScheduling
public class ScheduleRunner implements ApplicationRunner {

    @Autowired
    private ScheduledTaskManager task;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        // 爬取标准信息
        BaskTask baskTask = new DataCrawlerTask();
        task.add(baskTask);
    }

}

批量添加

import ……

public class ScheduleRunner implements ApplicationRunner {
    @Autowired
    private ApplicationContext applicationContext;

    @Autowired
    private ScheduledTaskManager task;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        // 获取所有的定时任务
        Map<String, BaskTask> map = applicationContext.getBeansOfType(BaskTask.class);

        // 遍历注册
        for (String key : map.keySet()) {
            // baskTask:回调内部的run方法
            BaskTask baskTask = map.get(key);
            // 立即执行
            // baskTask.execute();
            task.add(baskTask);
        }
    }
}