Java

引入 maven 依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
<dependencies>
 <!-- quartz -->
 <dependency>
  <groupId>org.quartz-scheduler</groupId>
  <artifactId>quartz</artifactId>
  <version>2.2.1</version>
 </dependency>
 <dependency>
  <groupId>org.quartz-scheduler</groupId>
  <artifactId>quartz-jobs</artifactId>
  <version>2.2.1</version>
 </dependency>
</dependencies>

任务调度类

1
2
3
4
5
6
7
public class MyJob implements Job {

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("quartz MyJob date:" + System.currentTimeMillis());
    }
}

启动类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class JobQuartz {
  public static void main(String[] args) throws SchedulerException {
    //1.创建Scheduler的工厂
    SchedulerFactory sf = new StdSchedulerFactory();
    //2.从工厂中获取调度器实例
    Scheduler scheduler = sf.getScheduler();
    //3.创建JobDetail，
    JobDetail jb = JobBuilder.newJob(MyJob.class)
      //job的描述
      .withDescription("this is a ram job")
      //job 的name和group
      .withIdentity("ramJob", "ramGroup")
      .build();
    //任务运行的时间，SimpleSchedle类型触发器有效，3秒后启动任务
    long time= System.currentTimeMillis() + 3*1000L;
    Date statTime = new Date(time);
    //4.创建Trigger
    //使用SimpleScheduleBuilder或者CronScheduleBuilder
    Trigger t = TriggerBuilder.newTrigger()
      .withDescription("")
      .withIdentity("ramTrigger", "ramTriggerGroup")
      //.withSchedule(SimpleScheduleBuilder.simpleSchedule())
      //默认当前时间启动
      .startAt(statTime)
      //两秒执行一次，Quartz表达式，支持各种牛逼表达式
      .withSchedule(CronScheduleBuilder.cronSchedule("0/2 * * * * ?"))
      .build();
    //5.注册任务和定时器
    scheduler.scheduleJob(jb, t);
    //6.启动 调度器
    scheduler.start();
  }

Spring

pom.xml

1
2
3
4
5
<dependency>
  <groupId>org.quartz-scheduler</groupId>
  <artifactId>quartz</artifactId>
  <version>2.2.1</version>
</dependency>

Spring.xml

1
2
3
4
5
<!-- 开启定时器开关-->
<task:annotation-driven />

<!-- 定时器任务代码所在包位置 -->
<context:component-scan base-package="com.bjtcrj.scm.login.jobs"></context:component-scan>

使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Component
@Slf4j
public class QuartzJobWithAnnotation {
    @Resource
    private DeptService deptService;
  
    @Scheduled(cron = "*/5 * * * * ?")//每隔5秒执行一次
    //@Scheduled(cron = "0 */60 * * * ?")//1小时处理一次
    //@Scheduled(cron = "0 0 1 * * ?")//每天凌晨1点整
    //@Scheduled(cron = "0 30 0 * * ?")//每天凌晨0点30分
    public void work() throws Exception {
        log.info("work:" + LocalDateTime.now());

        List<DeptDto> allDept = deptService.getAllDept();
        log.info("FirstDept:", allDept.get(0).toString());
    }
}

问题

  1. No qualifying bean of type [org.springframework.scheduling.TaskScheduler] is defined

    该提示信息为 DEBUG 级别，可以不必理会

定时任务管理

参考长沙城管项目

pom.xml

1
2
3
4
5
<dependency>
  <groupId>org.quartz-scheduler</groupId>
  <artifactId>quartz</artifactId>
  <version>2.2.1</version>
</dependency>

spring.xml

1
2
3
4
<!-- 定时任务:创建 SchedulerFactoryBean -->
<bean name="startQuertz" lazy-init="false" autowire="no"
      class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
</bean>

SYS_QUARTZ_JOB.sql

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
create table SYS_QUARTZ_JOB
(
	ID VARCHAR2(32) not null,
	JOB_CLASS_NAME VARCHAR2(255),
	CRON_EXPRESSION VARCHAR2(255),
	PARAMETER VARCHAR2(255),
	DESCRIPTION VARCHAR2(255),
	STATUS NUMBER(0)
);

create unique index INDEX33558252
	on SYS_QUARTZ_JOB (ID);

alter table SYS_QUARTZ_JOB
	add constraint CONS134220111
		primary key (ID);

QuartzJob.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package com.bjtcrj.scm.system.persistence.pojo;

import lombok.Data;

@Data
public class QuartzJob {
    /**
    * 主键
    */
    private String id;

    /**
    * 任务类名
    */
    private String jobClassName;

    /**
    * cron表达式
    */
    private String cronExpression;

    /**
    * 参数
    */
    private String parameter;

    /**
    * 描述
    */
    private String description;

    /**
    * 状态 0正常 -1停止
    */
    private int status;
}

QuartzJobDao.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.bjtcrj.scm.system.persistence.dao;

import com.bjtcrj.scm.system.persistence.pojo.QuartzJob;

import java.util.List;

public interface QuartzJobDao {
    int deleteByPrimaryKey(String id);

    int insert(QuartzJob record);

    int insertSelective(QuartzJob record);

    QuartzJob selectByPrimaryKey(String id);

    int updateByPrimaryKeySelective(QuartzJob record);

    int updateByPrimaryKey(QuartzJob record);

    List<QuartzJob> getList(QuartzJob quartzJob);

    List<QuartzJob> findByJobClassName(String jobClassName);
}

QuartzJobDao.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
<?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.bjtcrj.scm.system.persistence.dao.QuartzJobDao">
  <resultMap id="BaseResultMap" type="com.bjtcrj.scm.system.persistence.pojo.QuartzJob">
    <!--@mbg.generated-->
    <!--@Table SYS_QUARTZ_JOB-->
    <id column="ID" jdbcType="VARCHAR" property="id" />
    <result column="JOB_CLASS_NAME" jdbcType="VARCHAR" property="jobClassName" />
    <result column="CRON_EXPRESSION" jdbcType="VARCHAR" property="cronExpression" />
    <result column="PARAMETER" jdbcType="VARCHAR" property="parameter" />
    <result column="DESCRIPTION" jdbcType="VARCHAR" property="description" />
    <result column="STATUS" jdbcType="DECIMAL" property="status" />
  </resultMap>
  <sql id="Base_Column_List">
    <!--@mbg.generated-->
    ID, JOB_CLASS_NAME, CRON_EXPRESSION, "PARAMETER", DESCRIPTION, "STATUS"
  </sql>
  <select id="selectByPrimaryKey" parameterType="java.lang.String" resultMap="BaseResultMap">
    <!--@mbg.generated-->
    select 
    <include refid="Base_Column_List" />
    from SYS_QUARTZ_JOB
    where ID = #{id,jdbcType=VARCHAR}
  </select>
  <delete id="deleteByPrimaryKey" parameterType="java.lang.String">
    <!--@mbg.generated-->
    delete from SYS_QUARTZ_JOB
    where ID = #{id,jdbcType=VARCHAR}
  </delete>
  <insert id="insert" parameterType="com.bjtcrj.scm.system.persistence.pojo.QuartzJob">
    <!--@mbg.generated-->
    insert into SYS_QUARTZ_JOB (ID, JOB_CLASS_NAME, CRON_EXPRESSION, 
      "PARAMETER", DESCRIPTION, "STATUS"
      )
    values (#{id,jdbcType=VARCHAR}, #{jobClassName,jdbcType=VARCHAR}, #{cronExpression,jdbcType=VARCHAR}, 
      #{parameter,jdbcType=VARCHAR}, #{description,jdbcType=VARCHAR}, #{status,jdbcType=DECIMAL}
      )
  </insert>
  <insert id="insertSelective" parameterType="com.bjtcrj.scm.system.persistence.pojo.QuartzJob">
    <!--@mbg.generated-->
    insert into SYS_QUARTZ_JOB
    <trim prefix="(" suffix=")" suffixOverrides=",">
      <if test="id != null">
        ID,
      </if>
      <if test="jobClassName != null">
        JOB_CLASS_NAME,
      </if>
      <if test="cronExpression != null">
        CRON_EXPRESSION,
      </if>
      <if test="parameter != null">
        "PARAMETER",
      </if>
      <if test="description != null">
        DESCRIPTION,
      </if>
      <if test="status != null">
        "STATUS",
      </if>
    </trim>
    <trim prefix="values (" suffix=")" suffixOverrides=",">
      <if test="id != null">
        #{id,jdbcType=VARCHAR},
      </if>
      <if test="jobClassName != null">
        #{jobClassName,jdbcType=VARCHAR},
      </if>
      <if test="cronExpression != null">
        #{cronExpression,jdbcType=VARCHAR},
      </if>
      <if test="parameter != null">
        #{parameter,jdbcType=VARCHAR},
      </if>
      <if test="description != null">
        #{description,jdbcType=VARCHAR},
      </if>
      <if test="status != null">
        #{status,jdbcType=DECIMAL},
      </if>
    </trim>
  </insert>
  <update id="updateByPrimaryKeySelective" parameterType="com.bjtcrj.scm.system.persistence.pojo.QuartzJob">
    <!--@mbg.generated-->
    update SYS_QUARTZ_JOB
    <set>
      <if test="jobClassName != null">
        JOB_CLASS_NAME = #{jobClassName,jdbcType=VARCHAR},
      </if>
      <if test="cronExpression != null">
        CRON_EXPRESSION = #{cronExpression,jdbcType=VARCHAR},
      </if>
      <if test="parameter != null">
        "PARAMETER" = #{parameter,jdbcType=VARCHAR},
      </if>
      <if test="description != null">
        DESCRIPTION = #{description,jdbcType=VARCHAR},
      </if>
      <if test="status != null">
        "STATUS" = #{status,jdbcType=DECIMAL},
      </if>
    </set>
    where ID = #{id,jdbcType=VARCHAR}
  </update>
  <update id="updateByPrimaryKey" parameterType="com.bjtcrj.scm.system.persistence.pojo.QuartzJob">
    <!--@mbg.generated-->
    update SYS_QUARTZ_JOB
    set JOB_CLASS_NAME = #{jobClassName,jdbcType=VARCHAR},
      CRON_EXPRESSION = #{cronExpression,jdbcType=VARCHAR},
      "PARAMETER" = #{parameter,jdbcType=VARCHAR},
      DESCRIPTION = #{description,jdbcType=VARCHAR},
      "STATUS" = #{status,jdbcType=DECIMAL}
    where ID = #{id,jdbcType=VARCHAR}
  </update>

  <select id="getList" resultMap="BaseResultMap" parameterType="com.bjtcrj.scm.system.persistence.pojo.QuartzJob">
    select
    <include refid="Base_Column_List" />
    from SYS_QUARTZ_JOB
    <where>
      <if test="1==1">
        1=1
      </if>
      <if test="id != null and id != ''">
        and ID = #{id,jdbcType=VARCHAR}
      </if>
      <if test="status != null and status != ''">
        and "STATUS" = #{status}
      </if>
      <if test="description != null and description != ''">
        and DESCRIPTION = #{description,jdbcType=VARCHAR}
      </if>
      <if test="parameter != null and parameter != ''">
        and  "PARAMETER" = #{parameter,jdbcType=VARCHAR}
      </if>
      <if test="cronExpression != null and cronExpression != ''">
        and CRON_EXPRESSION = #{cronExpression,jdbcType=VARCHAR}
      </if>
      <if test="jobClassName != null and jobClassName != ''">
        and JOB_CLASS_NAME = #{jobClassName,jdbcType=VARCHAR}
      </if>
    </where>
  </select>

  <!-- 根据jobClassName查询 -->
  <select id="findByJobClassName" resultType="com.bjtcrj.scm.system.persistence.pojo.QuartzJob">
    select * from  sys_quartz_job  where job_class_name = #{jobClassName}
  </select>
</mapper>

QuartzJobServiceImpl.java

任务管理核心代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
package com.bjtcrj.scm.system.business.service.impl;

import com.bjtcrj.scm.common.exception.ApplicationRuntimeException;
import com.bjtcrj.scm.common.utils.Constants;
import com.bjtcrj.scm.common.utils.StringEx;
import com.bjtcrj.scm.common.utils.UniqueIDGen;
import com.bjtcrj.scm.system.business.dto.RoleDto;
import com.bjtcrj.scm.system.persistence.pojo.Role;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import lombok.extern.slf4j.Slf4j;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import com.bjtcrj.scm.system.persistence.dao.QuartzJobDao;
import com.bjtcrj.scm.system.persistence.pojo.QuartzJob;
import com.bjtcrj.scm.system.business.service.QuartzJobService;

import java.util.*;

@Service
@Slf4j
public class QuartzJobServiceImpl implements QuartzJobService{

    @Resource
    private QuartzJobDao quartzJobDao;

    @Autowired
    private Scheduler scheduler;

    /*
	 * 立即执行的任务分组
	 */
    private static final String JOB_TEST_GROUP = "test_group";

    @Override
    public int deleteByPrimaryKey(String id) {
        return quartzJobDao.deleteByPrimaryKey(id);
    }

    @Override
    public int insert(QuartzJob record) {
        return quartzJobDao.insert(record);
    }

    @Override
    public boolean insertSelective(QuartzJob quartzJob) {
        if (Constants.STATUS_NORMAL.equals(quartzJob.getStatus())) {
            // 定时器添加
            this.schedulerAdd(quartzJob.getJobClassName().trim(), quartzJob.getCronExpression().trim(), quartzJob.getParameter());
        }

        quartzJob.setId(StringEx.valueOf(UniqueIDGen.getUniqueID()));
        return quartzJobDao.insertSelective(quartzJob)>0;
    }

    @Override
    public QuartzJob selectByPrimaryKey(String id) {
        return quartzJobDao.selectByPrimaryKey(id);
    }

    @Override
    public boolean updateByPrimaryKeySelective(QuartzJob quartzJob) throws SchedulerException {
        if (Constants.STATUS_NORMAL.equals(quartzJob.getStatus())) {
            schedulerDelete(quartzJob.getJobClassName().trim());
            schedulerAdd(quartzJob.getJobClassName().trim(), quartzJob.getCronExpression().trim(), quartzJob.getParameter());
        }else{
            scheduler.pauseJob(JobKey.jobKey(quartzJob.getJobClassName().trim()));
        }
        return quartzJobDao.updateByPrimaryKeySelective(quartzJob)>0;
    }

    @Override
    public int updateByPrimaryKey(QuartzJob record) {
        return quartzJobDao.updateByPrimaryKey(record);
    }

    @Override
    public PageInfo<QuartzJob> getByPage(QuartzJob quartzJob, int page, int rows) {
        PageHelper.startPage(page,rows);

        List<QuartzJob> list = quartzJobDao.getList(quartzJob);
        return new PageInfo<QuartzJob>(list);
    }

    @Override
    public List<QuartzJob> findByJobClassName(String jobClassName) {
        return quartzJobDao.findByJobClassName(jobClassName);
    }

    @Override
    public QuartzJob getById(String id) {
        return quartzJobDao.selectByPrimaryKey(id);
    }

    @Override
    public boolean deleteAndStopJob(QuartzJob quartzJob) {
        schedulerDelete(quartzJob.getJobClassName().trim());
        return quartzJobDao.deleteByPrimaryKey(quartzJob.getId())>0;
    }

    @Override
    public boolean pause(QuartzJob quartzJob) {
        schedulerDelete(quartzJob.getJobClassName().trim());
        quartzJob.setStatus(Constants.STATUS_DISABLE);
        return quartzJobDao.updateByPrimaryKeySelective(quartzJob)>0;
    }

    @Override
    public boolean resumeJob(QuartzJob quartzJob) {
        schedulerDelete(quartzJob.getJobClassName().trim());
        schedulerAdd(quartzJob.getJobClassName().trim(), quartzJob.getCronExpression().trim(), quartzJob.getParameter());
        quartzJob.setStatus(Constants.STATUS_NORMAL);

        return quartzJobDao.updateByPrimaryKeySelective(quartzJob)>0;
    }

    @Override
    public void execute(QuartzJob quartzJob) throws Exception {
        String jobName = quartzJob.getJobClassName().trim();
        Date startDate = new Date();
        String ymd = StringEx.getYMDHMS(startDate);
        String identity =  jobName + ymd;
        //3秒后执行 只执行一次
        startDate.setTime(startDate.getTime()+3000L);
        // 定义一个Trigger
        SimpleTrigger trigger = (SimpleTrigger)TriggerBuilder.newTrigger()
                .withIdentity(identity, JOB_TEST_GROUP)
                .startAt(startDate)
                .build();
        // 构建job信息
        JobDetail jobDetail = JobBuilder.newJob(getClass(jobName).getClass()).withIdentity(identity).usingJobData("parameter", quartzJob.getParameter()).build();
        // 将trigger和 jobDetail 加入这个调度
        scheduler.scheduleJob(jobDetail, trigger);
        // 启动scheduler
        scheduler.start();
    }

    /**
     * 添加定时任务
     *
     * @param jobClassName
     * @param cronExpression
     * @param parameter
     */
    private void schedulerAdd(String jobClassName, String cronExpression, String parameter) {
        try {
            // 启动调度器
            scheduler.start();

            // 构建job信息
            JobDetail jobDetail = JobBuilder.newJob(getClass(jobClassName).getClass()).withIdentity(jobClassName).usingJobData("parameter", parameter).build();

            // 表达式调度构建器(即任务执行的时间)
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

            // 按新的cronExpression表达式构建一个新的trigger
            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobClassName).withSchedule(scheduleBuilder).build();

            scheduler.scheduleJob(jobDetail, trigger);
        } catch (SchedulerException e) {
            throw new RuntimeException("创建定时任务失败", e);
        } catch (RuntimeException e) {
            throw new RuntimeException(e.getMessage(), e);
        }catch (Exception e) {
            throw new RuntimeException("后台找不到该类名：" + jobClassName, e);
        }
    }

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

    /**
     * 删除定时任务
     *
     * @param jobClassName
     */
    private void schedulerDelete(String jobClassName) {
        try {
            scheduler.pauseTrigger(TriggerKey.triggerKey(jobClassName));
            scheduler.unscheduleJob(TriggerKey.triggerKey(jobClassName));
            scheduler.deleteJob(JobKey.jobKey(jobClassName));
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            throw new RuntimeException("删除定时任务失败");
        }
    }
}

