1
package com.ruoyi.quartz.domain;
2

3
import java.io.Serializable;
4
import java.util.Date;
5
import javax.validation.constraints.*;
6
import org.apache.commons.lang3.builder.ToStringBuilder;
7
import org.apache.commons.lang3.builder.ToStringStyle;
8
import com.ruoyi.common.annotation.Excel;
9
import com.ruoyi.common.annotation.Excel.ColumnType;
10
import com.ruoyi.common.constant.ScheduleConstants;
11
import com.ruoyi.common.core.domain.BaseEntity;
12
import com.ruoyi.common.utils.StringUtils;
13
import com.ruoyi.quartz.util.CronUtils;
14

15
/**
16
 * 定时任务调度表 sys_job
17
 *
18
 * @author ruoyi
19
 */
20
public class SysJob extends BaseEntity implements Serializable {
21
    private static final long serialVersionUID = 1L;
22

23
    /** 任务ID */
24
    @Excel(name = "任务序号", cellType = ColumnType.NUMERIC)
25
    private Long jobId;
26

27
    /** 任务名称 */
28
    @Excel(name = "任务名称")
29
    private String jobName;
30

31
    /** 任务组名 */
32
    @Excel(name = "任务组名")
33
    private String jobGroup;
34

35
    /** 调用目标字符串 */
36
    @Excel(name = "调用目标字符串")
37
    private String invokeTarget;
38

39
    /** cron执行表达式 */
40
    @Excel(name = "cron执行表达式")
41
    private String cronExpression;
42

43
    /** cron计划策略 */
44
    @Excel(name = "cron计划策略", readConverterExp = "0=立即执行,1=执行一次,2=放弃执行")
45
    private String misfirePolicy = ScheduleConstants.MISFIRE_DEFAULT;
46

47
    /** 是否并发执行（0允许 1禁止） */
48
    @Excel(name = "并发执行", readConverterExp = "0=允许,1=禁止")
49
    private String concurrent;
50

51
    /** 任务状态（0正常 1暂停） */
52
    @Excel(name = "任务状态", readConverterExp = "0=正常,1=暂停")
53
    private String status;
54

55
    /** 备注 */
56
    private String remark;
57

58
    public Long getJobId() {
59
        return jobId;
60
    }
61

62
    public void setJobId(Long jobId) {
63
        this.jobId = jobId;
64
    }
65

66
    @NotBlank(message = "任务名称不能为空")
67
    @Size(min = 0, max = 64, message = "任务名称不能超过64个字符")
68
    public String getJobName() {
69
        return jobName;
70
    }
71

72
    public void setJobName(String jobName) {
73
        this.jobName = jobName;
74
    }
75

76
    public String getJobGroup() {
77
        return jobGroup;
78
    }
79

80
    public void setJobGroup(String jobGroup) {
81
        this.jobGroup = jobGroup;
82
    }
83

84
    @NotBlank(message = "调用目标字符串不能为空")
85
    @Size(min = 0, max = 500, message = "调用目标字符串长度不能超过500个字符")
86
    public String getInvokeTarget() {
87
        return invokeTarget;
88
    }
89

90
    public void setInvokeTarget(String invokeTarget) {
91
        this.invokeTarget = invokeTarget;
92
    }
93

94
    @NotBlank(message = "Cron执行表达式不能为空")
95
    @Size(min = 0, max = 255, message = "Cron执行表达式长度不能超过255个字符")
96
    public String getCronExpression() {
97
        return cronExpression;
98
    }
99

100
    public void setCronExpression(String cronExpression) {
101
        this.cronExpression = cronExpression;
102
    }
103

104
    public Date getNextValidTime() {
105
        if (StringUtils.isNotEmpty(cronExpression)) {
106
            return CronUtils.getNextExecution(cronExpression);
107
        }
108
        return null;
109
    }
110

111
    public String getMisfirePolicy() {
112
        return misfirePolicy;
113
    }
114

115
    public void setMisfirePolicy(String misfirePolicy) {
116
        this.misfirePolicy = misfirePolicy;
117
    }
118

119
    public String getConcurrent() {
120
        return concurrent;
121
    }
122

123
    public void setConcurrent(String concurrent) {
124
        this.concurrent = concurrent;
125
    }
126

127
    public String getStatus() {
128
        return status;
129
    }
130

131
    public void setStatus(String status) {
132
        this.status = status;
133
    }
134

135
    @Override
136
    public String toString() {
137
        return new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE)
138
            .append("jobId", getJobId())
139
            .append("jobName", getJobName())
140
            .append("jobGroup", getJobGroup())
141
            .append("cronExpression", getCronExpression())
142
            .append("nextValidTime", getNextValidTime())
143
            .append("misfirePolicy", getMisfirePolicy())
144
            .append("concurrent", getConcurrent())
145
            .append("status", getStatus())
146
            .append("createBy", getCreateBy())
147
            .append("createTime", getCreateTime())
148
            .append("updateBy", getUpdateBy())
149
            .append("updateTime", getUpdateTime())
150
            .append("remark", getRemark())
151
            .toString();
152
    }
