Spring Boot集成Quartz，管理动态定时任务

1、添加maven依赖

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

2、创建数据库SQL，可以到quartz官网下载的quartz包中查找

#
# Quartz seems to work best with the driver mm.mysql-2.0.7-bin.jar
#
# PLEASE consider using mysql with innodb tables to avoid locking issues
#
# In your Quartz properties file, you'll need to set
# org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#

DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;
DROP TABLE IF EXISTS QRTZ_LOCKS;
DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;
DROP TABLE IF EXISTS QRTZ_CALENDARS;


CREATE TABLE QRTZ_JOB_DETAILS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    JOB_NAME  VARCHAR(200) NOT NULL,
    JOB_GROUP VARCHAR(200) NOT NULL,
    DESCRIPTION VARCHAR(250) NULL,
    JOB_CLASS_NAME   VARCHAR(250) NOT NULL,
    IS_DURABLE VARCHAR(1) NOT NULL,
    IS_NONCONCURRENT VARCHAR(1) NOT NULL,
    IS_UPDATE_DATA VARCHAR(1) NOT NULL,
    REQUESTS_RECOVERY VARCHAR(1) NOT NULL,
    JOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
);

CREATE TABLE QRTZ_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    JOB_NAME  VARCHAR(200) NOT NULL,
    JOB_GROUP VARCHAR(200) NOT NULL,
    DESCRIPTION VARCHAR(250) NULL,
    NEXT_FIRE_TIME BIGINT(13) NULL,
    PREV_FIRE_TIME BIGINT(13) NULL,
    PRIORITY INTEGER NULL,
    TRIGGER_STATE VARCHAR(16) NOT NULL,
    TRIGGER_TYPE VARCHAR(8) NOT NULL,
    START_TIME BIGINT(13) NOT NULL,
    END_TIME BIGINT(13) NULL,
    CALENDAR_NAME VARCHAR(200) NULL,
    MISFIRE_INSTR SMALLINT(2) NULL,
    JOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
        REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP)
);

CREATE TABLE QRTZ_SIMPLE_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    REPEAT_COUNT BIGINT(7) NOT NULL,
    REPEAT_INTERVAL BIGINT(12) NOT NULL,
    TIMES_TRIGGERED BIGINT(10) NOT NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_CRON_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    CRON_EXPRESSION VARCHAR(200) NOT NULL,
    TIME_ZONE_ID VARCHAR(80),
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_SIMPROP_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    STR_PROP_1 VARCHAR(512) NULL,
    STR_PROP_2 VARCHAR(512) NULL,
    STR_PROP_3 VARCHAR(512) NULL,
    INT_PROP_1 INT NULL,
    INT_PROP_2 INT NULL,
    LONG_PROP_1 BIGINT NULL,
    LONG_PROP_2 BIGINT NULL,
    DEC_PROP_1 NUMERIC(13,4) NULL,
    DEC_PROP_2 NUMERIC(13,4) NULL,
    BOOL_PROP_1 VARCHAR(1) NULL,
    BOOL_PROP_2 VARCHAR(1) NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_BLOB_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    BLOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_CALENDARS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    CALENDAR_NAME  VARCHAR(200) NOT NULL,
    CALENDAR BLOB NOT NULL,
    PRIMARY KEY (SCHED_NAME,CALENDAR_NAME)
);

CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_GROUP  VARCHAR(200) NOT NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_FIRED_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    ENTRY_ID VARCHAR(95) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    INSTANCE_NAME VARCHAR(200) NOT NULL,
    FIRED_TIME BIGINT(13) NOT NULL,
    SCHED_TIME BIGINT(13) NOT NULL,
    PRIORITY INTEGER NOT NULL,
    STATE VARCHAR(16) NOT NULL,
    JOB_NAME VARCHAR(200) NULL,
    JOB_GROUP VARCHAR(200) NULL,
    IS_NONCONCURRENT VARCHAR(1) NULL,
    REQUESTS_RECOVERY VARCHAR(1) NULL,
    PRIMARY KEY (SCHED_NAME,ENTRY_ID)
);

