SpringBoot集成Quartz实现定时任务

SpringBoot集成Quartz实现定时任务

0 59 2 ? * FRI    每周5凌晨2点59分触发；MON、THU、WED、THU、FRI、SAT、SUN
0 0 10 * * ?  每天早上10:00触发

linux中crontab每10秒执行一次 * * * * * sleep 10; /usr/bin/curl www.baidu.com

数据库表

初始化加载数据库里正常的定时任务
https://mp.weixin.qq.com/s/D2WDNCBuqSbTSuY8TkjPqA

import cn.alm.manage.business.dao.master.SysTaskDao;
import cn.alm.manage.business.model.SysTask;
import cn.alm.manage.business.service.DevCommandService;
import cn.alm.manage.common.model.DevCommand;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.Trigger;
import org.springframework.scheduling.TriggerContext;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.support.CronTrigger;

import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.atomic.AtomicInteger;

@EnableScheduling
@Configuration
public class SysTaskScheduleService {
    @Resource private ThreadPoolTaskScheduler threadPoolTaskScheduler;
    @Resource private SysTaskDao sysTaskDao;
    @Resource private DevCommandService devCommandService;
    
    public Map<Integer, ScheduledFuture<?>> futureMap = new ConcurrentHashMap<>();

    @Scheduled(cron = "0/12 * * * * *")
    public void getScheduleFromDB(){

        List<SysTask> taskList = sysTaskDao.findAll();
        for(SysTask task : taskList){
            if(task.isOpen())
            {
                boolean add = this.addTask(task);
                if(add){
                    logger.info("t:{}, add new task to schedule, size:{}", Thread.currentThread().getId(), futureMap.size());
                }
            }
        }}

    //添加一个动态任务
    public boolean addTask(SysTask task){
        int taskId = task.id;
        if(futureMap.get(taskId) != null){ return false;//stopTask(taskId);
        }
        if(Misc.trim(task.commandIds) == null){ return false;
        }
        String[] cmdIds = task.commandIds.split(","); //执行完1指令再执行3指令
        if(cmdIds.length == 0){
            logger.info("指令不能为null");
            return false;
        }
        // schedule :调度给定的Runnable ，在指定的执行时间调用它。一旦调度程序关闭或返回的ScheduledFuture被取消，执行将结束。
        //参数：任务 – 触发器触发时执行的 Runnable
        ScheduledFuture<?> scheduledFuture = threadPoolTaskScheduler.schedule(this.getRunnable(task), this.getTrigger(task.cron));
        futureMap.put(taskId, scheduledFuture);
        return true;
    }

    public Runnable getRunnable(SysTask task){
        AtomicInteger count = new AtomicInteger();
        String[] cmdIds = task.commandIds.split(Misc.COMMA);
        return () -> {
            for (String cmdId : cmdIds)
            {
                int cid = Misc.int0(cmdId);
                if(cid == 0)
                    continue;
                DevCommand cmd = devCommandService.findById(cid);
                if(cmd == null)
                    continue;
                String message = devCommandService.generateDevMeterInstruction(task.deviceId, cmd.command);
                boolean result = devCommandService.sendMessage(task.deviceId, message);
                logger.info("t:{}, result:{}-{}, cmdId:{}, task:{}, message:{}", Thread.currentThread().getId(), result, count.get(), cmdId, task, message);
                if(!result){
                    logger.info("t:{} 发送失败，清除一个任务", Thread.currentThread().getId());
                    this.stopTask(task.id);
                    return;
                }
                try {
                    if(task.interval < 1000)
                        task.interval = 1000;
                    Thread.sleep(task.interval);
                } catch (Exception e) { logger.error("thread stop exception"); return; }
            }
            this.stopTask(task.id);
        };
    }

    public Trigger getTrigger(String cron){
        return new Trigger() {
            @Override
            public Date nextExecutionTime(TriggerContext triggerContext) {
                CronTrigger trigger = new CronTrigger(cron);
                Date nextExec = trigger.nextExecutionTime(triggerContext);
                return nextExec;
            }
        };
    }

    /** 停止任务. */
    public boolean stopTask(int id){
        ScheduledFuture<?> sf = futureMap.get(id);
        if(sf == null){
            return false;
        }
        sf.cancel(true);
        futureMap.remove(id);
        logger.info("t:{} -----end-----", Thread.currentThread().getId());
        return true;
    }
}

参考地址

Spring boot定时任务及集成Quartz
https://blog.csdn.net/qq_27046951/article/details/82805259

quartz定时任务时间设置
https://blog.csdn.net/a1015088819/article/details/41866621

Spring Boot 定时任务，怎么实现任务动态增删启停？
https://mp.weixin.qq.com/s/D2WDNCBuqSbTSuY8TkjPqA