spring-boot quartz定时任务

基本功能

串并行控制
定时任务(CRUD)
定时任务启停
立即执行定时任务

相关代码

并行任务

QuartzJobFactory.java

import com.tld.admin.entity.business.SysJob;
import org.quartz.Job;
import org.quartz.JobExecutionContext;

import javax.annotation.Resource;

/**
 * 计划任务执行处 无状态
 *
 * @author ming
 * @version 1.0.0
 * @date 2019/8/30 14:34
 */
public class QuartzJobFactory implements Job {

    @Resource
    private SysJobExecutor jobExecutor;

    @Override
    public void execute(JobExecutionContext context) {
        jobExecutor.invokeMethod((SysJob) context.getMergedJobDataMap().get("admin_schedule_job"));
    }
}

串行任务

QuartzJobFactoryDisallowConcurrentExecution.java

import com.tld.admin.entity.business.SysJob;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobExecutionContext;

import javax.annotation.Resource;

/**
 * 若一个方法一次执行不完下次轮转时则等待改方法执行完后才执行下一次操作
 * 该任务未串行任务
 *
 * @author ming
 * @version 1.0.0
 * @date 2019/8/30 14:34
 */
@DisallowConcurrentExecution
public class QuartzJobFactoryDisallowConcurrentExecution implements Job {

    @Resource
    private SysJobExecutor jobExecutor;

    @Override
    public void execute(JobExecutionContext context) {
        jobExecutor.invokeMethod((SysJob) context.getMergedJobDataMap().get("admin_schedule_job"));
    }

}

任务执行器

SysJobExecutor.java

import com.tld.admin.common.utils.SpringUtil;
import com.tld.admin.entity.business.SysJob;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * 定时任务工具
 *
 * @author ming
 * @version 1.0.0
 * @date 2019/8/30 14:34
 */
@Slf4j
@Component
public class SysJobExecutor {

    /**
     * 调用SysJob中定义的方法
     *
     * @param sysJob job
     */
    public void invokeMethod(SysJob sysJob) {
        Object object = null;
        Class<?> clazz;
        if (StringUtils.isNotBlank(sysJob.getBeanClass())) {
            try {
                object = SpringUtil.getBean(sysJob.getBeanClass());
                if(ObjectUtils.isEmpty(object)){
                    log.error(String.format("任务名称 = [ %s ] --------------- 未找到该类！！！", sysJob.getJobName()));
                }
            } catch (Exception e) {
                object = null;
                e.printStackTrace();
            }
        }
        if (ObjectUtils.isEmpty(object)) {
            log.error(String.format("任务名称 = [ %s ] --------------- 未启动成功，请检查是否配置正确！！！", sysJob.getJobName()));
            return;
        }
        clazz = object.getClass();
        Method method = null;
        try {
            if (sysJob.getParams() != null && !"".equals(sysJob.getParams())) {
                method = clazz.getDeclaredMethod(sysJob.getMethodName(), String.class);
            } else {
                method = clazz.getDeclaredMethod(sysJob.getMethodName());
            }
        } catch (NoSuchMethodException e) {
            log.error(String.format("任务名称 = [ %s ] --------------- 未启动成功，方法名设置错误！！！", sysJob.getJobName()));
        } catch (SecurityException e) {
            log.error(e.getMessage(), e);
        }
        if (method != null) {
            try {
                if (sysJob.getParams() != null && !"".equals(sysJob.getParams())) {
                    method.invoke(object, sysJob.getParams());
                } else {
                    method.invoke(object);
                }
            } catch (Exception e) {
                log.error(e.getMessage(), e);
            }
        }
        log.debug(String.format("任务名称 = [ %s ] ---------- 执行成功", sysJob.getJobName()));
    }

}

任务注册器

SysJobRegistrar.java

import com.tld.admin.entity.business.SysJob;
import org.quartz.*;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * @author ming
 * @version 1.0.0
 * @date 2020/10/12 10:29
 **/
