SpringBoot整合Quartz，用于动态修改执行策略

SpringBoot整合Quartz，用于动态修改执行策略

第一步 引入依赖

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

第二步 创建一个定时任务

自定义一个类实现Quzrtz中的Job接口，重写execute方法

public class MyTask implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
         System.out.println("定时任务"+ LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
    }
}

第三步创建Quartz配置类，将第二步的任务添加到调度器中

@Configuration
public class QuartzConfig {

    @Bean
    public JobDetail jobDetail(){
        return JobBuilder.newJob(MyTask.class)// 任务的Class
                .withIdentity("MyTask") //任务名称 
                .storeDurably() // 是否持久存储，默认为true
                .build();
    }

	// 触发器
    @Bean
    public Trigger trigger(){
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("0/5 * * * * ?");
        return TriggerBuilder.newTrigger()
                .forJob(jobDetail()) //添加任务
                .withIdentity("MyTask") // 触发器名称
                .withSchedule(scheduleBuilder) // 指定使用那个CronScheduleBuilder 
                .build();
    }

}

第四步，创建一个任务的实体类用于保存信息到数据库

public class QuartzBean {

    private String id;

    private String jobName;

    private String jobClass;

    private Integer status;

    private String cronExpression;

    public QuartzBean() {
    }

    public QuartzBean(String id, String jobName, String jobClass, Integer status, String cronExpression) {
        this.id = id;
        this.jobName = jobName;
        this.jobClass = jobClass;
        this.status = status;
        this.cronExpression = cronExpression;
    }

    public String getId() {
        return id;
    }

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

    public String getJobName() {
        return jobName;
    }

    public void setJobName(String jobName) {
        this.jobName = jobName;
    }

    public String getJobClass() {
        return jobClass;
    }

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

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }

    public String getCronExpression() {
        return cronExpression;
    }

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

    @Override
    public String toString() {
        return "QuartzBean{" +
                "id='" + id + '\'' +
                ", jobName='" + jobName + '\'' +
                ", jobClass='" + jobClass + '\'' +
                ", status=" + status +
                ", cronExpression='" + cronExpression + '\'' +
                '}';
    }
}

第五步，创建一个工具类用于定时任务的创建，修改，暂停，启动

public class QuartzUtils {

    public static void createScheduleJob(Scheduler scheduler, QuartzBean quartzBean) {

        try {

            // 获取执行任务的Class对象
            Class<?> jobClass = Class.forName(quartzBean.getJobClass());

            // 构建一个jobDetail
            JobDetail jobDetail = JobBuilder.newJob((Class<? extends Job>) jobClass).withIdentity(quartzBean.getJobName()).build();

            // 创建以一个cron 表达式的调度器
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(quartzBean.getCronExpression());
            // 创建一个触发器
            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(quartzBean.getJobName()).withSchedule(scheduleBuilder).build();
            // 开启定时任务
            scheduler.scheduleJob(jobDetail, trigger);
        } catch (ClassNotFoundException | SchedulerException e) {
            e.printStackTrace();
        }
    }

    // 暂停定时任务
    public static void pauseScheduleJob(Scheduler scheduler, String jobName) {
        JobKey jobKey = JobKey.jobKey(jobName);
        try {
            scheduler.pauseJob(jobKey);
        } catch (SchedulerException e) {
            System.out.println("暂停定时任务出错：" + e.getMessage());
        }
    }

    // 恢复定时任务
    public static void resumeScheduleJob(Scheduler scheduler, String jobName) {

        JobKey jobKey = JobKey.jobKey(jobName);
        try {
            scheduler.resumeJob(jobKey);
        } catch (SchedulerException e) {
            System.out.println("启动定时任务出错：" + e.getMessage());
        }

    }

    // 手到执行一次
    public static void runOnce(Scheduler scheduler, String jobName) {
        JobKey jobKey = JobKey.jobKey(jobName);
        try {
            scheduler.triggerJob(jobKey);
        } catch (SchedulerException e) {
            System.out.println("运行定时任务出错：" + e.getMessage());
        }
    }

    //更新定时器任务
    public static void updateScheduleJob(Scheduler scheduler, QuartzBean quartzBean) {
        try {
            //获取到对应任务的触发器
            TriggerKey triggerKey = TriggerKey.triggerKey(quartzBean.getJobName());
            //设置定时任务执行方式
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(quartzBean.getCronExpression());
            //重新构建任务的触发器trigger
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
            //重置对应的job
            scheduler.rescheduleJob(triggerKey, trigger);
        } catch (SchedulerException e) {
            System.out.println("更新定时任务出错：" + e.getMessage());
        }

    }

    public static void deleteScheduleJob(Scheduler scheduler, String jobName) {
        JobKey jobKey = JobKey.jobKey(jobName);
        try {
            scheduler.deleteJob(jobKey);
        } catch (SchedulerException e) {
            System.out.println("删除定时任务出错："+e.getMessage());
        }
    }

}

第六步， 创建Controller 测试

@RestController
@RequestMapping("/quartz")
public class QuartzController {

	
    @Resource
    private Scheduler quartzScheduler; // springboot 回自动创建Scheduler调度器，直接注入即可

    @RequestMapping("/createJob")
    public String createJob(QuartzBean quartzBean){
        try {
            quartzBean.setJobClass("com.example.demo.job.Test");
            quartzBean.setCronExpression("0/2 * * * * ?");
            quartzBean.setJobName("test");
            QuartzUtils.createScheduleJob(quartzScheduler,quartzBean);

        }catch (Exception e){
            return "创建失败";

        }

        return "运行成功";
    }

    @RequestMapping("/pauseJob")
    public String pauseJob(){
        try {
            QuartzUtils.pauseScheduleJob(quartzScheduler,"MyTask");

        }catch (Exception e) {
            e.printStackTrace();
            return "暂停失败";
        }
        return "暂停成功";
    }

    @RequestMapping("resume")
    public String resumw(){
        try {

            QuartzUtils.resumeScheduleJob(quartzScheduler,"MyTask");

        }catch (Exception e){
            e.printStackTrace();
            return "恢复失败";
        }

        return "恢复成功";
    }

    @RequestMapping("runOnce")
    public String runOnce(){
        try {

            QuartzUtils.runOnce(quartzScheduler,"MyTask");

        }catch (Exception e){
            e.printStackTrace();
            return "启动失败";
        }

        return "启动成功";
    }

    @RequestMapping("update")
    public String update(QuartzBean quartzBean){
        try {
            quartzBean.setJobClass("com.example.demo.job.MyTask");
            quartzBean.setCronExpression("0/2 * * * * ?");
            quartzBean.setJobName("test");
            QuartzUtils.createScheduleJob(quartzScheduler,quartzBean);

        }catch (Exception e){
            return "启动失败";

        }

        return "启动成功";
    }


}