QuartzJobController.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
/**
 * @Description: 定时任务在线管理
 * @Author: jeecg-boot
 * @Date: 2019-01-02
 * @Version:V1.0
 */
@Controller
@RequestMapping("/quartzJob")
@Slf4j
public class QuartzJobController extends BaseController {
	@Autowired
	private QuartzJobService quartzJobService;

	@RequestMapping(value = "listUI")
	public String listUI(HttpServletRequest request){
		this.initListinfo(request, null);
		return this.redirectJsp("system/quartzjob", "list", true);
	}
	/**
	 * 分页列表查询
	 * @param page
	 * @param rows
	 * @return
	 */
	@RequestMapping(value = "/list")
	@ResponseBody
	public Map<String, Object> queryPageList(@RequestParam(name = "jobClassName", required = false) String jobClassName,
											 @RequestParam(name = "status", required = false) String status,
											 @RequestParam(name = "page", defaultValue = "1") Integer page,
								   			 @RequestParam(name = "rows", defaultValue = "10") Integer rows) {
		//分页条件
		QuartzJob quartzJob = new QuartzJob();
		quartzJob.setJobClassName(jobClassName);
		if(!StringEx.isNull(status)){
			quartzJob.setStatus(StringEx.tInteger(status));
		}
		PageInfo<QuartzJob> pageInfo = this.quartzJobService.getByPage(quartzJob, page, rows);
		Map<String, Object> map = new HashMap<>();
		map.put("total", pageInfo.getTotal());
		map.put("rows", pageInfo.getList());
		return map;
	}