CREATE TABLE QRTZ_SCHEDULER_STATE
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    INSTANCE_NAME VARCHAR(200) NOT NULL,
    LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
    CHECKIN_INTERVAL BIGINT(13) NOT NULL,
    PRIMARY KEY (SCHED_NAME,INSTANCE_NAME)
);

CREATE TABLE QRTZ_LOCKS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    LOCK_NAME  VARCHAR(40) NOT NULL,
    PRIMARY KEY (SCHED_NAME,LOCK_NAME)
);


commit;

3、在resource下添加quartz的属性配置文件quartz.properties

# 固定前缀org.quartz
# 主要分为scheduler、threadPool、jobStore、plugin等部分
#
#
org.quartz.scheduler.instanceName = DefaultQuartzScheduler
org.quartz.scheduler.rmi.export = false
org.quartz.scheduler.rmi.proxy = false
org.quartz.scheduler.wrapJobExecutionInUserTransaction = false

# 实例化ThreadPool时，使用的线程类为SimpleThreadPool
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool

# threadCount和threadPriority将以setter的形式注入ThreadPool实例
# 并发个数
org.quartz.threadPool.threadCount = 10
# 优先级
org.quartz.threadPool.threadPriority = 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true

org.quartz.jobStore.misfireThreshold = 6000

# 默认存储在内存中
#org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore

#持久化
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX

org.quartz.jobStore.tablePrefix = QRTZ_
org.quartz.jobStore.clusterCheckinInterval = 15000  
org.quartz.jobStore.isClustered = true

4、创建job的实例工厂，把quartz相关的bean交给spring管理，解决@Autowire无法注入的问题

package com.**.dv.modules.quartz;

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.AdaptableJobFactory;
import org.springframework.stereotype.Component;

/**
 * @ClassName JobFactory
 * @Description TODO
 * @Date 2019/7/1
 * @Version 1.0
 **/
@Component
public class JobFactory extends AdaptableJobFactory {

    @Autowired
    private AutowireCapableBeanFactory factory;

    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        //调用父类的方法
        Object jobInstance = super.createJobInstance(bundle);
        //进行注入
        factory.autowireBean(jobInstance);
        return jobInstance;
    }

}

5、创建quartz的配置文件QuartzConfig

package com.**.dv.conf;

import com.**.dv.modules.quartz.JobFactory;
import org.quartz.Scheduler;
import org.quartz.ee.servlet.QuartzInitializerListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import javax.sql.DataSource;
import java.io.IOException;
import java.util.Properties;

@Configuration
public class QuartzConfig {

    @Autowired
    private DataSource dataSource;

    @Autowired
    private JobFactory jobFactory;

    @Bean
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        //在quartz.properties中的属性被读取并注入后再初始化对象
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }
    @Bean(name = "SchedulerFactory")
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setQuartzProperties(quartzProperties());
        factory.setDataSource(dataSource);
        factory.setJobFactory(jobFactory);
        return factory;
    }

    @Bean
    public QuartzInitializerListener executorListener(){
        return new QuartzInitializerListener();
    }

    @Bean(name="Scheduler")
    public Scheduler scheduler() throws IOException {
        Scheduler scheduler = schedulerFactoryBean().getScheduler();
        return scheduler;
    }
}

6、创建基础任务接口，新建任务实现该接口

package com.**.dv.quartz.job.base;

import org.quartz.Job;

/**
 * @ClassName BaseJob
 * @Description TODO
 * @Date 2019/7/2
 * @Version 1.0
 **/
public interface BaseJob extends Job {
}

7、创建测试任务，并用@Component注释，把任务交给spring管理

package com.**.dv.job.task.base;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

/**
 * @ClassName HelloJob
 * @Description TODO
 * @Date 2019/7/2
 * @Version 1.0
 **/
@Component
public class HelloJob implements BaseJob {

