Quartz任务调度动态管理定时任务

在pom.xml导入jar包

 <dependency>
   <groupId>org.quartz-scheduler</groupId>
   <artifactId>quartz</artifactId>
   <version>2.3.0</version>
 </dependency>
 <dependency>
   <groupId>com.mchange</groupId>
   <artifactId>c3p0</artifactId>
   <version>0.9.5.4</version>
 </dependency>

properties配置文件

# 将 Quartz 持久化方式修改为 jdbc
spring.quartz.job-store-type=jdbc
# 实例名称（默认为quartzScheduler）
spring.quartz.properties.org.quartz.scheduler.instanceName=SC_Scheduler
# 实例节点 ID 自动生成
spring.quartz.properties.org.quartz.scheduler.instanceId=AUTO
# 修改存储内容使用的类
spring.quartz.properties.org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
# 数据源信息
spring.quartz.properties.org.quartz.jobStore.dataSource=quartz_jobs
spring.quartz.properties.org.quartz.dataSource.quartz_jobs.driver=com.mysql.cj.jdbc.Driver
spring.quartz.properties.org.quartz.dataSource.quartz_jobs.URL=jdbc:mysql://127.0.0.1:3306/quartz_jobs?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8
spring.quartz.properties.org.quartz.dataSource.quartz_jobs.user=root
spring.quartz.properties.org.quartz.dataSource.quartz_jobs.password=123456

yml配置文件 

quartz:
    job-store-type: jdbc
    properties:
      org:
        quartz:
          dataSource:
              quartz_jobs:
                URL: jdbc:mysql://127.0.0.1:3306/chain_hotel? 
                serverTimezone=UTC&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true
                user: root
                password: root
                driver: com.mysql.cj.jdbc.Driver
          scheduler:
            instanceName: SC_Scheduler
            instanceId: AUTO
          jobStore:
            dataSource: quartz_jobs
            class: org.quartz.impl.jdbcjobstore.JobStoreTX

 需要提前在数据库中建立表，这里的是mysql需要的表

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;

再建立一张表，用于自己对定时任务进行操作

CREATE TABLE `sc_task_info` (
	`id` INT(10) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
	`cron` VARCHAR(32) NULL DEFAULT NULL COMMENT '定时执行' COLLATE 'utf8_general_ci',
	`job_name` VARCHAR(256) NULL DEFAULT NULL COMMENT '任务名称' COLLATE 'utf8_general_ci',
	`status` CHAR(1) NULL DEFAULT '0' COMMENT '任务开启状态 0-关闭 2-开启' COLLATE 'utf8_general_ci',
	`create_time` DATETIME NULL DEFAULT NULL COMMENT '创建时间',
	`update_time` DATETIME NULL DEFAULT NULL COMMENT '更新时间',
	PRIMARY KEY (`id`) USING BTREE
)
COMMENT='定时任务表'
COLLATE='utf8_general_ci'
ENGINE=InnoDB
ROW_FORMAT=COMPACT
AUTO_INCREMENT=13
;

 TaskInfoDto

数据库的表实例

@Data
@AllArgsConstructor
@NoArgsConstructor
public class TaskInfoDto implements Serializable {
    private String id;
    private String cron;
    private String jobName;
    private String status;
    private Date createTime;
    private Date updateTime;
}

TaskInfoSo

入参实例

@Data
@AllArgsConstructor
@NoArgsConstructor
public class TaskInfoSo {
    /**
     * 任务编号
     */
    private String id;
    /**
     * 任务时间表达式
     */
    private String cron;
    /**
     * 任务状态
     */
    private String status;
    /**
     * 任务名称
     */
    private String jobName;
    /**
     * 每页显示条数
     */
    private int pageSize = 10;
    /**
     * 当前页数
     */
    private int pageCurrent = 1;

springJobFactory

解决job注入的问题，这样就不需要亲自实例化

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;

/**
 * 解决spring bean注入Job的问题
 */
@Component
public class SpringJobFactory extends AdaptableJobFactory {

    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;

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

SpringContextUtils

通过反射获取类对象

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

@Component
@Lazy(false)
public class SpringContextUtils implements ApplicationContextAware {


    // Spring应用上下文环境
    private static ApplicationContext applicationContext;