@Component
public class SysJobRegistrar {

    @Resource
    private SchedulerFactoryBean schedulerFactoryBean;

    /**
     * 新增定时任务
     *
     * @param job job
     */
    public void addJob(SysJob job) {
        try {
            if (job == null) {
                return;
            }
            Scheduler scheduler = schedulerFactoryBean.getScheduler();
            TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName(), job.getJobGroup());

            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

            // 不存在，创建一个
            if (null == trigger) {
                JobDetail jobDetail;
                // 判断是使用串行任务还是并行任务执行器
                if (SysJobStatus.NORMAL.getCode().equals(job.getConcurrent())) {
                    jobDetail = JobBuilder.newJob(QuartzJobFactory.class).withIdentity(job.getJobName(), job.getJobGroup()).build();
                } else {
                    jobDetail = JobBuilder.newJob(QuartzJobFactoryDisallowConcurrentExecution.class).withIdentity(job.getJobName(), job.getJobGroup()).build();
                }
                jobDetail.getJobDataMap().put("admin_schedule_job", job);
                CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCron());
                trigger = TriggerBuilder.newTrigger().withIdentity(job.getJobName(), job.getJobGroup()).withSchedule(scheduleBuilder).build();
                scheduler.scheduleJob(jobDetail, trigger);
            } else {
                // Trigger已存在，那么更新相应的定时设置
                CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCron());
                // 按新的cronExpression表达式重新构建trigger
                trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
                // 按新的trigger重新设置job执行
                scheduler.rescheduleJob(triggerKey, trigger);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void deleteJob(SysJob sysJob) {
        try {
            Scheduler scheduler = schedulerFactoryBean.getScheduler();
            JobKey jobKey = JobKey.jobKey(sysJob.getJobName(), sysJob.getJobGroup());
            scheduler.deleteJob(jobKey);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 立即运行任务
     *
     * @param sysJob job
     */
    public void runJobNow(SysJob sysJob) {
        try {
            Scheduler scheduler = schedulerFactoryBean.getScheduler();
            JobKey jobKey = JobKey.jobKey(sysJob.getJobName(), sysJob.getJobGroup());
            scheduler.triggerJob(jobKey);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 改变任务状态( 1 -> 运行中 ; 2 -> 已停止)
     *
     * @param sysJob 任务
     * @return boolean
     */
    public boolean changeJobStatus(SysJob sysJob) {
        try {
            if (SysJobStatus.NORMAL.getCode().equals(sysJob.getStatus())) {
                deleteJob(sysJob);
                return false;
            } else {
                addJob(sysJob);
                return true;
            }
        } catch (Exception e) {
            throw new RuntimeException("任务状态修改失败");
        }
    }

}

初始化定时任务

SysJobRunner.java

import com.tld.admin.entity.business.SysJob;
import com.tld.admin.service.business.SysJobService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

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

/**
 * 初始化定时任务
 *
 * @author ming
 * @version 1.0.0
 * @date 2019/8/30
 */
@Component
@Slf4j
public class SysJobRunner implements ApplicationRunner {

    @Resource
    private SysJobService jobService;

    @Resource
    private SysJobRegistrar jobRegistrar;

    @Override
    public void run(ApplicationArguments args) {
        List<SysJob> jobList = jobService.queryNormalJob(SysJobStatus.NORMAL.getCode()).getData();
        if (!CollectionUtils.isEmpty(jobList)) {
            for (SysJob job : jobList) {
                jobRegistrar.addJob(job);
            }
            log.info("定时任务已加载完毕...");
        }else {
            log.warn("暂无可执行的任务...");
        }
    }
}

状态枚举

SysJobStatus.java

/**
 * @author ming
 * @version 1.0.0
 * @date 2020/10/11 22:31
 **/
public enum SysJobStatus {
    /**
     * 定时任务运行状态
     */
    NORMAL("运行中", "1"),
    STOPPED("已停止", "0");

    private String msg;
    private String code;

    SysJobStatus(String msg, String code) {
        this.code = code;
        this.msg = msg;
    }

    public String getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }
}

任务类

SysJobTask.java


import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.util.TimeZone;

/**
 * @author ming
 * @version 1.0.0
 * @date 2020/10/12 15:25
 **/
@Slf4j
@Component("sysJobTask")
public class SysJobTask {

    public void pullBlockInfoDataTask() {
        log.debug("正在执行任务==> pull_block_info_data_task <==");
        long start = System.currentTimeMillis();
        try {
            log.info("执行了任务");
            long end = System.currentTimeMillis();
            long timeConsuming = end - start;
            log.info(String.format("任务执行耗时: %s", figureOutTimeInterval(timeConsuming)));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static String figureOutTimeInterval(long interval) {
        //初始化Formatter的转换格式。
        SimpleDateFormat formatter = new SimpleDateFormat("HH:mm:ss");
        formatter.setTimeZone(TimeZone.getTimeZone("GMT+00:00"));
        String hms = formatter.format(interval);
        System.out.println("耗时 == " + hms);
        return hms;
    }
}

数据库字段

DROP TABLE IF EXISTS `t_sys_job`;
CREATE TABLE `t_sys_job`  (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '唯一标识',
  `job_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL COMMENT '任务名',
  `job_group` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL COMMENT '任务分组',
  `cron` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL COMMENT 'Cron表达式',
  `concurrent` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT '1' COMMENT '是否并行(1 - 并行 , 2 - 串行)',
  `bean_class` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL COMMENT '执行类',
  `method_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL COMMENT '执行方法',
  `params` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL COMMENT '初始化参数',
  `remarks` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL COMMENT '备注',
  `creator` varchar(50) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL COMMENT '创建者ID',
  `modifier` varchar(50) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL COMMENT '修改者ID',
  `create_time` varchar(50) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL COMMENT '创建时间',
  `modify_time` varchar(50) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL COMMENT '修改时间',
  `status` varchar(1) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT '1' COMMENT '执行状态(1 - 运行中 , 0 - 停止 )',
  `valid` tinyint(1) NULL DEFAULT 1 COMMENT '是否有效( 1-有效, 0-无效 )',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8 COLLATE = utf8_bin COMMENT = '定时任务' ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of t_sys_job
-- ----------------------------
INSERT INTO `t_sys_job` VALUES (1, 'sys_task', 'sys_task', '0 */30 * * * ?', '0', 'sysJobTask', 'pullBlockInfoDataTask', '', '系统任务', NULL, NULL, NULL, NULL, '1', 1);

实体类

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import com.tld.admin.entity.BaseEntity;
import lombok.Data;
import lombok.ToString;
import lombok.experimental.Accessors;

import java.io.Serializable;

/**
 * 定时任务 实体类
 *
 * @author ming
 * @version 1.0.0
 * @date 2020-10-11 22:04:27
 **/
@Data
@ToString
@TableName("t_sys_job")
@Accessors(chain = true)
public class SysJob extends BaseEntity<SysJob> {

    /**
     * 任务名
     */
    @TableField("job_name")
    private String jobName;
    /**
     * 任务分组
     */
    @TableField("job_group")
    private String jobGroup;
    /**
     * Cron表达式
     */
    @TableField("cron")
    private String cron;
    /**
     * 执行状态(0 - 停止 ; 1 - 运行中)
     */
    @TableField("concurrent")
    private String concurrent;
    /**
     * 执行类
     */
    @TableField("bean_class")
    private String beanClass;
    /**
     * 执行方法
     */
    @TableField("method_name")
    private String methodName;
    /**
     * 初始化参数
     */
    @TableField("params")
    private String params;
    /**
     * 备注
     */
    @TableField("remarks")
    private String remarks;

    /**
     * 状态
     */
    @TableField("status")
    private String status;

    @Override
    protected Serializable pkVal() {
        return this.id;
    }

}

import cn.hutool.core.date.DatePattern;
import com.alibaba.fastjson.annotation.JSONField;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import lombok.experimental.Accessors;

/**
 * 基础实体
 *
 * @author m
 * @date 2020/04/16
 */
@Data
@Accessors(chain = true)
public abstract class BaseEntity<T> extends Model<BaseEntity<T>> {

    private static final long serialVersionUID = 5796049886922555842L;
    @TableId(value = "id")
    public Integer id;

    /**
     * 1 true 0 false
     */
    @TableField("valid")
    public Boolean valid;

    /**
     * 创建者
     */
    @TableField("creator")
    public String creator;

    /**
     * 最后一次修改者
     */
    @TableField("modifier")
    public String modifier;

    /**
     * 创建时间
     */
    @JSONField(format = DatePattern.NORM_DATETIME_PATTERN)
    @JsonFormat(pattern = DatePattern.NORM_DATETIME_PATTERN)
    @TableField(value = "create_time")
    public String createTime;

    /**
     * 修改时间
     */
    @JSONField(format = DatePattern.NORM_DATETIME_PATTERN)
    @JsonFormat(pattern = DatePattern.NORM_DATETIME_PATTERN)
    @TableField(value = "modify_time")
    public String modifyTime;

    /**
     * 查询关键字
     */
    @TableField(exist = false)
    public String searchKey;

    /**
     * 状态（0：正常；1：删除）
     */
    public static final Boolean VALID = true;
    public static final Boolean IN_VALID = false;
}

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

/**
 * @author ming
 * @version 1.0.0
 * @date 2020/10/12 14:06
 **/
@Data
@ApiModel(value = "后台定时任务DTO")
public class SysJobDTO {
    @ApiModelProperty(value = "任务id")
    private Integer id;
    /**
     * 任务名
     */
    @ApiModelProperty(value = "任务名称")
    private String jobName;
    /**
     * 任务分组
     */
    @ApiModelProperty(value = "任务分组")
    private String jobGroup;
    /**
     * Cron表达式
     */
    @ApiModelProperty(value = "cron表达式")
    private String cron;
    /**
     * 是否并行(0 - 否 ; 1 - 是)
     */
    @ApiModelProperty(value = "是否并行执行")
    private String concurrent;
    /**
     * 执行类
     */
    @ApiModelProperty(value = "执行类的bean")
    private String beanClass;
    /**
     * 执行方法
     */
    @ApiModelProperty(value = "方法名")
    private String methodName;
    /**
     * 初始化参数
     */
    @ApiModelProperty(value = "初始化参数")
    private String params;
    /**
     * 备注
     */
    @ApiModelProperty(value = "备注")
    private String remarks;

    /**
     * 状态 1-> 运行中, 0 -> 已停止
     */
    @ApiModelProperty(value = "任务状态")
    private String status;
}

dao

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import com.tld.admin.entity.business.SysJob;

/**
 * 定时任务 mapper
 *
 * @author m
 * @version 1.0.0
 * @date 2020-10-11 22:04:27
 **/
@Mapper
public interface SysJobMapper extends BaseMapper<SysJob> {

}

mapper

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.tld.admin.dao.business.SysJobMapper">

    <resultMap id="SysJobMap" type="com.tld.admin.entity.business.SysJob">
        <result column="id" property="id" />
        <result column="job_name" property="jobName" />
        <result column="job_group" property="jobGroup" />
        <result column="cron" property="cron" />
        <result column="concurrent" property="concurrent" />
        <result column="bean_class" property="beanClass" />
        <result column="method_name" property="methodName" />
        <result column="params" property="params" />
        <result column="remarks" property="remarks" />
        <result column="creator" property="creator" />
        <result column="modifier" property="modifier" />
        <result column="create_time" property="createTime" />
        <result column="modify_time" property="modifyTime" />
        <result column="status" property="status" />
        <result column="valid" property="valid" />
    </resultMap>

    
</mapper>

service

import com.baomidou.mybatisplus.extension.service.IService;
import com.tld.admin.common.handle.ApiResult;
import com.tld.admin.dto.business.SysJobDTO;
import com.tld.admin.entity.business.SysJob;

import java.util.List;

/**
 * 定时任务 Service
 *
 * @author m
 * @version 1.0.0
 * @date 2020-10-11 22:04:27
 **/
public interface SysJobService extends IService<SysJob> {

    /**
     * 查询所有正常的定时任务
     *
     * @param status 任务状态
     * @return List<SysJob>
     */
    ApiResult<List<SysJob>> queryNormalJob(String status);

    /**
     * 新增定时任务
     *
     * @param sysJob 定时任务对象
     * @return String
     */
    ApiResult<String> addNewJob(SysJobDTO sysJob);

    /**
     * 修改定时任务
     *
     * @param sysJob 定时任务对象
     * @return String
     */
    ApiResult<String> editJob(SysJobDTO sysJob);

    /**
     * 删除定时任务
     *
     * @param id 任务编号
     * @return String
     */
    ApiResult<String> deleteJob(Integer id);

    /**
     * 启停定时任务
     *
     * @param id 任务编号
     * @return String
     */
    ApiResult<String> startOrStopJob(Integer id);

    /**
     * 立即执行任务
     *
     * @param id 任务编号
     * @return String
     */
    ApiResult<String> runJobNow(Integer id);

}

impl

import cn.hutool.core.date.DatePattern;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.tld.admin.common.handle.ApiResult;
import com.tld.admin.config.quartz.SysJobRegistrar;
import com.tld.admin.config.quartz.SysJobStatus;
import com.tld.admin.dao.business.SysJobMapper;
import com.tld.admin.dto.business.SysJobDTO;
import com.tld.admin.entity.business.SysJob;
import com.tld.admin.service.business.SysJobService;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;


/**
 * 定时任务 Impl
 *
 * @author m
 * @version 1.0.0
 * @date 2020-10-11 22:04:27
 **/
@Service
public class SysJobServiceImpl extends ServiceImpl<SysJobMapper, SysJob> implements SysJobService {

    @Resource
    private SysJobMapper jobMapper;

    @Resource
    private SysJobRegistrar jobRegistrar;

    /**
     * 查询所有正常的定时任务
     *
     * @param status 任务状态
     * @return List<SysJob>
     */
    @Override
    public ApiResult<List<SysJob>> queryNormalJob(String status) {
        List<SysJob> sysJob = jobMapper.selectList(new QueryWrapper<SysJob>().lambda()
                .eq(SysJob::getStatus, status)
                .and(queryWrapper -> queryWrapper.eq(SysJob::getValid, true)));
        return ApiResult.successOf(sysJob);
    }

    /**
     * 新增定时任务
     *
     * @param sysJob 定时任务对象
     * @return String
     */
    @Override
    public ApiResult<String> addNewJob(SysJobDTO sysJob) {
        SysJob job = jobDto2Entity(sysJob);
        job.setId(null);
        int r = jobMapper.insert(job);
        if (r <= 0) {
            return ApiResult.failOf("新增失败");
        }
        if (SysJobStatus.NORMAL.getCode().equals(sysJob.getStatus())) {
            jobRegistrar.addJob(job);
        }
        return ApiResult.successOf("新增成功");
    }

    /**
     * 修改定时任务
     *
     * @param sysJob 定时任务对象
     * @return String
     */
    @Override
    public ApiResult<String> editJob(SysJobDTO sysJob) {
        SysJob job = jobDto2Entity(sysJob);
        int r = jobMapper.updateById(job);
        if (r <= 0) {
            return ApiResult.failOf("修改失败");
        }
        SysJob existedJob = jobMapper.selectOne(new QueryWrapper<SysJob>().lambda()
                .eq(SysJob::getId, job.getId())
                .and(queryWrapper -> queryWrapper.eq(SysJob::getValid, true)));
        // 移除旧的任务
        if (SysJobStatus.NORMAL.getCode().equals(existedJob.getStatus())) {
            jobRegistrar.deleteJob(existedJob);
        }
        // 添加新的任务
        if (SysJobStatus.NORMAL.getCode().equals(job.getStatus())) {
            jobRegistrar.addJob(job);
        }
        return ApiResult.successOf("修改成功");
    }

    /**
     * 删除定时任务
     *
     * @param id 任务编号
     * @return String
     */
    @Override
    public ApiResult<String> deleteJob(Integer id) {
        SysJob existedJob = jobMapper.selectOne(new QueryWrapper<SysJob>().lambda()
                .eq(SysJob::getId, id)
                .and(queryWrapper -> queryWrapper.eq(SysJob::getValid, true)));
        existedJob.setValid(false);
        int r = jobMapper.updateById(existedJob);
        if (r <= 0) {
            return ApiResult.failOf("删除失败");
        }
        if (SysJobStatus.NORMAL.getCode().equals(existedJob.getStatus())) {
            jobRegistrar.deleteJob(existedJob);
        }
        return ApiResult.successOf("删除成功");
    }

    /**
     * 启停定时任务
     *
     * @param id 任务编号
     * @return String
     */
    @Override
    public ApiResult<String> startOrStopJob(Integer id) {
        try {
            SysJob existedJob = jobMapper.selectOne(new QueryWrapper<SysJob>().lambda()
                    .eq(SysJob::getId, id)
                    .and(queryWrapper -> queryWrapper.eq(SysJob::getValid, true)));

            if (!jobRegistrar.changeJobStatus(existedJob)) {
                existedJob.setStatus(SysJobStatus.STOPPED.getCode());
                int i = jobMapper.updateById(existedJob);
                if (i <= 0) {
                    return ApiResult.successOf("关闭失败");
                }
                return ApiResult.successOf("关闭成功");
            } else {
                existedJob.setStatus(SysJobStatus.NORMAL.getCode());
                int i = jobMapper.updateById(existedJob);
                if (i <= 0) {
                    return ApiResult.successOf("开启失败");
                }
                return ApiResult.successOf("开启成功");
            }
        } catch (Exception e) {
            return ApiResult.failOf(e.getMessage());
        }
    }

    /**
     * 立即执行任务(由于其他原因导致的任务挂掉，但是数据库状态没有修改的情况下，来重启任务)
     *
     * @param id 任务编号
     * @return String
     */
    @Override
    public ApiResult<String> runJobNow(Integer id) {
        SysJob sysJob = jobMapper.selectOne(new QueryWrapper<SysJob>().lambda()
                .eq(SysJob::getId, id)
                .and(queryWrapper -> queryWrapper.eq(SysJob::getValid, true)));
        if (ObjectUtils.isEmpty(sysJob)) {
            return ApiResult.failOf("任务执行失败");
        }

        jobRegistrar.runJobNow(sysJob);
        return ApiResult.failOf("任务执行成功");
    }

    private static SysJob jobDto2Entity(SysJobDTO sysJob) {
        SysJob job = new SysJob();
        job.setJobName(sysJob.getJobName())
                .setJobGroup(sysJob.getJobGroup())
                .setStatus(sysJob.getStatus())
                .setConcurrent(sysJob.getConcurrent())
                .setBeanClass(sysJob.getBeanClass())
                .setCron(sysJob.getCron())
                .setMethodName(sysJob.getMethodName())
                .setParams(sysJob.getParams())
                .setRemarks(sysJob.getRemarks())
                .setCreateTime(LocalDateTime.now().format(DateTimeFormatter.ofPattern(DatePattern.NORM_DATETIME_PATTERN)))
                .setId(sysJob.getId());
        return job;
    }
}

controller

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.tld.admin.annotation.SysLog;
import com.tld.admin.common.handle.ApiResult;
import com.tld.admin.dto.business.SysJobDTO;
import com.tld.admin.entity.business.SysJob;
import com.tld.admin.service.business.SysJobService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;

/**
 * 定时任务 控制层
 *
 * @author ming
 * @version 1.0.0
 * @date 2020-10-11 22:04:27
 **/
@RestController
@RequestMapping("job")
@Api(tags = "定时任务模块")
public class SysJobController {

    @Resource
    private SysJobService sysJobService;

    @GetMapping()
    //@RequiresPermissions("job:list")
    @ApiOperation(value = "定时任务列表")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "当前页码", name = "current", dataType = "int", paramType = "query", defaultValue = "1"),
            @ApiImplicitParam(value = "分页大小", name = "size", dataType = "int", paramType = "query", defaultValue = "10")
    })
    public ApiResult fetchJobs(@RequestParam(required = false, defaultValue = "1") Integer current,
                               @RequestParam(required = false, defaultValue = "10") Integer size) {
        Page<SysJob> page = sysJobService.page(new Page<>(current, size), new QueryWrapper<SysJob>().lambda().eq(SysJob::getValid, true));
        return ApiResult.successOf(page);
    }

    @PostMapping()
    //@RequiresPermissions("job:add")
    @ApiOperation(value = "新增定时任务")
    @SysLog(value = "新增用户", type = 1)
    public ApiResult addJob(@ModelAttribute SysJobDTO sysJob) {
        return sysJobService.addNewJob(sysJob);
    }

    @PutMapping()
    //@RequiresPermissions("job:edit")
    @ApiOperation(value = "修改定时任务")
    public ApiResult editJob(@ModelAttribute SysJobDTO sysJob) {
        return sysJobService.editJob(sysJob);
    }

    @DeleteMapping("/{id}")
    //@RequiresPermissions("job:delete")
    @ApiOperation(value = "删除定时任务")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "任务编号", name = "id", dataType = "int", paramType = "path"),
    })
    public ApiResult deleteJob(@PathVariable("id") Integer id) {
        return sysJobService.deleteJob(id);
    }

