SpringBoot集成quartz实现定时任务

        <!--集成quartz-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
            <version>2.3.12.RELEASE</version>
        </dependency>

       <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--mysql依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!--util工具类-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.8.1</version>
        </dependency>

spring:
  datasource:
    name: db_quartz
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db_quartz?useSSL=false&serverTimezone=Asia/Shanghai&characterEncoding=UTF8&rewriteBatchedStatements=true
    username: root
    password: 123456
  #quartz配置
  quartz:
    #数据存储方式 默认是 MEMORY（内存方式）
    job-store-type: jdbc
    properties:
      org:
        quartz:
          scheduler:
            #调度标识名
            instanceName: clusteredScheduler
            #ID设置为自动获取 每一个必须不同
            instanceId: AUTO
          jobStore:
            #数据保存方式为持久化
            class: org.quartz.impl.jdbcjobstore.JobStoreTX
            #数据库平台
            driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
            #表的前缀
            tablePrefix: QRTZ_
            #加入集群
            isClustered: false
            #调度实例失效的检查时间间隔
            clusterCheckinInterval: 10000
            #设置为TRUE不会出现序列化非字符串类到 BLOB 时产生的类版本问题
            useProperties: false
          threadPool:
            #ThreadPool 实现的类名
            class: org.quartz.simpl.SimpleThreadPool
            #线程数量
            threadCount: 5
            #线程优先级
            threadPriority: 5
            #自创建父线程
            threadsInheritContextClassLoaderOfInitializingThread: true

@RestController
@RequestMapping("/quartz")
public class QuartzController {
    @Autowired
    private QuartzService quartzService;
    /**
     * 新增任务
     */
    @PostMapping("/insert")
    @ApiOperation(value = "新增任务", notes = "新增任务")
    public Boolean insertTask(@RequestBody QuartzModel quartzModel) {
        return quartzService.addJob(quartzModel);
    }
    /**
     * 暂停任务
     */
    @PostMapping("/pause")
    @ApiOperation(value = "暂停任务", notes = "暂停任务")
    public Boolean pauseTask(@RequestBody OperationModel operationModel) {
        return quartzService.pauseJob(operationModel);
    }
    /**
     * 恢复任务
     */
    @PostMapping("/resume")
    @ApiOperation(value = "恢复任务", notes = "恢复任务")
    public Boolean resumeTask(@RequestBody OperationModel operationModel) {
        return quartzService.resumeJob(operationModel);
    }
    /**
     * 删除任务
     */
    @PostMapping("/delete")
    @ApiOperation(value = "删除任务", notes = "删除任务")
    public Boolean deleteTask(@RequestBody OperationModel operationModel) {
        return quartzService.deleteJob(operationModel);
    }
    /**
     * 查看所有定时任务
     */
    @GetMapping("/query-all-job")
    @ApiOperation(value = "查看所有定时任务", notes = "查看所有定时任务")
    public List<Map<String, Object>> queryAllJob() {
        return quartzService.queryAllJob();
    }
    /**
     * 查看正在运行的任务
     */
    @GetMapping("/query-all-running-job")
    @ApiOperation(value = "查看正在执行的任务", notes = "查看正在执行的任务")
    public List<Map<String, Object>> queryAllRunningJob() {
        return quartzService.queryAllRunningJob();
    }
}

@Service
public interface QuartzService {
    /**
     * 新增定时任务
     */
    Boolean addJob(QuartzModel quartzModel);
    /**
     * 暂停定时任务
     */
    Boolean pauseJob(OperationModel operationModel);
    /**
     * 继续定时任务
     */
    Boolean resumeJob(OperationModel operationModel);
    /**
     * 删除定时任务
     */
    Boolean deleteJob(OperationModel operationModel);
    /**
     * 查询所有计划中的任务列表
     */
    List<Map<String, Object>> queryAllJob();
    /**
     * 查看正在运行的任务
     */
    List<Map<String, Object>> queryAllRunningJob();
}

 
/**
 * 定时任务执行器
 */
@Slf4j
public class TaskDistributor extends QuartzJobBean {
    /**
     * 根据不同的jobDetail携带的type参数区分,执行不同业务
     */
    @Override
    protected void executeInternal(JobExecutionContext context) {
        synchronized (this) {
            log.info("开始执行定时任务...............");
            try {
                //获取job中携带的内容并转成jobDetailModel对象
                JobDetailModel jobDetailModel = (JobDetailModel) context.getJobDetail().getJobDataMap().get("jobDetailModel");
                Integer type = jobDetailModel.getType();
                String content = jobDetailModel.getContent();
                //根据type执行不同的业务逻辑
                switch (type) {
                    case 1:
                        System.out.println("task1即将被执行，content:" + content);
                        //模拟处理逻辑
                        Thread.sleep(5000);
                        log.info("---------task1定时任务执行结束----------");
                        break;
                    case 2:
                        System.out.println("task2即将被执行，content:" + content);
                        //模拟处理逻辑
                        Thread.sleep(5000);
                        log.info("----------task2定时任务结束---------");
                        break;
                    default:
                        log.info("---------定时任务执行开始----------");
                        log.info("---------定时任务执行结束----------");
                        break;
                }
            } catch (Throwable t) {
                log.error(t.getMessage(), t);
            }
            log.info("定时任务执行结束...............");
        }
    }
}