    /**
     * 实现ApplicationContextAware接口的回调方法，设置上下文环境
     *
     * @param applicationContext
     */
    public void setApplicationContext(ApplicationContext applicationContext) {
        SpringContextUtils.applicationContext = applicationContext;
    }

    /**
     * @return ApplicationContext
     */
    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    /**
     * 获取对象
     * 这里重写了bean方法，起主要作用
     *
     * @param name
     * @return Object 一个以所给名字注册的bean的实例
     * @throws BeansException
     */
    public static <T> T getBean(String name) {
        try {
            return (T) applicationContext.getBean(name);
        } catch (Exception e) {
            return null;
        }
    }

    public static <T> T getBean(Class<T> clazz) {
        try {
            return applicationContext.getBean(clazz);
        } catch (Exception e) {
            return null;
        }
    }
}

QuartzManager

用于启动所有任务

import com.my.hotel.config.SpringJobFactory;
import com.my.hotel.model.So.TaskInfoSo;
import com.my.hotel.model.TaskInfoDto;
import com.my.hotel.services.taskInfo.TaskInfoService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import javax.annotation.PostConstruct;
import java.util.List;

@Component
@Slf4j
public class QuartzManager {
    @Autowired
    private Scheduler scheduler;
    @Autowired
    private SpringJobFactory springJobFactory;
    @Autowired
    private TaskInfoService taskInfoService;

    @PostConstruct
    public void start() {
        //启动所有任务
        try {
//            scheduler.clear();
            scheduler.setJobFactory(springJobFactory);
            List<TaskInfoDto> tasks = taskInfoService.selectAllTasks();
            for (TaskInfoDto taskInfo : tasks) {
//            默认1为开启
                if ("1".equals(taskInfo.getStatus()) && !StringUtils.isEmpty(taskInfo.getCron())) {
                    TaskInfoSo data=new TaskInfoSo();
                    BeanUtils.copyProperties(taskInfo,data);
                    taskInfoService.addJob(data);
                }
            }
            log.info("定时任务启动完成");
        } catch (SchedulerException e) {
            log.error(e.getMessage(), e);
            throw new RuntimeException("定时任务初始化失败");
        }
    }
}

TaskManager

对任务进行操作

import com.my.hotel.model.So.TaskInfoSo;
import com.my.hotel.model.TaskInfoDto;
import com.my.hotel.util.SpringContextUtils;
import lombok.extern.slf4j.Slf4j;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

@Component
@Slf4j
public class TaskManager {
    @Resource
    Scheduler scheduler;
    @Autowired
    SpringContextUtils springContextUtils;

    public static final String JOB_DEFAULT_GROUP_NAME = "JOB_DEFAULT_GROUP_NAME";
    public static final String TRIGGER_DEFAULT_GROUP_NAME = "TRIGGER_DEFAULT_GROUP_NAME";

    public Boolean addJob(TaskInfoSo taskInfoSo) {
        Boolean flag = true;
        if (!CronExpression.isValidExpression(taskInfoSo.getCron())) {
            log.error("表达式错误");
            return false;
        }
        try {
            String className = SpringContextUtils.getBean(taskInfoSo.getJobName()).getClass().getName();
            JobDetail jobDetail = JobBuilder.newJob().withIdentity(new JobKey(taskInfoSo.getJobName(), JOB_DEFAULT_GROUP_NAME))
                    .ofType((Class<? extends Job>) Class.forName(className))
                    .build();
            Trigger trigger = TriggerBuilder.newTrigger()
                    .forJob(jobDetail)
                    .withSchedule(CronScheduleBuilder.cronSchedule(taskInfoSo.getCron()))
                    .withIdentity(new TriggerKey(taskInfoSo.getJobName(), TRIGGER_DEFAULT_GROUP_NAME))
                    .build();
            scheduler.scheduleJob(jobDetail, trigger);
            scheduler.start();
        } catch (Exception e) {
            flag = false;
            e.printStackTrace();
        }
        return flag;
    }

