SpringBoot动态定时任务

import cn.hutool.core.convert.ConverterRegistry;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledFuture;

/**
 * @author crush
 */
@Component
@Slf4j
public class DynamicTaskService {

    /**
     * 以下两个都是线程安全的集合类。
     */
    public Map<String, ScheduledFuture<?>> oneTaskMap = new ConcurrentHashMap<>();
    public Map<String,ScheduledFuture> cronTaskMap=new ConcurrentHashMap<>();

    private final ThreadPoolTaskScheduler syncScheduler;

    public DynamicTaskService(ThreadPoolTaskScheduler syncScheduler) {
        this.syncScheduler = syncScheduler;
    }

    /**
     * 添加一个动态任务
     *
     * @param task
     * @return
     */
    public boolean add(RechargeTask task) {
        // 此处的逻辑是 ，如果当前已经有这个名字的任务存在，先删除之前的，再添加现在的。（即重复就覆盖）
        if (null != oneTaskMap.get(task.getName())) {
            stop(task.getName());
        }

        // hutool 工具包下的一个转换类型工具类 好用的很
        ConverterRegistry converterRegistry = ConverterRegistry.getInstance();
        String start=task.getStart();
        Date startTime=new Date();
        if(start!=null){
            startTime = converterRegistry.convert(Date.class, task.getStart());
        }

        // schedule :调度给定的Runnable ，在指定的执行时间调用它。
        //一旦调度程序关闭或返回的ScheduledFuture被取消，执行将结束。
        //参数：
        //任务 – 触发器触发时执行的 Runnable
        //startTime – 任务所需的执行时间（如果这是过去，则任务将立即执行，即尽快执行）
        ScheduledFuture<?> schedule = syncScheduler.schedule(getRunnable(task), startTime);
        oneTaskMap.put(task.getName(), schedule);
        return true;
    }


    /**
     * 运行任务
     *
     * @param task
     * @return
     */
    public Runnable getRunnable(RechargeTask task) {
        return () -> {
            log.info("---动态定时任务运行---");
            try {
                // 查询是否有定时任务
                String taskName=task.getName();
                ScheduledFuture<?> cronFuture=cronTaskMap.get(taskName);
                if(cronFuture!=null){
                    cronFuture.cancel(true);
                }
                cronFuture = syncScheduler.schedule(task, new CronTrigger(task.getCron())); // 重新启动任务
                cronTaskMap.put(taskName,cronFuture);

            } catch (Exception e) {
                e.printStackTrace();
                log.error("getRunnable",e);
            }
            log.info("---end--------");
        };
    }

    /**
     * 停止任务
     *
     * @param name
     * @return
     */
    public boolean stop(String name) {
        if (null == oneTaskMap.get(name)) {
            return false;
        }
        // 删除一次定时任务
        ScheduledFuture<?> scheduledFuture = oneTaskMap.get(name);
        scheduledFuture.cancel(true);
        oneTaskMap.remove(name);
        // 删除多次定时任务
        scheduledFuture = cronTaskMap.get(name);
        scheduledFuture.cancel(true);
        cronTaskMap.remove(name);
        return true;
    }