    private Logger logger = LoggerFactory.getLogger(this.getClass());

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        Long stime = System.currentTimeMillis();
        logger.info("开始时间："+stime);
        System.out.println("HelleJob......");
        logger.info("结束时间：{}",System.currentTimeMillis());
    }
}

8、创建bean工具类，通过beanid获取bean实例

package com.**.dv.utils;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

/**
 * @ClassName BeanUtil
 * @Description 通过容器中的beanId获取bean
 * @Date 2019/6/10
 * @Version 1.0
 **/
@Component
public class BeanUtil implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }
    
    public static <T> T getBean(String name) throws BeansException {
        return (T) applicationContext.getBean(name);
    }
    public static <T> T getBean(Class<T> clazz){
        return getApplicationContext().getBean(clazz);
    }

    public static <T> T getBean(String name,Class<T> clazz){
        return getApplicationContext().getBean(name,clazz);
    }

}

9、创建自定义表qrtz_job_info的实体类，用于存放job基本信息

package com.**.dv.modules.quartz.entity;

import javax.persistence.*;

/**
 * @ClassName QrtzJobInfoEntity
 * @Description TODO
 * @Date 2019/7/3
 * @Version 1.0
 **/
@Entity
@Table(name = "qrtz_job_info")
public class QrtzJobInfoEntity {

    @Id
    @GeneratedValue
    private Integer id;

    @Column
    private String jobName;
    @Column
    private String jobGroup;
    @Column
    private String jobCron;
    @Column
    private String jobStatus;
    @Column
    private String jobTitle;
    @Column
    private Long jobDate = System.currentTimeMillis();

    public Integer getId() {
        return id;
    }

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

    public String getJobName() {
        return jobName;
    }

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

    public String getJobGroup() {
        return jobGroup;
    }

    public void setJobGroup(String jobGroup) {
        this.jobGroup = jobGroup;
    }

    public String getJobCron() {
        return jobCron;
    }

    public void setJobCron(String jobCron) {
        this.jobCron = jobCron;
    }

    public String getJobStatus() {
        return jobStatus;
    }

    public void setJobStatus(String jobStatus) {
        this.jobStatus = jobStatus;
    }

    public String getJobTitle() {
        return jobTitle;
    }

    public void setJobTitle(String jobTitle) {
        this.jobTitle = jobTitle;
    }

    public Long getJobDate() {
        return jobDate;
    }

    public void setJobDate(Long jobDate) {
        this.jobDate = jobDate;
    }
}

10、创建controller和service，对外提供接口

package com.**.dv.modules.quartz.controller;

import com.**.dv.common.vo.PageableVO;
import com.**.dv.modules.quartz.bean.JobBean;
import com.**.dv.modules.quartz.condition.QuartzCondition;
import com.**.dv.modules.quartz.entity.QrtzJobInfoEntity;
import com.**.dv.modules.quartz.service.QuartzService;
import com.**.dv.job.task.base.BaseJob;
import com.**.dv.utils.Response;
import com.**.dv.utils.ResponseUtil;
import io.swagger.annotations.ApiOperation;
import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.quartz.impl.triggers.CronTriggerImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName QuartzController
 * @Description TODO
 * @Date 2019/7/2
 * @Version 1.0
 **/
@RestController
@RequestMapping("/quartz")
public class QuartzController {

    private Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    @Qualifier("Scheduler")
    private Scheduler scheduler;

    @Autowired
    private QuartzService quartzService;

    @ApiOperation("查询全部任务列表(包括正在执行和暂定的)")
    @GetMapping("/list")
    public Response getJobList(QuartzCondition condition){
        PageableVO list = quartzService.getJobList(condition);
        return ResponseUtil.success(list);
    }