	@RequestMapping(value = "addUI")
	public String addUI(HttpServletRequest request){
		return this.redirectJsp("system/quartzjob", "add", true);
	}

	/**
	 * 添加定时任务
	 * 
	 * @param quartzJob
	 * @return
	 */
	@RequestMapping(value = "/add", method = RequestMethod.POST)
	@ResponseBody
	public Json add(QuartzJob quartzJob) {
		Json json = new Json();
		List<QuartzJob> list = quartzJobService.findByJobClassName(quartzJob.getJobClassName());
		if (list != null && list.size() > 0) {
			json.setSuccess(false);
			json.setMsg("该定时任务类名已存在");
			return json;
		}
		if (quartzJobService.insertSelective(quartzJob)) {
			json.setSuccess(true);
			json.setMsg("添加成功");
		} else {
			json.setSuccess(false);
			json.setMsg("添加失败");
		}
		return json;
	}

	@RequestMapping(value = "updateUI")
	public String updateUI(HttpServletRequest request){
		String id = request.getParameter("id");
		QuartzJob quartzJob = this.quartzJobService.getById(id);
		request.setAttribute("quartzjob", quartzJob);
		return this.redirectJsp("system/quartzjob", "update", true);
	}

	/**
	 * 更新定时任务
	 * 
	 * @param quartzJob
	 * @return
	 */
	@RequestMapping(value = "/update")
	@ResponseBody
	public Json update(QuartzJob quartzJob) {
		Json json = new Json();
		try {
			boolean b = quartzJobService.updateByPrimaryKeySelective(quartzJob);
			if(b) {
				json.setMsg("更新定时任务成功!");
			}
			json.setSuccess(b);
		} catch (SchedulerException e) {
			log.error(e.getMessage(),e);
			json.setSuccess(false);
			json.setMsg("更新定时任务失败!");
			return json;
		}
	    return json;
	}