    @PutMapping("/{id}")
    //@RequiresPermissions("job:status")
    @ApiOperation(value = "启停定时任务")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "任务编号", name = "id", dataType = "int", paramType = "path"),
    })
    public ApiResult startOrStopJob(@PathVariable("id") Integer id) {
        return sysJobService.startOrStopJob(id);
    }

    @PutMapping("execution/{id}")
    //@RequiresPermissions("job:execution")
    @ApiOperation(value = "立即执行定时任务")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "任务编号", name = "id", dataType = "int", paramType = "path"),
    })
    public ApiResult runJobNow(@PathVariable("id") Integer id) {
        return sysJobService.runJobNow(id);
    }
}

相关阅读:
css 超出两行省略号,超出一行省略号
 css 去掉i标签默认斜体样式
 Spring 使用单选按钮
 Spring Maven工程引入css,js
Sping 补充完成修改功能
 Spring 控制器层如何启用验证？
Spring 控制器层如何调用DAO层
 spring boot工程如何启用热启动功能
 Spring 视图层如何显示验证消息提示
 Sping POJO中如何添加验证规则和验证消息提示
原文地址：https://www.cnblogs.com/jockming/p/13808470.html

spring-boot quartz定时任务

spring-boot quartz定时任务

基本功能

相关依赖

相关代码

并行任务

串行任务

任务执行器

任务注册器

初始化定时任务

状态枚举

任务类

数据库字段

实体类

dao

mapper

service

impl

controller