关于使用quartz动态增删改定时任务

1. 首先, 还是喜闻乐见的导包

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

2. 处理schedule工具

package com.hoolink.schedule.util;

import com.hoolink.sdk.bo.device.ScreenPlayScheduleBO;
import com.hoolink.sdk.utils.JSONUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.quartz.*;

import java.time.LocalDate;
import java.util.List;

/**
 * @author <a herf="mailto:yanwu0527@163.com">XuBaofeng</a>
 * @date 2019-05-31 17:29.
 * <p>
 * description:
 * DisallowConcurrentExecution:     不允许并发执行
 */
@Slf4j
@DisallowConcurrentExecution
public class ScreenPlayUtil {

    /**
     * 批量创建定时任务
     *
     * @param scheduler
     * @param screens
     */
    public static void createAll(Scheduler scheduler, List<ScreenPlayScheduleBO> screens) {
        if (CollectionUtils.isEmpty(screens)) {
            return;
        }
        screens.forEach(screen -> {
            createJob(scheduler, screen);
        });
    }

    /**
     * 添加一个定时任务
     *
     * @param scheduler 调度器
     * @param screen    任务
     */
    public static void createJob(Scheduler scheduler, ScreenPlayScheduleBO screen) {
        try {
            log.info("create job, time: {}, screen: {}", LocalDate.now(), screen);
            Class<? extends Job> clazz = (Class<? extends Job>) Class.forName(screen.getClassName());
            JobDataMap jobDataMap = new JobDataMap(JSONUtils.stringToMap(JSONUtils.toJSONString(screen)));
            // 任务名，任务组，任务执行类
            JobDetail jobDetail = JobBuilder.newJob(clazz).withIdentity(screen.getJobName(), screen.getJobGroup())
                    .withDescription("定时任务").setJobData(jobDataMap).build();
            // 触发器名,触发器组
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(screen.getCronExpression())
                    .withMisfireHandlingInstructionDoNothing();
            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(screen.getTriggerName(), screen.getTriggerGroup())
                    .withDescription(screen.getDescription()).withSchedule(scheduleBuilder).startNow().build();
            // 触发器时间设定
            scheduler.scheduleJob(jobDetail, trigger);
            // 启动
            if (!scheduler.isShutdown()) {
                startJobs(scheduler);
            }
        } catch (Exception e) {
            log.error("create schedule job error", e);
        }
    }

    /**
     * 批量更新定时任务
     *
     * @param scheduler
     * @param screens
     */
    public static void updateAll(Scheduler scheduler, List<ScreenPlayScheduleBO> screens) {
        if (CollectionUtils.isEmpty(screens)) {
            return;
        }
        screens.forEach(screen -> {
            updateJob(scheduler, screen);
        });
    }

    /**
     * 修改一个任务的触发时间
     *
     * @param scheduler
     * @param screen
     */
    public static void updateJob(Scheduler scheduler, ScreenPlayScheduleBO screen) {
        try {
            log.info("update job, time: {}, screen:{}", LocalDate.now(), screen);
            TriggerKey triggerKey = new TriggerKey(screen.getTriggerName(), screen.getTriggerGroup());
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            if (trigger == null) {
                createJob(scheduler, screen);
                return;
            }
            String cron = trigger.getCronExpression();
            if (!cron.equalsIgnoreCase(screen.getCronExpression())) {
                removeJob(scheduler, screen);
                createJob(scheduler, screen);
            }
        } catch (Exception e) {
            log.error("update schedule job error", e);
        }
    }

    /**
     * 清除所有的定时任务
     *
     * @param scheduler
     */
    public static void removeAll(Scheduler scheduler) {
        try {
            log.info("remove all schedule job, time: {}", LocalDate.now());
            scheduler.clear();
        } catch (Exception e) {
            log.error("remove all schedule job error.", e);
        }
    }

    /**
     * 批量清除指定的定时任务
     *
     * @param scheduler
     */
    public static void removeAll(Scheduler scheduler, List<ScreenPlayScheduleBO> screens) {
        if (CollectionUtils.isEmpty(screens)) {
            return;
        }
        screens.forEach(screen -> {
            removeJob(scheduler, screen);
        });
    }

    /**
     * 移除一个任务
     *
     * @param scheduler
     * @param screen
     */
    public static void removeJob(Scheduler scheduler, ScreenPlayScheduleBO screen) {
        try {
            log.info("remove job, time: {}, screen:{}", LocalDate.now(), screen);
            JobKey jobKey = new JobKey(screen.getJobName(), screen.getJobGroup());
            TriggerKey triggerKey = new TriggerKey(screen.getTriggerName(), screen.getTriggerGroup());
            // 停止触发器
            scheduler.pauseTrigger(triggerKey);
            // 移除触发器
            scheduler.unscheduleJob(triggerKey);
            // 删除任务
            scheduler.deleteJob(jobKey);
        } catch (Exception e) {
            log.error("remove schedule job error", e);
        }
    }

    /**
     * 启动所有定时任务
     *
     * @param scheduler 调度器
     */
    public static void startJobs(Scheduler scheduler) {
        try {
            log.info("start schedule job, time: {}", LocalDate.now());
            scheduler.start();
        } catch (Exception e) {
            log.error("start schedule job error", e);
        }
    }

    /**
     * 关闭所有定时任务
     *
     * @param scheduler 调度器
     */
    public static void shutdownJobs(Scheduler scheduler) {
        try {
            log.info("shutdown schedule job, time: {}", LocalDate.now());
            if (!scheduler.isShutdown()) {
                scheduler.shutdown();
            }
        } catch (Exception e) {
            log.error("shutdown schedule job error", e);
        }
    }

}