    public boolean updateJob(TaskInfoSo taskInfoSo) {
        boolean flag = true;
        try {
            JobKey jobKey = new JobKey(taskInfoSo.getJobName(), JOB_DEFAULT_GROUP_NAME);
            TriggerKey triggerKey = new TriggerKey(taskInfoSo.getJobName(), TRIGGER_DEFAULT_GROUP_NAME);
            JobDetail jobDetail = scheduler.getJobDetail(jobKey);
            if (scheduler.checkExists(jobKey) && scheduler.checkExists(triggerKey)) {
                Trigger newTrigger = TriggerBuilder.newTrigger()
                        .forJob(jobDetail)
                        .withSchedule(CronScheduleBuilder.cronSchedule(taskInfoSo.getCron()))
                        .withIdentity(triggerKey)
                        .build();
                scheduler.rescheduleJob(triggerKey, newTrigger);
                log.info("更新任务成功，任务名称：{}，表达式：{}", taskInfoSo.getJobName(), taskInfoSo.getCron());
            } else {
                log.info("更新任务失败，任务不存在，任务名称：{}，表达式：{}", taskInfoSo.getJobName(), taskInfoSo.getCron());
                flag = false;
            }
        } catch (SchedulerException e) {
            log.error("更新定时任务失败:{}", e.getMessage(), e);
            flag = false;
        }
        return flag;
    }

    public boolean pauseJob(TaskInfoDto taskInfoDto) {
        try {
            scheduler.pauseJob(JobKey.jobKey(taskInfoDto.getJobName(), JOB_DEFAULT_GROUP_NAME));
            log.info("任务暂停成功：{}", taskInfoDto.getId());
            return true;
        } catch (SchedulerException e) {
            log.error("暂停定时任务失败:{}", e.getMessage(), e);
            return false;
        }
    }

    public boolean resumeJob(TaskInfoDto taskInfoDto) {
        try {
            scheduler.resumeJob(JobKey.jobKey(taskInfoDto.getJobName(), JOB_DEFAULT_GROUP_NAME));
            log.info("任务恢复成功：{}", taskInfoDto.getId());
            return true;
        } catch (SchedulerException e) {
            log.error("恢复定时任务失败:{}", e.getMessage(), e);
            return false;
        }
    }
}

ResponseResult

个人使用的出参

import com.fasterxml.jackson.annotation.JsonInclude;

@JsonInclude(JsonInclude.Include.NON_NULL)
public class ResponseResult<T> {
    /**
     * 状态码
     */
    private Integer code;
    /**
     * 提示信息，如果有错误时，前端可以获取该字段进行提示
     */
    private String msg;
    /**
     * 查询到的结果数据，
     */
    private T data;

