关于使用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();
     }

 }