    @ApiOperation("查询全部任务(包括正在执行和暂定的)")
    @GetMapping("/job")
    public Response queryJob(){
        List<JobBean> list = new ArrayList<>();
        try {
            for(String groupName:scheduler.getJobGroupNames()){
                for(JobKey jobKey:scheduler.getJobKeys(GroupMatcher.groupEquals(groupName))){
                    JobBean jobBean = new JobBean();
                    jobBean.setJobName(jobKey.getName());
                    jobBean.setGroupName(jobKey.getGroup());
                    TriggerKey triggerKey = TriggerKey.triggerKey(jobKey.getName(), jobKey.getGroup());
                    CronTriggerImpl cronTriggerImpl = (CronTriggerImpl) scheduler.getTrigger(triggerKey);
                    jobBean.setStatus(scheduler.getTriggerState(triggerKey).name());
                    jobBean.setCron(cronTriggerImpl.getCronExpression());
                    list.add(jobBean);
                    logger.info("Current JOB : {}",jobKey);
                }
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return ResponseUtil.success(list);
    }

    @ApiOperation("新增定时任务")
    @PostMapping("/job")
    public Response addJob(@RequestBody QrtzJobInfoEntity entity){
        quartzService.addJob(entity);
        return ResponseUtil.success();
    }
    @ApiOperation("新增定时任务")
    @PostMapping("/modify")
    public Response modifyJob(@RequestBody QrtzJobInfoEntity entity){
        quartzService.modifyJob(entity);
        return ResponseUtil.success();
    }

    @ApiOperation("删除指定任务")
    @DeleteMapping("/job/{ids}")
    public Response deleteJob(@PathVariable("ids") Integer[] ids){
        quartzService.deleteJob(ids);
        return ResponseUtil.success();
    }

    @ApiOperation("恢复任务")
    @PostMapping("/resume/{id}")
    public Response resumeJob(@PathVariable("id") Integer id){
        quartzService.resumeJob(id);
        return ResponseUtil.success();
    }
    @ApiOperation("暂停任务")
    @PostMapping("/pause/{id}")
    public Response pauseJob(@PathVariable("id") Integer id){
        quartzService.pauseJob(id);
        return ResponseUtil.success();
    }
    @ApiOperation("立即执行任务")
    @PostMapping("/start/{id}")
    public Response startJob(@PathVariable("id") Integer id){
        quartzService.startJob(id);
        return ResponseUtil.success();
    }

    public static BaseJob getClass(String classname) throws Exception{
        Class<?> class1 = Class.forName(classname);
        return (BaseJob)class1.newInstance();
    }

    @ApiOperation("删除全部定时任务")
    @DeleteMapping("/deleteAll")
    public ResponseEntity deleteJob(){
        try {
            scheduler.clear();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return ResponseEntity.ok("");
    }
}

package com.**.dv.modules.quartz.service.impl;

import com.**.dv.common.vo.PageableVO;
import com.**.dv.job.task.base.BaseJob;
import com.**.dv.modules.page.entity.PageInfoEntity;
import com.**.dv.modules.quartz.condition.QuartzCondition;
import com.**.dv.modules.quartz.entity.QrtzJobInfoEntity;
import com.**.dv.modules.quartz.repository.QrtzJobInfoRepository;
import com.**.dv.modules.quartz.service.QuartzService;
import com.**.dv.utils.BeanUtil;
import org.quartz.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.persistence.criteria.Predicate;
import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName QuartzServiceImpl
 * @Description TODO
 * @Date 2019/7/3
 * @Version 1.0
 **/
@Service
public class QuartzServiceImpl implements QuartzService {
    private Logger logger = LoggerFactory.getLogger(this.getClass());
    @Autowired
    @Qualifier("Scheduler")
    private Scheduler scheduler;

    @Autowired
    private QrtzJobInfoRepository qrtzJobInfoRepository;

    @Override
    public PageableVO getJobList(QuartzCondition condition) {
        Sort sort = new Sort(Sort.Direction.DESC, "jobDate");
        Pageable pageable = PageRequest.of(condition.getPage(), condition.getSize(), sort);
        Specification<QrtzJobInfoEntity> specification = (root, query, criteriaBuilder) -> {
            List<Predicate> list = new ArrayList<>();
            return criteriaBuilder.and(list.toArray(new Predicate[0]));
        };
        Page<QrtzJobInfoEntity> page = qrtzJobInfoRepository.findAll(specification, pageable);
        return new PageableVO(page);
    }

    @Transactional
    @Override
    public void addJob(QrtzJobInfoEntity entity) {
        String jobClassName = entity.getJobName();
        String jobCron = entity.getJobCron();
        try {
            scheduler.start();
            BaseJob jobBean = BeanUtil.getBean(jobClassName);
            //构建job信息
            JobDetail jobDetail = JobBuilder.newJob(jobBean.getClass()).withIdentity(jobClassName, jobClassName).build();
            //表达式调度构建器(即任务执行的时间)
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(jobCron);
            //按新的cronExpression表达式构建一个新的trigger
            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobClassName, jobClassName).withSchedule(scheduleBuilder).build();
            scheduler.scheduleJob(jobDetail,trigger);
            TriggerKey triggerKey = TriggerKey.triggerKey(jobClassName, jobClassName);
            entity.setJobStatus(scheduler.getTriggerState(triggerKey).name());
            entity.setJobGroup(jobClassName);
            qrtzJobInfoRepository.saveAndFlush(entity);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    @Transactional
    @Override
    public void deleteJob(Integer[] ids) {
        for(Integer id:ids){
            QrtzJobInfoEntity jobInfoEntity = qrtzJobInfoRepository.findById(id).get();
            String jobName = jobInfoEntity.getJobName();
            String groupName = jobInfoEntity.getJobGroup();
            try {
                TriggerKey key = TriggerKey.triggerKey(jobName,groupName);
                //停止触发器
                scheduler.pauseTrigger(key);
                //移除触发器
                scheduler.unscheduleJob(key);
                //删除任务
                boolean flag = scheduler.deleteJob(JobKey.jobKey(jobName,groupName));
                logger.info("定时任务：【{}】删除：{}",jobInfoEntity.getJobTitle(),flag);
                qrtzJobInfoRepository.deleteById(id);
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
        }

    }

    @Override
    public void resumeJob(Integer id) {
        QrtzJobInfoEntity jobInfoEntity = qrtzJobInfoRepository.findById(id).get();
        try {
            JobKey jobKey = JobKey.jobKey(jobInfoEntity.getJobName(), jobInfoEntity.getJobGroup());
            scheduler.resumeJob(jobKey);
            jobInfoEntity.setJobStatus("NORMAL");
            qrtzJobInfoRepository.saveAndFlush(jobInfoEntity);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void pauseJob(Integer id) {
        QrtzJobInfoEntity jobInfoEntity = qrtzJobInfoRepository.findById(id).get();
        try {
            JobKey jobKey = JobKey.jobKey(jobInfoEntity.getJobName(), jobInfoEntity.getJobGroup());
            scheduler.pauseJob(jobKey);
            jobInfoEntity.setJobStatus("PAUSED");
            qrtzJobInfoRepository.saveAndFlush(jobInfoEntity);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void startJob(Integer id) {
        QrtzJobInfoEntity jobInfoEntity = qrtzJobInfoRepository.findById(id).get();
        try {
            JobKey jobKey = JobKey.jobKey(jobInfoEntity.getJobName(),jobInfoEntity.getJobGroup());
            scheduler.triggerJob(jobKey);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void modifyJob(QrtzJobInfoEntity entity) {
        try {
            TriggerKey triggerKey = TriggerKey.triggerKey(entity.getJobName(),entity.getJobGroup());
            //表达式调度构建器(即任务执行的时间)
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(entity.getJobCron());
            //按新的cronExpression表达式构建一个新的trigger
            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(entity.getJobName(),entity.getJobGroup()).withSchedule(scheduleBuilder).build();
            scheduler.rescheduleJob(triggerKey,trigger);
            entity.setJobStatus("NORMAL");
            qrtzJobInfoRepository.saveAndFlush(entity);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }

    }
}

前端使用vue写的，就暂时不放代码了，最终结果如下：