153
}

1
package com.ruoyi.quartz.service.impl;
2

3
import java.util.List;
4
import javax.annotation.PostConstruct;
5
import org.quartz.JobDataMap;
6
import org.quartz.JobKey;
7
import org.quartz.Scheduler;
8
import org.quartz.SchedulerException;
9
import org.springframework.beans.factory.annotation.Autowired;
10
import org.springframework.stereotype.Service;
11
import org.springframework.transaction.annotation.Transactional;
12
import com.ruoyi.common.constant.ScheduleConstants;
13
import com.ruoyi.common.core.text.Convert;
14
import com.ruoyi.common.exception.ServiceException;
15
import com.ruoyi.common.utils.StringUtils;
16
import com.ruoyi.quartz.domain.SysJob;
17
import com.ruoyi.quartz.mapper.SysJobMapper;
18
import com.ruoyi.quartz.service.ISysJobService;
19
import com.ruoyi.quartz.util.CronUtils;
20
import com.ruoyi.quartz.util.ScheduleUtils;
21

22
/**
23
 * 定时任务调度信息 服务层
24
 *
25
 * @author ruoyi
26
 */
27
@Service
28
public class SysJobServiceImpl implements ISysJobService {
29
    @Autowired
30
    private Scheduler scheduler;
31

32
    @Autowired
33
    private SysJobMapper jobMapper;
34

35
    /**
36
     * 项目启动时，初始化调度器 主要是防止手动修改数据库导致未同步到定时任务处理
37
     */
38
    @PostConstruct
39
    public void init() throws SchedulerException {
40
        scheduler.clear();
41
        List<SysJob> jobList = jobMapper.selectJobAll();
42
        for (SysJob job : jobList) {
43
            ScheduleUtils.createScheduleJob(scheduler, job);
44
        }
45
    }
46

47
    /**
48
     * 获取quartz调度器的计划任务列表
49
     */
50
    @Override
51
    public List<SysJob> selectJobList(SysJob job) {
52
        return jobMapper.selectJobList(job);
53
    }
54

55
    /**
56
     * 通过调度任务ID查询调度信息
57
     */
58
    @Override
59
    public SysJob selectJobById(Long jobId) {
60
        return jobMapper.selectJobById(jobId);
61
    }
62

63
    /**
64
     * 暂停任务
65
     */
66
    @Override
67
    @Transactional
68
    public int pauseJob(SysJob job) throws SchedulerException {
69
        Long jobId = job.getJobId();
70
        String jobGroup = job.getJobGroup();
71
        SysJob properties = selectJobById(jobId);
72
        // 暂停任务
73
        scheduler.pauseJob(ScheduleUtils.getJobKey(jobId, jobGroup));
74
        properties.setStatus(ScheduleConstants.Status.PAUSE.getValue());
75
        return jobMapper.updateJob(properties);
76
    }
77

78
    /**
79
     * 恢复任务
80
     */
81
    @Override
82
    @Transactional
83
    public int resumeJob(SysJob job) throws SchedulerException {
84
        Long jobId = job.getJobId();
85
        String jobGroup = job.getJobGroup();
86
        SysJob properties = selectJobById(jobId);
87
        // 恢复任务
88
        scheduler.resumeJob(ScheduleUtils.getJobKey(jobId, jobGroup));
89
        properties.setStatus(ScheduleConstants.Status.NORMAL.getValue());
90
        return jobMapper.updateJob(properties);
91
    }
92

93
    /**
94
     * 删除任务后，所对应的trigger也将被删除
95
     */
96
    @Override
97
    @Transactional
98
    public int deleteJob(SysJob job) throws SchedulerException {
99
        Long jobId = job.getJobId();
100
        String jobGroup = job.getJobGroup();
101
        // 删除任务
102
        scheduler.deleteJob(ScheduleUtils.getJobKey(jobId, jobGroup));
103
        return jobMapper.deleteJobById(jobId);
104
    }
105

106
    /**
107
     * 批量删除调度信息
108
     */
109
    @Override
110
    @Transactional
111
    public void deleteJobByIds(String ids) throws SchedulerException {
112
        Long[] jobIds = Convert.toLongArray(ids);
113
        for (Long jobId : jobIds) {
114
            SysJob job = jobMapper.selectJobById(jobId);
115
            deleteJob(job);
116
        }
117
    }
118

119
    /**
120
     * 任务调度状态修改
121
     */
122
    @Override
123
    @Transactional
124
    public int changeStatus(SysJob job) throws SchedulerException {
125
        int rows = 0;
126
        String status = job.getStatus();
127
        if (ScheduleConstants.Status.NORMAL.getValue().equals(status)) {
128
            rows = resumeJob(job);
129
        } else if (ScheduleConstants.Status.PAUSE.getValue().equals(status)) {
130
            rows = pauseJob(job);
131
        }
132
        return rows;
133
    }
134

135
    /**
136
     * 立即运行任务
137
     */
138
    @Override
139
    @Transactional
140
    public void run(SysJob job) throws SchedulerException {
141
        Long jobId = job.getJobId();
142
        SysJob tmpObj = selectJobById(jobId);
143
        // 参数
144
        JobDataMap dataMap = new JobDataMap();
145
        dataMap.put(ScheduleConstants.TASK_PROPERTIES, tmpObj);
146
        scheduler.triggerJob(ScheduleUtils.getJobKey(jobId, tmpObj.getJobGroup()), dataMap);
147
    }
148

149
    /**
150
     * 新增任务
151
     */
152
    @Override
153
    @Transactional
154
    public int insertJob(SysJob job) throws SchedulerException {
155
        job.setStatus(ScheduleConstants.Status.PAUSE.getValue());
156
        int rows = jobMapper.insertJob(job);
157
        if (rows > 0) {
158
            ScheduleUtils.createScheduleJob(scheduler, job);
159
        }
160
        return rows;
161
    }
162

163
    /**
164
     * 更新任务的时间表达式
165
     */
166
    @Override
167
    @Transactional
168
    public int updateJob(SysJob job) throws SchedulerException {
169
        SysJob properties = selectJobById(job.getJobId());
170
        int rows = jobMapper.updateJob(job);
171
        if (rows > 0) {
172
            updateSchedulerJob(job, properties.getJobGroup());
173
        }
174
        return rows;
175
    }
176

177
    /**
178
     * 更新任务
179
     */
180
    public void updateSchedulerJob(SysJob job, String jobGroup) throws SchedulerException {
181
        Long jobId = job.getJobId();
182
        // 判断是否存在
183
        JobKey jobKey = ScheduleUtils.getJobKey(jobId, jobGroup);
184
        if (scheduler.checkExists(jobKey)) {
185
            // 防止创建时触发器还未开始就删除了
186
            scheduler.deleteJob(jobKey);
187
        }
188
        ScheduleUtils.createScheduleJob(scheduler, job);
189
    }
190

191
    /**
192
     * 校验cron表达式是否有效
193
     */
194
    @Override
195
    public boolean checkCronExpressionIsValid(SysJob job) {
196
        return CronUtils.isValid(job.getCronExpression());
197
    }
198
}

