Spring Boot 整合Quartz以及动态控制任务(暂停，启动，修改执行时间)

淡淡的烟草味﹌ 2023-02-12 05:41 79阅读 0赞

原文 https://blog.csdn.net/yali\_aini/article/details/85287074

# Spring Boot 整合Quartz以及动态控制任务(暂停，启动，修改执行时间) #

### 整合 Quartz定时器 ###

<dependency>
                <groupId>org.quartz-scheduler</groupId>
                <artifactId>quartz</artifactId>
                <version>2.2.1</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-tx</artifactId>
                <version>5.0.8.RELEASE</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
                <version>4.3.13.RELEASE</version>
            </dependency>

### 集成接口式定时器 ###

1 集成Job

public class TestJob implements Job { 
        @Override
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException { 
    
    
            System.out.println(" ------------ quartz 控制台定时器 ------------------ ");
        }
    
    
        public static void main(String[] args) throws SchedulerException { 
    
    
            // 1,创建 job，你要做什么事？
            JobDetail job = JobBuilder.newJob(TestJob.class).build();
    
            // 2,创建 trigger ，你在什么时候做？
            Trigger trigger = TriggerBuilder
                    .newTrigger()
                    //.withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(2)).build();
                    //可以换成cron表达式
                    .withSchedule(CronScheduleBuilder.cronSchedule("0/2 * * * * ?")).build();
    
            // 3,创建 schedule 对象，在什么时候执行什么事？
            Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
    
            scheduler.scheduleJob(job, trigger);
            // 4,启动
            scheduler.start();
    
        }
    }

### Quartz 启动 更新 停止 ###

#### 新建任务 ####

@Component
    public class Job { 
    
    
        public void job() { 
    
            System.out.println("--------------- 执行任务 --------------");
        }
    }

#### 配置定时器 ####

@Configuration
    public class QuartzConfig { 
    
        // 定义方法，做什么
        @Bean(name = "job1")
        public MethodInvokingJobDetailFactoryBean job1(Job job) { 
            MethodInvokingJobDetailFactoryBean factoryBean = new MethodInvokingJobDetailFactoryBean();
            // 是否并发执行
            factoryBean.setConcurrent(false);
            // 使用哪个对象
            factoryBean.setTargetObject(job);
            // 使用哪个方法
            factoryBean.setTargetMethod("job");
    
            return factoryBean;
        }
    
        // 定义什么时候做，使用 cron 表达式
        @Bean(name = "cron1")
        public CronTriggerFactoryBean cron1(@Qualifier("job1") MethodInvokingJobDetailFactoryBean job1) { 
            CronTriggerFactoryBean factoryBean = new CronTriggerFactoryBean();
            // 设置job对象
            factoryBean.setJobDetail(job1.getObject());
            // 设置执行时间
            factoryBean.setCronExpression("0/5 * * * * ?");
            return factoryBean;
        }
    
    
        // 创建 Scheduler 对象
        // 定义 任务,传入 triggers
        @Bean(name = "sch1")
        public SchedulerFactoryBean scheduler1(Trigger... triggers) { 
            SchedulerFactoryBean factoryBean = new SchedulerFactoryBean();
            // 设置 triggers
            factoryBean.setTriggers(triggers);
            // 自动运行
            factoryBean.setAutoStartup(true);
    
            return factoryBean;
        }
    
    }

#### 对外提供配置启动更新接口 ####

/** * @description: 定时器控制层 * @author: Administrator * @create: 2020-05-24 15:35 **/
    @RestController
    public class QuartzController { 
    
    
        @Autowired
        @Qualifier("sch1")
        private Scheduler scheduler;
    
        /** * 关闭任务 */
        @RequestMapping("/pause")
        public String pause() throws Exception { 
    
            System.out.println(scheduler);
            //任务名
            JobKey key = new JobKey("job1");
            scheduler.pauseJob(key);
            System.out.println(" ---------- 关闭成功 ---------- ");
            return "pause";
    
    
        }
    
        /** * 执行任务 */
        @RequestMapping("/start")
        public String start() throws Exception { 
    
            System.out.println(scheduler);
    
            JobKey key = new JobKey("job1");
            scheduler.resumeJob(key);
            System.out.println(" ---------- 启动成功 ---------- ");
            return "start";
        }
    
    
        /** * 动态修改任务执行的时间 */
        @RequestMapping("/trigger")
        public String trigger() throws Exception { 
            // 获取任务
            JobKey jobKey = new JobKey("job1");
            // 获取 jobDetail
            JobDetail jobDetail = scheduler.getJobDetail(jobKey);
            // 生成 trigger
            Trigger trigger = TriggerBuilder
                    .newTrigger()
                    .withSchedule(CronScheduleBuilder.cronSchedule("0/10 * * * * ?"))
                    .build();
            // 删除任务，不删除会报错。报任务已存在
            scheduler.deleteJob(jobKey);
            // 启动任务
            scheduler.scheduleJob(jobDetail, trigger);
            System.out.println(" ---------- 更新启动成功 ---------- ");
            return "trigger";
        }
    }