	@RequestMapping(value = "detailUI")
	public String detailUI(HttpServletRequest request){
		String id = request.getParameter("id");
		QuartzJob quartzJob = this.quartzJobService.getById(id);
		request.setAttribute("quartzjob", quartzJob);
		return this.redirectJsp("system/quartzjob", "detail", true);
	}

	/**
	 * 通过id删除
	 * 
	 * @param id
	 * @return
	 */
	//@RequiresRoles("admin")
	@RequestMapping(value = "/delete")
	@ResponseBody
	public Json delete(@RequestParam(name = "id", required = true) String id) {
		Json json = new Json();
		QuartzJob quartzJob = quartzJobService.getById(id);
		if (quartzJob == null) {
			json.setSuccess(false);
			json.setMsg("未找到对应实体");
			return json;
		}
		boolean b = quartzJobService.deleteAndStopJob(quartzJob);
		if(b) {
			json.setMsg("删除成功");
		} else{
			json.setMsg("删除失败");
		}
		json.setSuccess(b);
		return json;
	}

	/**
	 * 批量删除
	 * 
	 * @param ids
	 * @return
	 */
	@RequestMapping(value = "/deleteBatch")
	@ResponseBody
	public Json deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
		Json json = new Json();
		if (ids == null || "".equals(ids.trim())) {
			json.setSuccess(false);
			json.setMsg("参数不识别!");
			return json;
		}
		for (String id : Arrays.asList(ids.split(","))) {
			QuartzJob job = quartzJobService.getById(id);
			quartzJobService.deleteAndStopJob(job);
		}
		json.setSuccess(true);
		json.setMsg("删除定时任务成功!");
		return json;
	}

	/**
	 * 暂停定时任务
	 * @param id
	 * @return
	 */
	@RequestMapping(value = "/pause")
	@ResponseBody
	public Json pauseJob(@RequestParam(name = "id", required = true) String id) {
		Json json = new Json();
		QuartzJob job = quartzJobService.getById(id);
		if (job == null) {
			json.setSuccess(false);
			json.setMsg("未找到对应实体!");
			return json;
		}

		if (quartzJobService.pause(job)) {
			json.setSuccess(true);
			json.setMsg("暂停定时任务成功");
		} else {
			json.setSuccess(false);
			json.setMsg("暂停定时任务失败");
		}
		return json;
	}

	/**
	 * 启动定时任务
	 * @param id
	 * @return
	 */
	@RequestMapping(value = "/resume")
	@ResponseBody
	public Json resumeJob(@RequestParam(name = "id", required = true) String id) {
		Json json = new Json();
		QuartzJob job = this.quartzJobService.getById(id);
		if (job == null) {
			json.setSuccess(false);
			json.setMsg("未找到对应实体!");
			return json;
		}

		if (quartzJobService.resumeJob(job)) {
			json.setSuccess(true);
			json.setMsg("恢复定时任务成功");
		} else {
			json.setSuccess(false);
			json.setMsg("恢复定时任务失败");
		}
		return json;
	}

	/**
	 * 通过id查询
	 * 
	 * @param id
	 * @return
	 */
	@RequestMapping(value = "/queryById", method = RequestMethod.GET)
	@ResponseBody
	public QuartzJob queryById(@RequestParam(name = "id", required = true) String id) {
        return quartzJobService.getById(id);
	}

	/**
	 * 立即执行
	 * @param id
	 * @return
	 */
	//@RequiresRoles("admin")
	@RequestMapping("/execute")
	@ResponseBody
	public Json execute(@RequestParam(name = "id", required = true) String id) {
		Json json = new Json();
		json.setSuccess(true);
		json.setMsg("执行成功");

		QuartzJob quartzJob = quartzJobService.getById(id);
		if (quartzJob == null) {
			json.setSuccess(false);
			json.setMsg("未找到对应实体!");
			return json;
		}
		try {
			quartzJobService.execute(quartzJob);
		} catch (Exception e) {
			//e.printStackTrace();
			log.info("定时任务 立即执行失败>>"+e.getMessage());
			json.setSuccess(false);
			json.setMsg("执行失败");
			return json;
		}
		return json;
	}

	private void initListinfo(HttpServletRequest request, HttpServletResponse response) {
		/********************************************/
		try {
			String id = request.getParameter("moduleid");

			List<NavTreeDto> authButton = this.getAuthorizeMenuButtonJson(request,
					response,
					(String) this.getSessionAttribute(request, Constants.SESSION_ROLE_ID),
					id,
					Constants.SYS_MODULE_TERMINAL_TYPE_PCWEB);
			this.setRequestAttribute(request, "buttonList", JSON.toJSON(authButton));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

示例任务

1
2
3
4
5
6
7
8
9
10
11
12
13
@Slf4j
public class SampleJob implements Job {

	@Override
	public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
		//获取 service 或 dao 接口
		UserService userService = (UserService)SpringContextUtil.getBean("userService");
		UserDao userDao = (UserDao)SpringContextUtil.getBean("userDao");

		LocalDateTime rightNow = LocalDateTime.now();
		log.info(" ---SampleJob 执行完毕，时间："+rightNow.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))+"---");
	}
}