    public ResponseResult(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public ResponseResult(Integer code, T data) {
        this.code = code;
        this.data = data;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public ResponseResult(Integer code, String msg, T data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }
}

TaskMapper

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.my.hotel.model.TaskInfoDto;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import java.util.List;

@Mapper
public interface TaskInfoMapper extends BaseMapper<TaskInfoDto> {
    @Insert("insert into sc_task_info set cron = #{cron},job_name = #{jobName},status = '1',create_time = now(),update_time = now()")
    int insertSelective(String cron,String jobName);

    @Select("select * from sc_task_info where job_name = #{jobName}")
    TaskInfoDto selectByJobName(String jobName);

    @Select("select * from sc_task_info")
    List<TaskInfoDto> selectAllTasks();

    @Select("select * from sc_task_info where id = #{id}")
    TaskInfoDto selectByPrimaryKey(String id);
    @Update("update sc_task_info set status=#{status},update_time = now() where id = #{id}")
    void updateByPrimaryKeySelective(String id,String status);

    @Update("update sc_task_info set cron = #{cron},update_time = now() where id = #{id}")
    void updateByPrimaryKeyCron(String id,String cron);
}

TaskInfoService

import com.my.hotel.model.Po.ResponseResult;
import com.my.hotel.model.So.TaskInfoSo;
import com.my.hotel.model.TaskInfoDto;

import java.util.List;

public interface TaskInfoService {
    List<TaskInfoDto> selectAllTasks();
    ResponseResult addJob(TaskInfoSo taskInfoSo);
    ResponseResult pauseJob(TaskInfoSo taskInfoSo);
    ResponseResult resumeJob(TaskInfoSo taskInfoSo);
    ResponseResult updateJob(TaskInfoSo taskInfoSo);
}

TaskInfoServiceImpl

在数据库中进行操作

import com.my.hotel.dao.TaskInfoDao;
import com.my.hotel.manager.TaskManager;
import com.my.hotel.model.Po.ResponseResult;
import com.my.hotel.model.So.TaskInfoSo;
import com.my.hotel.model.TaskInfoDto;
import com.my.hotel.services.taskInfo.TaskInfoService;
import lombok.extern.slf4j.Slf4j;
import org.quartz.CronExpression;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
import java.util.Objects;

@Service
@Slf4j
public class TaskInfoServiceImpl implements TaskInfoService {
    @Resource
    TaskInfoDao taskInfoDao;
    @Resource
    TaskManager taskManager;

    @Override
    public List<TaskInfoDto> selectAllTasks() {
        List<TaskInfoDto> list = taskInfoDao.selectAllTasks();
        return list;
    }

    @Override
    public ResponseResult addJob(TaskInfoSo taskInfoSo) {
        if (!taskManager.addJob(taskInfoSo)) {
            return new ResponseResult(201, "error");
        }
        TaskInfoDto data = taskInfoDao.selectByJobName(taskInfoSo.getJobName());
        //当任务不存在，则返回成功插入
        if (Objects.isNull(data)) {
            data = new TaskInfoDto();
            BeanUtils.copyProperties(taskInfoSo, data);
            data.setCreateTime(new Date());
            taskInfoDao.insertSelective(data);
            return new ResponseResult(200, "success");
        } else {
            return new ResponseResult(201, "error");
        }
    }

    @Override
    public ResponseResult updateJob(TaskInfoSo taskInfoSo) {
        if (!CronExpression.isValidExpression(taskInfoSo.getCron())) {
            log.error("更新任务失败，表达式有误：{}", taskInfoSo.getCron());
            return new ResponseResult(201, "error");
        }
        TaskInfoDto isExistData = taskInfoDao.selectByJobName(taskInfoSo.getJobName());
        //当任务存在，则更改失败
        if ((!Objects.isNull(isExistData)) && (!isExistData.getId().equals(taskInfoSo.getId()))) {
            return new ResponseResult(201, "error");
        }
        TaskInfoDto taskInfoDto = taskInfoDao.selectByPrimaryKey(taskInfoSo.getId());
        if (taskInfoDto == null) {
            return new ResponseResult(201, "error");
        }
        BeanUtils.copyProperties(taskInfoSo, taskInfoDto);
        taskInfoDto.setUpdateTime(new Date());
        if (!taskManager.updateJob(taskInfoSo)) {
            return new ResponseResult(201, "error");
        }
        taskInfoDao.updateByPrimaryKeyCron(taskInfoDto);
        return new ResponseResult(200, "error");
    }

    @Override
    public ResponseResult pauseJob(TaskInfoSo taskInfoSo) {
        TaskInfoDto data = taskInfoDao.selectByPrimaryKey(taskInfoSo.getId());
        if (data == null) {
            return new ResponseResult(201, "error");
        }
        if (!taskManager.pauseJob(data)) {
            return new ResponseResult(201, "error");
        }
        data.setStatus("0");
        taskInfoDao.updateByPrimaryKeySelective(data);
        return new ResponseResult(200, "success");
    }

    @Override
    public ResponseResult resumeJob(TaskInfoSo taskInfoSo) {
        TaskInfoDto data = taskInfoDao.selectByPrimaryKey(taskInfoSo.getId());
        if (data == null) {
            return new ResponseResult(201, "error");
        }
        if (!taskManager.resumeJob(data)) {
            return new ResponseResult(201, "error");
        }
        data.setStatus("1");
        taskInfoDao.updateByPrimaryKeySelective(data);
        return new ResponseResult(200, "success");
    }
}

具体使用（add为例）

写一个job,继承QuartzBean

@Slf4j
@Component
public class Task extends QuartzJobBean {
    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
       
    }

在controller中实现接口 

 @PostMapping("/add")
    public ResponseResult add(@RequestBody TaskInfoSo taskInfoSo) {
        return taskInfoService.addJob(taskInfoSo);
    }

postman进行调用

这里的jobname需要首字母为小写,springContextUtil通过反射才能获取bean

 摘自一猿小讲