3. BO

package com.hoolink.sdk.bo.device;

import lombok.Data;

import java.io.Serializable;

/**
 * @author <a herf="mailto:yanwu0527@163.com">XuBaofeng</a>
 * @date 2019-05-31 17:31.
 * <p>
 * description:
 */
@Data
public class ScreenPlayScheduleBO implements Serializable {
    private static final long serialVersionUID = 4226193119686522141L;

    private Long configId;

    /*** 执行任务的类名称 */
    private String className;

    /*** 定时任务表达式 */
    private String cronExpression;

    /*** 任务名称 */
    private String jobName;

    /*** 任务分组 */
    private String jobGroup;

    /*** 触发器名称 */
    private String triggerName;

    /*** 触发器分组 */
    private String triggerGroup;

    /*** 任务描述 */
    private String description;

    /*** 创建时间 */
    private Long createTime;

    /*** 定时任务任务ID */
    private Long playId;

    /*** 开启关闭(0:关闭;1:开启) */
    private Boolean playStatus;
}

5. 处理定时任务

package com.hoolink.schedule.job;

import com.hoolink.schedule.consumer.ScreenClient;
import com.hoolink.sdk.bo.device.ScreenPlayScheduleBO;
import com.hoolink.sdk.utils.JSONUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.servicecomb.foundation.common.utils.BeanUtils;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import java.time.LocalDateTime;

/**
 * @author <a herf="mailto:yanwu0527@163.com">XuBaofeng</a>
 * @date 2019-05-31 17:29.
 * <p>
 * description:
 * DisallowConcurrentExecution:     不允许并发执行
 */
@Slf4j
@DisallowConcurrentExecution
public class ScreenPlayJob implements Job {

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        JobDataMap jobDataMap = context.getMergedJobDataMap();
        ScreenPlayScheduleBO mediaTaskBO = JSONUtils.parse(JSONUtils.toJSONString(jobDataMap), ScreenPlayScheduleBO.class);
        log.info("screen play control job start, time: {} param: {}", LocalDateTime.now(), mediaTaskBO);
        ScreenClient screenClient = BeanUtils.getContext().getBean(ScreenClient.class);
        screenClient.playControl(mediaTaskBO);
    }

}

6. 调用schedule工具

package com.hoolink.schedule.controller;

import com.hoolink.schedule.util.ScreenPlayUtil;
import com.hoolink.sdk.annotation.LogAndParam;
import com.hoolink.sdk.bo.BackBO;
import com.hoolink.sdk.bo.device.ScreenPlayScheduleBO;
import com.hoolink.sdk.utils.BackBOUtil;
import io.swagger.annotations.ApiOperation;
import org.apache.servicecomb.provider.rest.common.RestSchema;
import org.quartz.Scheduler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * @author <a herf="mailto:yanwu0527@163.com">XuBaofeng</a>
 * @date 2019-06-01 14:59.
 * <p>
 * description:
 */
@RestController
@RequestMapping("/screen/play/")
@RestSchema(schemaId = "screenPlayController")
public class ScreenPlayController {
    @Autowired
    private Scheduler scheduler;

    @PostMapping(value = "create")
    @ApiOperation(value = "创建定时任务")
    @LogAndParam(value = "创建定时任务失败")
    public BackBO<Void> create(@RequestBody ScreenPlayScheduleBO screen) {
        ScreenPlayUtil.createJob(scheduler, screen);
        return BackBOUtil.defaultBackBO();
    }

    @PostMapping(value = "createAll")
    @ApiOperation(value = "批量创建定时任务")
    @LogAndParam(value = "批量定时任务失败")
    public BackBO<Void> createAll(@RequestBody List<ScreenPlayScheduleBO> screens) {
        ScreenPlayUtil.createAll(scheduler, screens);
        return BackBOUtil.defaultBackBO();
    }

    @PostMapping(value = "update")
    @ApiOperation(value = "更新定时任务")
    @LogAndParam(value = "更新定时任务失败")
    public BackBO<Void> update(@RequestBody ScreenPlayScheduleBO screen) {
        ScreenPlayUtil.updateJob(scheduler, screen);
        return BackBOUtil.defaultBackBO();
    }

    @PostMapping(value = "updateAll")
    @ApiOperation(value = "更新定时任务")
    @LogAndParam(value = "更新定时任务失败")
    public BackBO<Void> updateAll(@RequestBody List<ScreenPlayScheduleBO> screens) {
        ScreenPlayUtil.updateAll(scheduler, screens);
        return BackBOUtil.defaultBackBO();
    }

    @PostMapping(value = "remove")
    @ApiOperation(value = "删除定时任务")
    @LogAndParam(value = "删除定时任务失败")
    public BackBO<Void> remove(@RequestBody ScreenPlayScheduleBO screen) {
        ScreenPlayUtil.removeJob(scheduler, screen);
        return BackBOUtil.defaultBackBO();
    }

    @PostMapping(value = "deleteAll")
    @ApiOperation(value = "清除所有的定时任务")
    @LogAndParam(value = "清除所有的定时任务失败")
    public BackBO<Void> deleteAll() {
        ScreenPlayUtil.removeAll(scheduler);
        return BackBOUtil.defaultBackBO();
    }

    @PostMapping(value = "removeAll")
    @ApiOperation(value = "清除所有的定时任务")
    @LogAndParam(value = "清除所有的定时任务失败")
    public BackBO<Void> removeAll(@RequestBody List<ScreenPlayScheduleBO> screens) {
        ScreenPlayUtil.removeAll(scheduler, screens);
        return BackBOUtil.defaultBackBO();
    }

}