注册菜单

1
2
3
4
5
6
INSERT INTO SCM_SYSMODULE (MODULEID, TERMINALTYPE, MODULENAME, MODULECODE, PMODULECODE, ENDFLAG, ORDERNUMBER, TARGET, MODULEPATH, MODULETYPE, MODULEICON, RELATIONFLAG, ENABLED, REMARK) VALUES ('1380546536370606080', '1', '定时任务', null, '1444444602387475', '0', 51, null, '/quartzJob/listUI.jspx', '1', null, null, '1', null);
INSERT INTO SCM_SYSMODULE (MODULEID, TERMINALTYPE, MODULENAME, MODULECODE, PMODULECODE, ENDFLAG, ORDERNUMBER, TARGET, MODULEPATH, MODULETYPE, MODULEICON, RELATIONFLAG, ENABLED, REMARK) VALUES ('1380546789907894272', '1', '新增', null, '1380546536370606080', '1', 1, 'addFun', '/quartzJob/addUI.jspx', '0', null, null, '1', null);
INSERT INTO SCM_SYSMODULE (MODULEID, TERMINALTYPE, MODULENAME, MODULECODE, PMODULECODE, ENDFLAG, ORDERNUMBER, TARGET, MODULEPATH, MODULETYPE, MODULEICON, RELATIONFLAG, ENABLED, REMARK) VALUES ('1380546934519107584', '1', '编辑', null, '1380546536370606080', '1', 2, 'editFun', '/quartzJob/updateUI.jspx', '0', null, null, '1', null);
INSERT INTO SCM_SYSMODULE (MODULEID, TERMINALTYPE, MODULENAME, MODULECODE, PMODULECODE, ENDFLAG, ORDERNUMBER, TARGET, MODULEPATH, MODULETYPE, MODULEICON, RELATIONFLAG, ENABLED, REMARK) VALUES ('1380547258944327680', '1', '删除', null, '1380546536370606080', '1', 4, 'deleteFun', '/quartzJob/deleteBatch.jspx', '0', null, null, '1', null);
INSERT INTO SCM_SYSMODULE (MODULEID, TERMINALTYPE, MODULENAME, MODULECODE, PMODULECODE, ENDFLAG, ORDERNUMBER, TARGET, MODULEPATH, MODULETYPE, MODULEICON, RELATIONFLAG, ENABLED, REMARK) VALUES ('1380547055185039360', '1', '查看', null, '1380546536370606080', '1', 3, 'detailFun', '/quartzJob/detailUI.jspx', '0', null, null, '1', null);
INSERT INTO SCM_SYSMODULE (MODULEID, TERMINALTYPE, MODULENAME, MODULECODE, PMODULECODE, ENDFLAG, ORDERNUMBER, TARGET, MODULEPATH, MODULETYPE, MODULEICON, RELATIONFLAG, ENABLED, REMARK) VALUES ('1380547513370808320', '1', '执行', null, '1380546536370606080', '1', 5, 'executeFun', '/quartzJob/execute.jspx', '0', null, null, '1', null);