1
package com.ruoyi.quartz.util;
2

3
import org.quartz.*;
4
import com.ruoyi.common.constant.ScheduleConstants;
5
import com.ruoyi.common.exception.ServiceException;
6
import com.ruoyi.common.utils.StringUtils;
7
import com.ruoyi.quartz.domain.SysJob;
8

9
/**
10
 * 定时任务工具类
11
 *
12
 * @author ruoyi
13
 */
14
public class ScheduleUtils {
15
    /**
16
     * 得到quartz任务类
17
     */
18
    private static Class<? extends Job> getQuartzJobClass(SysJob sysJob) {
19
        boolean isConcurrent = "0".equals(sysJob.getConcurrent());
20
        return isConcurrent ? QuartzJobExecution.class : QuartzDisallowConcurrentExecution.class;
21
    }
22

23
    /**
24
     * 构建任务触发对象
25
     */
26
    public static TriggerKey getTriggerKey(Long jobId, String jobGroup) {
27
        return TriggerKey.triggerKey(ScheduleConstants.TASK_CLASS_NAME + jobId, jobGroup);
28
    }
29

30
    /**
31
     * 构建任务键对象
32
     */
33
    public static JobKey getJobKey(Long jobId, String jobGroup) {
34
        return JobKey.jobKey(ScheduleConstants.TASK_CLASS_NAME + jobId, jobGroup);
35
    }
36

37
    /**
38
     * 创建定时任务
39
     */
40
    public static void createScheduleJob(Scheduler scheduler, SysJob job) {
41
        try {
42
            Class<? extends Job> jobClass = getQuartzJobClass(job);
43
            // 构建job信息
44
            Long jobId = job.getJobId();
45
            String jobGroup = job.getJobGroup();
46
            JobDetail jobDetail = JobBuilder.newJob(jobClass)
47
                    .withIdentity(getJobKey(jobId, jobGroup))
48
                    .build();
49

50
            // 表达式调度构建器
51
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder
52
                    .cronSchedule(job.getCronExpression());
53
            cronScheduleBuilder = handleCronScheduleMisfirePolicy(job, cronScheduleBuilder);
54

55
            // 按新的cronExpression表达式构建一个新的trigger
56
            CronTrigger trigger = TriggerBuilder.newTrigger()
57
                    .withIdentity(getTriggerKey(jobId, jobGroup))
58
                    .withSchedule(cronScheduleBuilder)
59
                    .build();
60

61
            // 放入参数，运行时的方法可以获取
62
            jobDetail.getJobDataMap().put(ScheduleConstants.TASK_PROPERTIES, job);
63

64
            // 判断是否存在
65
            if (scheduler.checkExists(getJobKey(jobId, jobGroup))) {
66
                // 防止创建时触发器还未开始就删除了
67
                scheduler.deleteJob(getJobKey(jobId, jobGroup));
68
            }
69

70
            scheduler.scheduleJob(jobDetail, trigger);
71

72
            // 暂停任务
73
            if (job.getStatus().equals(ScheduleConstants.Status.PAUSE.getValue())) {
74
                scheduler.pauseJob(getJobKey(jobId, jobGroup));
75
            }
76
        } catch (SchedulerException e) {
77
            throw new ServiceException("创建定时任务失败");
78
        }
79
    }
80

81
    /**
82
     * 设置定时任务策略
83
     */
84
    public static CronScheduleBuilder handleCronScheduleMisfirePolicy(SysJob job,
85
            CronScheduleBuilder cb) throws ServiceException {
86
        switch (job.getMisfirePolicy()) {
87
            case ScheduleConstants.MISFIRE_DEFAULT:
88
                return cb;
89
            case ScheduleConstants.MISFIRE_IGNORE_MISFIRES:
90
                return cb.withMisfireHandlingInstructionIgnoreMisfires();
91
            case ScheduleConstants.MISFIRE_FIRE_AND_PROCEED:
92
                return cb.withMisfireHandlingInstructionFireAndProceed();
93
            case ScheduleConstants.MISFIRE_DO_NOTHING:
94
                return cb.withMisfireHandlingInstructionDoNothing();
95
            default:
96
                throw new ServiceException("未知任务策略");
97
        }
98
    }
99
}

