springboot2-多个动态定时任务quartz使用-综合运用（四）

（1）springboot2运用quartz，pom.xml加载spring-boot-starter-quartz架包

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

（2） QuartzConfiguration配置类

import java.util.Date;
import org.quartz.JobDetail;
import org.quartz.Trigger;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
@Configuration
public class QuartzConfiguration {

// 配置定时任务1
    @Bean(name = "firstJobDetail")
    public MethodInvokingJobDetailFactoryBean firstJobDetail(Task1 entity) {
        MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean();
        // 是否并发执行
        jobDetail.setConcurrent(false);
        // 为需要执行的实体类对应的对象
        jobDetail.setTargetObject(entity);
        // 需要执行的方法
        jobDetail.setTargetMethod("getData1");
        return jobDetail;
    }

   // 配置触发器1
    @Bean(name = "firstTrigger")
    public CronTriggerFactoryBean firstTrigger(JobDetail firstJobDetail) {
        CronTriggerFactoryBean trigger = new CronTriggerFactoryBean();
        trigger.setJobDetail( firstJobDetail );
        trigger.setStartTime(new Date());
        // cron表达式(设置间隔60s) 7天(d)=604800000毫秒(ms)
        trigger.setCronExpression("0/5 * * * * ?");
        return trigger;
    }
    // 配置定时任务2
    @Bean(name = "secondJobDetail")
    public MethodInvokingJobDetailFactoryBean secondJobDetail(Task2 entity) {
        MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean();
        // 是否并发执行
        jobDetail.setConcurrent(true);
        // 为需要执行的实体类对应的对象
        jobDetail.setTargetObject(entity);
        // 需要执行的方法
        jobDetail.setTargetMethod("getData2");
        return jobDetail;
    }
    // 配置触发器2
    @Bean(name = "secondTrigger")
    public CronTriggerFactoryBean  secondTrigger(JobDetail secondJobDetail) {
        CronTriggerFactoryBean trigger = new CronTriggerFactoryBean();
        trigger.setJobDetail(secondJobDetail);
        trigger.setStartTime(new Date());
        // cron表达式(设置间隔60s) 7天(d)=604800000毫秒(ms)
        trigger.setCronExpression("0/5 * * * * ?");
        return trigger;
    }

// 配置Scheduler
    @Bean(name = "scheduler")
    public SchedulerFactoryBean schedulerFactory(Trigger firstTrigger, Trigger secondTrigger) {
        SchedulerFactoryBean bean = new SchedulerFactoryBean();
        // 延时启动，应用启动1秒后
        bean.setStartupDelay(1);
        // 注册触发器
        bean.setTriggers(firstTrigger,secondTrigger);
        return bean;
    }

}

2个task类Task1、Task2

import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.Date;

import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.stereotype.Component;

@Component
@EnableScheduling
public class Task2 {

    public void getData2(){
        System.out.println("===启动Job2：" + LocalDateTime.now()+"===");
        SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
        System.out.println("MyJob作业调度2-现在时间：" + dateFormat.format(new Date()));
    }

}

@Component
@EnableScheduling
public class Task2 {

    public void getData2(){
        
        System.out.println("===启动Job2：" + LocalDateTime.now()+"===");
        SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
        System.out.println("MyJob作业调度2-现在时间：" + dateFormat.format(new Date()));
    
    }

}

（3）修改数据库Cron： 0/10 * * * * ?，定时器重新执行ScheduleRefreshService

@Configuration
@EnableScheduling
@Component
public class ScheduleRefreshService {
    
    @Autowired
    private QuartzConfigMapper configMapper;
    
    @Resource(name = "scheduler")
    private Scheduler scheduler;
     
    @Resource(name = "firstJobDetail")
    private JobDetail firstJobDetail;
 
    @Resource(name = "firstTrigger")
    private CronTrigger firstTrigger;
    
    @Resource(name = "secondTrigger")
    private CronTrigger secondTrigger;
    
    @Resource(name = "thirdTrigger")
    private CronTrigger thirdTrigger;
    
