Springboot集成Quartz动态配置定时任务

业务需求：

业务需要设置某项目预警，要求预警周期可以根据具体需求进行修改。例如每天触发一次、每周触发一次。

正文

1. 创建定时任务Bean；用于方便动态从数据库中获取cron表达式，具体字段可根据需求变更。

public class QuartzBean {

    private Integer id; //任务id

    private String jobClass; //任务执行类

    private String cronExpression; //cron表达式

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getJobClass() {
        return jobClass;
    }

    public void setJobClass(String jobClass) {
        this.jobClass = jobClass;
    }

    public String getCronExpression() {
        return cronExpression;
    }

    public void setCronExpression(String cronExpression) {
        this.cronExpression = cronExpression;
    }
}

2.创建工具类；

public class QuartzUtils {

    private final static Logger logger = LoggerFactory.getLogger(QuartzUtils.class);

    /**
     * 创建定时任务类 定时任务创建后默认状态为启动
     * @param scheduler 调度器
     * @param quartzBean 定时任务信息类
     */
    public static void createScheduleJob(Scheduler scheduler,QuartzBean quartzBean) {
        try {
            //获取定时任务的执行类，定时任务类需要job类的具体实现，QuartzJobBean是job的抽象类
            Class<? extends Job> jobClass = (Class<? extends Job>) Class.forName(quartzBean.getJobClass());

            //构建定时任务信息
            JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(quartzBean.getJobName()).build();

            //设置定时任务执行方式(获取cronExpression)
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(quartzBean.getCronExpression());

            //构建触发器
            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(quartzBean.getJobName()).withSchedule(scheduleBuilder).build();

            scheduler.scheduleJob(jobDetail,trigger);
        } catch (Exception e) {
            e.printStackTrace();
            logger.info("创建定时任务失败："+e.getMessage());
        }
    }

    /**
     * 暂停定时任务
     * @param scheduler
     * @param jobName
     */
    public static void pauseScheduleJob(Scheduler scheduler,String jobName) {
        JobKey jobKey = JobKey.jobKey(jobName);
        try {
            scheduler.pauseJob(jobKey);
        } catch (Exception e) {
            e.printStackTrace();
            logger.info("暂停定时任务失败："+e.getMessage());
        }
    }

    /**
     * 恢复定时任务
     * @param scheduler
     * @param jobName
     */
    public static void resumeScheduleJob(Scheduler scheduler,String jobName) {
        JobKey jobKey = JobKey.jobKey(jobName);
        try {
            scheduler.resumeJob(jobKey);
        } catch (Exception e) {
            e.printStackTrace();
            logger.info("恢复定时任务失败："+e.getMessage());
        }
    }

    /**
     * 更新定时任务
     * @param scheduler
     * @param quartzBean
     */
    public static void updateScheduleJob(Scheduler scheduler, QuartzBean quartzBean) {
        try {
            //根据jobName获取对应任务的触发器
            TriggerKey triggerKey = TriggerKey.triggerKey(quartzBean.getJobName());
            //获取cron表达式
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(quartzBean.getCronExpression());
            //重新构建任务触发器
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
            //重置对应的job
            scheduler.rescheduleJob(triggerKey,trigger);
        } catch (Exception e) {
            e.printStackTrace();
            logger.info("更新定时任务失败："+e.getMessage());
        }
    }

    /**
     * 删除定时任务
     * @param scheduler
     * @param jobName
     */
    public static void deleteScheduleJob(Scheduler scheduler,String jobName) {
        JobKey jobKey = JobKey.jobKey(jobName);
        try {
            scheduler.deleteJob(jobKey);
        } catch (Exception e) {
            e.printStackTrace();
            logger.info("删除定时任务失败："+e.getMessage());
        }
    }
}

3. 创建测试类；

public class TestQuartz extends QuartzJobBean {
    @Override
    protected void executeIternal(JobExecutionContext context) throws JobExecutionException {
    	//此处添加具体的业务逻辑
        System.err.println("定时任务开始执行"+new Date()+"\n");
    }
}

4. 创建测试Controller；

@Controller
@RequestMapping("/quartz/")
public class QuartzController {
    //注入任务调度
    @Autowired
    private Scheduler scheduler;

    @RequestMapping("/createJob")
    @ResponseBody
    public String  createJob(QuartzBean quartzBean)  {
        try {
            //进行测试所以写死
            quartzBean.setJobClass("com.devplatform.bidding.test.TestQuartz"); //class路径需要填写绝对路径
            quartzBean.setCronExpression("9 */1 * * * ?"); //此处cron表达式可以通过调用接口的方式从数据库中获取
            QuartzUtils.createScheduleJob(scheduler,quartzBean);
        } catch (Exception e) {
            return "创建失败";
        }
        return "创建成功";
    }

    @RequestMapping("/pauseJob")
    @ResponseBody
    public String  pauseJob(@RequestBody String jobName)  {
        try {
            QuartzUtils.pauseScheduleJob (scheduler,jobName);
        } catch (Exception e) {
            return "暂停失败";
        }
        return "暂停成功";
    }

    @RequestMapping("/resume")
    @ResponseBody
    public String  resume(@RequestBody String jobName)  {
        try {
            QuartzUtils.resumeScheduleJob(scheduler,jobName);
        } catch (Exception e) {
            return "启动失败";
        }
        return "启动成功";
    }

    @RequestMapping("/update")
    @ResponseBody
    public String  update(QuartzBean quartzBean)  {
        try {
            //进行测试所以写死
            quartzBean.setJobClass("com.devplatform.bidding.test.TestQuartz");
            quartzBean.setCronExpression("*/30 * * * * ?");
            QuartzUtils.updateScheduleJob(scheduler,quartzBean);
        } catch (Exception e) {
            return "启动失败";
        }
        return "启动成功";
    }
}

6.项目启动之后调用createJob接口，会立刻运行定时任务，需要切换定时任务周期，只需在数据库中插入对应cron表达式，执行update接口就行。