@Slf4j
@Service
public class QuartzServiceImpl implements QuartzService {
    @Autowired
    private Scheduler scheduler;
    /**
     * 新增定时任务
     */
    @Override
    public Boolean addJob(QuartzModel quartzModel) {
        try {
            String cron = quartzModel.getCron();
            //校验cron是否有效
            boolean valid = CronUtils.isValid(cron);
            if (!valid) {
                return false;
            }
            JobDetail jobDetail = JobBuilder.newJob(TaskDistributor.class)
                    .withIdentity(quartzModel.getJobName(), quartzModel.getJobGroup())
                    .build();
            // 携带job内容 此处可以携带业务所需要的执行参数
            JobDetailModel jobDetailModel = quartzModel.getJobData();
            if (!Objects.isNull(jobDetailModel)) {
                jobDetail.getJobDataMap().put("jobDetailModel", jobDetailModel);
            }
            CronTrigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity(quartzModel.getTriggerName(), quartzModel.getTriggerGroup())
                    .startNow()
                    .withSchedule(CronScheduleBuilder.cronSchedule(cron))
                    .build();
            //把作业和触发器注册到任务调度中
            scheduler.scheduleJob(jobDetail, trigger);
            //启用调度
            scheduler.start();
            log.info("---------定时任务成功添加进quartz队列中！----------");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return true;
    }
    /**
     * 暂停定时任务
     */
    @Override
    public Boolean pauseJob(OperationModel operationModel) {
        try {
            scheduler.pauseJob(JobKey.jobKey(operationModel.getJobName(), operationModel.getJobGroup()));
            System.out.println("暂停定时任务成功");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return true;
    }
    /**
     * 继续定时任务
     */
    @Override
    public Boolean resumeJob(OperationModel operationModel) {
        try {
            scheduler.resumeJob(JobKey.jobKey(operationModel.getJobName(), operationModel.getJobGroup()));
            System.out.println("恢复定时任务成功");
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return true;
    }
    /**
     * 删除定时任务
     */
    @Override
    public Boolean deleteJob(OperationModel operationModel) {
        try {
            // TriggerKey 定义了trigger的名称和组别 ，通过任务名和任务组名获取TriggerKey
            TriggerKey triggerKey = TriggerKey.triggerKey(operationModel.getJobName(), operationModel.getJobGroup());
            // 停止触发器
            scheduler.resumeTrigger(triggerKey);
            // 移除触发器
            scheduler.unscheduleJob(triggerKey);
            scheduler.deleteJob(JobKey.jobKey(operationModel.getJobName(), operationModel.getJobGroup()));
            System.out.println("删除定时任务成功");
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return true;
    }
    /**
     * 查看所有定时任务
     *
     * @return
     */
    @Override
    public List<Map<String, Object>> queryAllJob() {
        List<Map<String, Object>> jobList = null;
        try {
            GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
            Set<JobKey> jobKeys = scheduler.getJobKeys(matcher);
            jobList = new ArrayList<Map<String, Object>>();
            for (JobKey jobKey : jobKeys) {
                List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
                for (Trigger trigger : triggers) {
                    jobList.add(this.buildMap(jobKey, trigger));
                }
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return jobList;
    }
    /**
     * 返回指定的map集合
     */
    private Map<String, Object> buildMap(JobKey jobKey, Trigger trigger) throws SchedulerException {
        Map<String, Object> map = new HashMap<>();
        map.put("jobName", jobKey.getName());
        map.put("jobGroupName", jobKey.getGroup());
        map.put("description", "触发器:" + trigger.getKey());
        Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
        map.put("jobStatus", triggerState.name());
        if (trigger instanceof CronTrigger) {
            CronTrigger cronTrigger = (CronTrigger) trigger;
            String cronExpression = cronTrigger.getCronExpression();
            map.put("jobTime", cronExpression);
        }
        return map;
    }
    /**
     * 获取所有正在运行的job
     *
     * @return
     */
    @Override
    public List<Map<String, Object>> queryAllRunningJob() {
        List<Map<String, Object>> jobList = null;
        try {
            List<JobExecutionContext> executingJobs = scheduler.getCurrentlyExecutingJobs();
            jobList = new ArrayList<Map<String, Object>>(executingJobs.size());
            for (JobExecutionContext executingJob : executingJobs) {
                JobDetail jobDetail = executingJob.getJobDetail();
                JobKey jobKey = jobDetail.getKey();
                Trigger trigger = executingJob.getTrigger();
                jobList.add(this.buildMap(jobKey, trigger));
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return jobList;
    }
}