1
package com.ruoyi.quartz.util;
2

3
import org.quartz.JobExecutionContext;
4
import org.quartz.JobExecutionException;
5
import com.ruoyi.quartz.domain.SysJob;
6

7
/**
8
 * 定时任务处理（允许并发执行）
9
 *
10
 * @author ruoyi
11
 */
12
public class QuartzJobExecution extends AbstractQuartzJob {
13
    @Override
14
    protected void doExecute(JobExecutionContext context, SysJob sysJob) throws Exception {
15
        JobInvokeUtil.invokeMethod(sysJob);
16
    }
17
}
18

19
// src/main/java/com/ruoyi/quartz/util/QuartzDisallowConcurrentExecution.java
20
package com.ruoyi.quartz.util;
21

22
import org.quartz.DisallowConcurrentExecution;
23
import org.quartz.JobExecutionContext;
24
import com.ruoyi.quartz.domain.SysJob;
25

26
/**
27
 * 定时任务处理（禁止并发执行）
28
 *
29
 * @author ruoyi
30
 */
31
@DisallowConcurrentExecution
32
public class QuartzDisallowConcurrentExecution extends AbstractQuartzJob {
33
    @Override
34
    protected void doExecute(JobExecutionContext context, SysJob sysJob) throws Exception {
35
        JobInvokeUtil.invokeMethod(sysJob);
36
    }
37
}