    @Scheduled(cron="0 */1 * * * ?")
    public void scheduleUpdateCronTrigger() throws SchedulerException {
        CronTrigger trigger = (CronTrigger) scheduler.getTrigger(firstTrigger.getKey());
        //当前Trigger使用的
        String currentCron = trigger.getCronExpression();
        System.out.println("1-->currentCron Trigger:"+ currentCron);
        //mapper操作数据库从数据库查询出来的
        String searchCron = configMapper.findOne(1).getCron();
        System.out.println("1-->searchCron  Trigger:"+ searchCron);
 
        if (currentCron.equals(searchCron)) {
            // 如果当前使用的cron表达式和从数据库中查询出来的cron表达式一致，则不刷新任务
        } else {
            //表达式调度构建器
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(searchCron);
            //按新的cronExpression表达式重新构建trigger
            trigger = (CronTrigger) scheduler.getTrigger(firstTrigger.getKey());
            trigger = trigger.getTriggerBuilder().withIdentity(firstTrigger.getKey()).withSchedule(scheduleBuilder).build();
            //按新的trigger重新设置job执行
            scheduler.rescheduleJob(firstTrigger.getKey(), trigger);
            currentCron = searchCron;
        }
    }

    @Scheduled(cron="0 */2 * * * ?")
    public void scheduleUpdateCronTrigger2() throws SchedulerException {
        CronTrigger trigger = (CronTrigger) scheduler.getTrigger(secondTrigger.getKey());
        //当前Trigger使用的
        String currentCron = trigger.getCronExpression();
        System.out.println("2-->currentCron Trigger:"+ currentCron);
        //mapper操作数据库从数据库查询出来的
        String searchCron = configMapper.findOne(2).getCron();
        System.out.println("2-->searchCron  Trigger:"+ searchCron);
 
        if (currentCron.equals(searchCron)) {
            // 如果当前使用的cron表达式和从数据库中查询出来的cron表达式一致，则不刷新任务
        } else {
            //表达式调度构建器
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(searchCron);
            //按新的cronExpression表达式重新构建trigger
            trigger = (CronTrigger) scheduler.getTrigger(secondTrigger.getKey());
            trigger = trigger.getTriggerBuilder().withIdentity(secondTrigger.getKey()).withSchedule(scheduleBuilder).build();
            //按新的trigger重新设置job执行
            scheduler.rescheduleJob(secondTrigger.getKey(), trigger);
            currentCron = searchCron;
        }
    }
    
    @Scheduled(cron="0 */3 * * * ?")
    public void scheduleUpdateCronTrigger3() throws SchedulerException {
        CronTrigger trigger = (CronTrigger) scheduler.getTrigger(thirdTrigger.getKey());
        //当前Trigger使用的
        String currentCron = trigger.getCronExpression();
        System.out.println("3-->currentCron Trigger:"+ currentCron);
        //mapper操作数据库从数据库查询出来的
        String searchCron = configMapper.findOne(3).getCron();
        System.out.println("3-->searchCron  Trigger:"+ searchCron);
 
        if (currentCron.equals(searchCron)) {
            // 如果当前使用的cron表达式和从数据库中查询出来的cron表达式一致，则不刷新任务
        } else {
            //表达式调度构建器
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(searchCron);
            //按新的cronExpression表达式重新构建trigger
            trigger = (CronTrigger) scheduler.getTrigger(thirdTrigger.getKey());
            trigger = trigger.getTriggerBuilder().withIdentity(thirdTrigger.getKey()).withSchedule(scheduleBuilder).build();
            //按新的trigger重新设置job执行
            scheduler.rescheduleJob(thirdTrigger.getKey(), trigger);
            currentCron = searchCron;
        }
    }

}
实体类Config与数据库操作接口了QuartzConfigMapper，QuartzConfigMapper采用注解直接查询

public class Config {

    private Integer id;
    private String cron;
    
    public Config() {
        super();
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getCron() {
        return cron;
    }
    public void setCron(String cron) {
        this.cron = cron;
    }
}

public interface QuartzConfigMapper {
    @Select("SELECT * FROM config t where id = #{id}")
    Config findOne(int id);

}

注意:  Application 添加扫描MapperScan()你自己的包名称

@MapperScan("com.*.mapper")
public class Application 

表结构sql

DROP TABLE IF EXISTS `config`;
CREATE TABLE `config`  (
  `id` int(10) NOT NULL,
  `cron` varchar(40) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_unicode_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of config
-- ----------------------------
INSERT INTO `config` VALUES (1, '0/10 * * * * ?');
INSERT INTO `config` VALUES (2, '0/20 * * * * ?');
INSERT INTO `config` VALUES (3, '0/30 * * * * ?');

运行

===启动Job1：2021-03-04T16:49:50.001===
MyJob作业调度1-现在时间：16:49:50

===启动Job2：2021-03-04T16:50:00.002===
MyJob作业调度2-现在时间：16:50:00