Spring4+Springmvc+quartz实现多线程动态定时调度

scheduler定时调度系统是大多行业项目都需要的，传统的spring-job模式，个人感觉已经out了，因为存在很多的问题，特别是定时调度的追加、修改、删除等，需要修改xml，xml的配置生效无非是热部署灰度发布方案或者直接停止、重启服务器，完全不能做到自动启动、修复方式。

提醒：可以对应用进行集群部署，在对定时调度配置时可以使用集群方式或者单边配置应用方式，今天讲解的是使用spring4+scheduler实现定时调度，闲话少说，直接把步骤记录下来：

1. 在项目的pom.xml文件中引入quartz的jar包，如下：

1. <!-- quartz定时调度 -->
2. lt;dependency>
3. <groupId>org.quartz-scheduler</groupId>
4. <artifactId>quartz</artifactId>
5. <version>1.8.5</version>
6. lt;/dependency>

                <!-- quartz定时调度 -->
		<dependency>
			<groupId>org.quartz-scheduler</groupId>
			<artifactId>quartz</artifactId>
			<version>1.8.5</version>
		</dependency>

2. 定义quartz的配置文件spring-context-quartz.xml：

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3. xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="
4. http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
5. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd"
6. default-lazy-init="false">
7. <!-- 调度器 -->
8. <bean name="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
9. <!-- 通过applicationContextSchedulerContextKey属性配置spring上下文 -->
10. <property name="applicationContextSchedulerContextKey" value="applicationContext" />
11. </bean>
12. <!--加载数据库任务-->
13. <bean id="jobService" class="com.ml.honghu.job.service.JobService" init-method="loadJob" />
14. </beans>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd"
	default-lazy-init="false">
	<!-- 调度器 -->
    <bean name="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
       <!-- 通过applicationContextSchedulerContextKey属性配置spring上下文 -->
        <property name="applicationContextSchedulerContextKey" value="applicationContext" />
    </bean>
    <!--加载数据库任务-->
    <bean id="jobService" class="com.ml.honghu.job.service.JobService" init-method="loadJob" />
</beans>

3.  在项目的web.xml文件中引入spring-context-quartz.xml配置文件

1. classpath*:spring-context-quartz.xml

classpath*:spring-context-quartz.xml

4. 定义job实体对象

1. public class Job{
2. private static final long serialVersionUID = 1L;
3. /**
4. * 任务执行周期cron表达式
5. */
6. public static int EXECYCLE_CRON = 2;
7. /**
8. * 任务执行周期自定义
9. */
10. public static int EXECYCLE_DEFINE = 1;
11. /**
12. * 执行周期-分钟
13. */
14. public static int EXECYCLE_MINUTE = 1;
15. /**
16. * 执行周期-小时
17. */
18. public static int EXECYCLE_HOUR = 2;
19. /**
20. * 执行周期-日
21. */
22. public static int EXECYCLE_DAY = 3;
23. /**
24. * 执行周期-月
25. */
26. public static int EXECYCLE_WEEK = 4;
27. /**
28. * 执行周期-月
29. */
30. public static int EXECYCLE_MONTH = 5;
31. private String jobType;     // 任务类型(1首页静态化、2栏目页静态化、3内容页静态化、4采集、5分发)
32. private String jobName;     // 任务名称
33. private String jobClass;        // 任务类
34. private String execycle;        // 执行周期分类(1非表达式 2 cron表达式)
35. private String dayOfMonth;      // 每月的哪天
36. private String dayOfWeek;       // 周几
37. private String hour;        // 小时
38. private String minute;      // 分钟
39. private String intervalHour;        // 间隔小时
40. private String intervalMinute;      // 间隔分钟
41. private String jobIntervalUnit;     // 1分钟、2小时、3日、4周、5月
42. private String cronExpression;      // 规则表达式
43. private String isEnable;        // 是否启用
44. public Job() {
45. super();
46. }
47. public Job(String id){
48. super(id);
49. }
50. @Length(min=1, max=1, message="任务类型(1首页静态化、2栏目页静态化、3内容页静态化、4采集、5分发)长度必须介于 1 和 1 之间")
51. public String getJobType() {
52. return jobType;
53. }
54. public void setJobType(String jobType) {
55. this.jobType = jobType;
56. }
57. @Length(min=1, max=255, message="任务名称长度必须介于 1 和 255 之间")
58. public String getJobName() {
59. return jobName;
60. }
61. public void setJobName(String jobName) {
62. this.jobName = jobName;
63. }
64. @Length(min=1, max=255, message="任务类长度必须介于 1 和 255 之间")
65. public String getJobClass() {
66. return jobClass;
67. }
68. public void setJobClass(String jobClass) {
69. this.jobClass = jobClass;
70. }
71. @Length(min=1, max=1, message="执行周期分类(1非表达式 2 cron表达式)长度必须介于 1 和 1 之间")
72. public String getExecycle() {
73. return execycle;
74. }
75. public void setExecycle(String execycle) {
76. this.execycle = execycle;
77. }
78. @Length(min=0, max=11, message="每月的哪天长度必须介于 0 和 11 之间")
79. public String getDayOfMonth() {
80. return dayOfMonth;
81. }
82. public void setDayOfMonth(String dayOfMonth) {
83. this.dayOfMonth = dayOfMonth;
84. }
85. @Length(min=0, max=1, message="周几长度必须介于 0 和 1 之间")
86. public String getDayOfWeek() {
87. return dayOfWeek;
88. }
89. public void setDayOfWeek(String dayOfWeek) {
90. this.dayOfWeek = dayOfWeek;
91. }
92. @Length(min=0, max=11, message="小时长度必须介于 0 和 11 之间")
93. public String getHour() {
94. return hour;
95. }
96. public void setHour(String hour) {
97. this.hour = hour;
98. }
99. @Length(min=0, max=11, message="分钟长度必须介于 0 和 11 之间")
100. public String getMinute() {
101. return minute;
102. }
103. public void setMinute(String minute) {
104. this.minute = minute;
105. }
106. @Length(min=0, max=11, message="间隔小时长度必须介于 0 和 11 之间")
107. public String getIntervalHour() {
108. return intervalHour;
109. }
110. public void setIntervalHour(String intervalHour) {
111. this.intervalHour = intervalHour;
112. }
113. @Length(min=0, max=11, message="间隔分钟长度必须介于 0 和 11 之间")
114. public String getIntervalMinute() {
115. return intervalMinute;
116. }
117. public void setIntervalMinute(String intervalMinute) {
118. this.intervalMinute = intervalMinute;
119. }
120. @Length(min=0, max=1, message="1分钟、2小时、3日、4周、5月长度必须介于 0 和 1 之间")
121. public String getJobIntervalUnit() {
122. return jobIntervalUnit;
123. }
124. public void setJobIntervalUnit(String jobIntervalUnit) {
125. this.jobIntervalUnit = jobIntervalUnit;
126. }
127. @Length(min=0, max=255, message="规则表达式长度必须介于 0 和 255 之间")
128. public String getCronExpression() {
129. return cronExpression;
130. }
131. public void setCronExpression(String cronExpression) {
132. this.cronExpression = cronExpression;
133. }
134. @Length(min=1, max=1, message="是否启用长度必须介于 1 和 1 之间")
135. public String getIsEnable() {
136. return isEnable;
137. }
138. public void setIsEnable(String isEnable) {
139. this.isEnable = isEnable;
140. }
141. }

public class Job{
private static final long serialVersionUID = 1L;

/**
 * 任务执行周期cron表达式
 */
public static int EXECYCLE_CRON = 2;
/**
 * 任务执行周期自定义
 */
public static int EXECYCLE_DEFINE = 1;
/**
 * 执行周期-分钟
 */
public static int EXECYCLE_MINUTE = 1;
/**
 * 执行周期-小时
 */
public static int EXECYCLE_HOUR = 2;
/**
 * 执行周期-日
 */
public static int EXECYCLE_DAY = 3;
/**
 * 执行周期-月
 */
public static int EXECYCLE_WEEK = 4;
/**
 * 执行周期-月
 */
public static int EXECYCLE_MONTH = 5;

private String jobType;		// 任务类型(1首页静态化、2栏目页静态化、3内容页静态化、4采集、5分发)
private String jobName;		// 任务名称
private String jobClass;		// 任务类
private String execycle;		// 执行周期分类(1非表达式 2 cron表达式)
private String dayOfMonth;		// 每月的哪天
private String dayOfWeek;		// 周几
private String hour;		// 小时
private String minute;		// 分钟
private String intervalHour;		// 间隔小时
private String intervalMinute;		// 间隔分钟
private String jobIntervalUnit;		// 1分钟、2小时、3日、4周、5月
private String cronExpression;		// 规则表达式
private String isEnable;		// 是否启用

public Job() {
	super();
}

public Job(String id){
	super(id);
}

@Length(min=1, max=1, message="任务类型(1首页静态化、2栏目页静态化、3内容页静态化、4采集、5分发)长度必须介于 1 和 1 之间")
public String getJobType() {
	return jobType;
}

public void setJobType(String jobType) {
	this.jobType = jobType;
}

@Length(min=1, max=255, message="任务名称长度必须介于 1 和 255 之间")
public String getJobName() {
	return jobName;
}

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

@Length(min=1, max=255, message="任务类长度必须介于 1 和 255 之间")
public String getJobClass() {
	return jobClass;
}

public void setJobClass(String jobClass) {
	this.jobClass = jobClass;
}

@Length(min=1, max=1, message="执行周期分类(1非表达式 2 cron表达式)长度必须介于 1 和 1 之间")
public String getExecycle() {
	return execycle;
}

public void setExecycle(String execycle) {
	this.execycle = execycle;
}

@Length(min=0, max=11, message="每月的哪天长度必须介于 0 和 11 之间")
public String getDayOfMonth() {
	return dayOfMonth;
}

public void setDayOfMonth(String dayOfMonth) {
	this.dayOfMonth = dayOfMonth;
}

@Length(min=0, max=1, message="周几长度必须介于 0 和 1 之间")
public String getDayOfWeek() {
	return dayOfWeek;
}

public void setDayOfWeek(String dayOfWeek) {
	this.dayOfWeek = dayOfWeek;
}

@Length(min=0, max=11, message="小时长度必须介于 0 和 11 之间")
public String getHour() {
	return hour;
}

public void setHour(String hour) {
	this.hour = hour;
}

@Length(min=0, max=11, message="分钟长度必须介于 0 和 11 之间")
public String getMinute() {
	return minute;
}

public void setMinute(String minute) {
	this.minute = minute;
}

@Length(min=0, max=11, message="间隔小时长度必须介于 0 和 11 之间")
public String getIntervalHour() {
	return intervalHour;
}

public void setIntervalHour(String intervalHour) {
	this.intervalHour = intervalHour;
}

@Length(min=0, max=11, message="间隔分钟长度必须介于 0 和 11 之间")
public String getIntervalMinute() {
	return intervalMinute;
}

public void setIntervalMinute(String intervalMinute) {
	this.intervalMinute = intervalMinute;
}

@Length(min=0, max=1, message="1分钟、2小时、3日、4周、5月长度必须介于 0 和 1 之间")
public String getJobIntervalUnit() {
	return jobIntervalUnit;
}

public void setJobIntervalUnit(String jobIntervalUnit) {
	this.jobIntervalUnit = jobIntervalUnit;
}

@Length(min=0, max=255, message="规则表达式长度必须介于 0 和 255 之间")
public String getCronExpression() {
	return cronExpression;
}

public void setCronExpression(String cronExpression) {
	this.cronExpression = cronExpression;
}

@Length(min=1, max=1, message="是否启用长度必须介于 1 和 1 之间")
public String getIsEnable() {
	return isEnable;
}

public void setIsEnable(String isEnable) {
	this.isEnable = isEnable;
}

}

5. 编写quartz的jobServvice类：

1. package com.ml.honghu.job.service;
2. import java.text.ParseException;
3. import java.util.List;
4. import java.util.UUID;
5. import org.quartz.CronTrigger;
6. import org.quartz.JobDetail;
7. import org.quartz.Scheduler;
8. import org.quartz.SchedulerException;
9. import org.slf4j.Logger;
10. import org.slf4j.LoggerFactory;
11. import org.springframework.beans.factory.annotation.Autowired;
12. import org.springframework.stereotype.Service;
13. import org.springframework.transaction.annotation.Transactional;
14. import com.ml.honghu.StringUtils;
15. import com.ml.honghu.common.persistence.Page;
16. import com.ml.honghu.common.service.CrudService;
17. import com.ml.honghu.job.dao.JobDao;
18. import com.ml.honghu.job.entity.Job;
19. /**
20. * 定时调度任务Service
21. *
22. * @author honghu
23. */
24. @Service
25. @Transactional(readOnly = true)
26. public class JobService extends CrudService<JobDao, Job> {
27. @Autowired
28. private JobDao jobDao;
29. private Logger logger = LoggerFactory.getLogger(getClass());
30. public Job get(String id) {
31. return super.get(id);
32. }
33. public List<Job> findList(Job job) {
34. return super.findList(job);
35. }
36. public Page<Job> findPage(Page<Job> page, Job job) {
37. return super.findPage(page, job);
38. }
39. @Transactional(readOnly = false)
40. public void save(Job job) {
41. super.save(job);
42. // 启用则启动任务
43. if (StringUtils.equals("1", job.getIsEnable())) {
44. startTask(job, job.getId());
45. }
46. }
47. @Transactional(readOnly = false)
48. public void update(Job job) {
49. //结束定时调度
50. endTask(job.getId());
51. job.preUpdate();
52. jobDao.update(job);
53. // 启用则启动任务
54. if (StringUtils.equals("1", job.getIsEnable())) {
55. startTask(job, job.getId());
56. }
57. }
58. @Transactional(readOnly = false)
59. public void delete(Job job) {
60. //结束任务
61. endTask(job.getId());
62. super.delete(job);
63. }
64. /**
65. * 系统初始加载任务
66. */
67. public void loadJob() throws Exception {
68. List<Job> jobList = this.findList(new Job());
69. if (null != jobList && jobList.size() > 0) {
70. for (int i = 0; i < jobList.size(); i++) {
71. Job job = jobList.get(i);
72. // 任务开启状态 执行任务调度
73. if (StringUtils.equals("1", job.getIsEnable())) {
74. try {
75. JobDetail jobDetail = new JobDetail();
76. // 设置任务名称
77. if (StringUtils.isNotBlank(job.getId())) {
78. jobDetail.setName(job.getId());
79. } else {
80. UUID uuid = UUID.randomUUID();
81. jobDetail.setName(uuid.toString());
82. job.setId(uuid.toString());
83. }
84. jobDetail.setGroup(Scheduler.DEFAULT_GROUP);
85. // 设置任务执行类
86. jobDetail.setJobClass(getClassByTask(job.getJobClass()));
87. // 添加任务参数
88. CronTrigger cronTrigger = new CronTrigger("cron_" + i, Scheduler.DEFAULT_GROUP,
89. jobDetail.getName(), Scheduler.DEFAULT_GROUP);
90. cronTrigger.setCronExpression(getCronExpressionFromDB(job.getId()));
91. // 调度任务
92. scheduler.scheduleJob(jobDetail, cronTrigger);
93. } catch (SchedulerException e) {
94. logger.error("JobService SchedulerException", e);
95. } catch (ClassNotFoundException e) {
96. logger.error("JobService ClassNotFoundException", e);
97. } catch (Exception e) {
98. logger.error("JobService Exception", e);
99. }
100. }
101. }
102. }
103. }
104. /**
105. *
106. * @param taskClassName
107. *            任务执行类名
108. * @return
109. * @throws ClassNotFoundException
110. */
111. @SuppressWarnings("rawtypes")
112. private Class getClassByTask(String taskClassName) throws ClassNotFoundException {
113. return Class.forName(taskClassName);
114. }
115. public String getCronExpressionFromDB(String id) throws Exception {
116. // 设置任务规则
117. Job job = this.get(id);
118. if (null != job) {
119. if (Job.EXECYCLE_CRON == Integer.parseInt(job.getExecycle())) {
120. return job.getCronExpression();
121. } else {
122. Integer execycle = Integer.parseInt(job.getJobIntervalUnit());
123. String excep = "";
124. if (execycle.equals(Job.EXECYCLE_MONTH)) {
125. excep = "0  " + job.getMinute() + " " + job.getHour() + " " + job.getDayOfMonth() + " * ?";
126. } else if (execycle.equals(Job.EXECYCLE_WEEK)) {
127. excep = "0  " + job.getMinute() + " " + job.getHour() + " " + " ? " + " * " + job.getDayOfWeek();
128. } else if (execycle.equals(Job.EXECYCLE_DAY)) {
129. excep = "0  " + job.getMinute() + " " + job.getHour() + " " + " * * ?";
130. } else if (execycle.equals(Job.EXECYCLE_HOUR)) {
131. excep = "0 0 */" + job.getIntervalHour() + " * * ?";
132. } else if (execycle.equals(Job.EXECYCLE_MINUTE)) {
133. excep = "0  */" + job.getIntervalMinute() + " * * * ?";
134. }
135. return excep;
136. }
137. }
138. return "";
139. }
140. private void startTask(Job job, String id) {
141. try {
142. String cronExpress = getCronExpressionFromDB(id);
143. if (StringUtils.isNotEmpty(cronExpress) && cronExpress.indexOf("null") == -1) {
144. JobDetail jobDetail = new JobDetail();
145. jobDetail.setName(id);
146. jobDetail.setGroup(Scheduler.DEFAULT_GROUP);
147. jobDetail.setJobClass(getClassByTask(job.getJobClass()));
148. CronTrigger cronTrigger = new CronTrigger("cron_" + id, Scheduler.DEFAULT_GROUP, jobDetail.getName(),
149. Scheduler.DEFAULT_GROUP);
150. cronTrigger.setCronExpression(cronExpress);
151. scheduler.scheduleJob(jobDetail, cronTrigger);
152. }
153. } catch (ParseException e) {
154. logger.error("JobService ParseException", e);
155. } catch (Exception e) {
156. logger.error("JobService Exception", e);
157. }
158. }
159. private void endTask(String id) {
160. try {
161. scheduler.deleteJob(id, Scheduler.DEFAULT_GROUP);
162. } catch (SchedulerException e) {
163. logger.error("JobService endTask", e);
164. }
165. }
166. @Autowired
167. private Scheduler scheduler;
168. }

package com.ml.honghu.job.service;

import java.text.ParseException;

import java.util.List;

import java.util.UUID;

import org.quartz.CronTrigger;

import org.quartz.JobDetail;

import org.quartz.Scheduler;

import org.quartz.SchedulerException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import com.ml.honghu.StringUtils;

import com.ml.honghu.common.persistence.Page;

import com.ml.honghu.common.service.CrudService;

import com.ml.honghu.job.dao.JobDao;

import com.ml.honghu.job.entity.Job;

/**
定时调度任务Service
@author honghu

*/

@Service

@Transactional(readOnly = true)

public class JobService extends CrudService<JobDao, Job> {

@Autowired

private JobDao jobDao;

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

public Job get(String id) {

return super.get(id);

}

public List<Job> findList(Job job) {

return super.findList(job);

}

public Page<Job> findPage(Page<Job> page, Job job) {

return super.findPage(page, job);

}

@Transactional(readOnly = false)

public void save(Job job) {

super.save(job);

// 启用则启动任务

if (StringUtils.equals("1", job.getIsEnable())) {

startTask(job, job.getId());

}

}

@Transactional(readOnly = false)

public void update(Job job) {

//结束定时调度

endTask(job.getId());
 job.preUpdate();
 jobDao.update(job);

 // 启用则启动任务
 if (StringUtils.equals("1", job.getIsEnable())) {
 	startTask(job, job.getId());
 }

}
@Transactional(readOnly = false)

public void delete(Job job) {

//结束任务

endTask(job.getId());
 super.delete(job);

}
/**
系统初始加载任务

*/

public void loadJob() throws Exception {

List<Job> jobList = this.findList(new Job());

if (null != jobList && jobList.size() > 0) {

for (int i = 0; i < jobList.size(); i++) {

Job job = jobList.get(i);

// 任务开启状态 执行任务调度

if (StringUtils.equals("1", job.getIsEnable())) {

try {

JobDetail jobDetail = new JobDetail();

// 设置任务名称

if (StringUtils.isNotBlank(job.getId())) {

jobDetail.setName(job.getId());

} else {

UUID uuid = UUID.randomUUID();

jobDetail.setName(uuid.toString());

job.setId(uuid.toString());

}

jobDetail.setGroup(Scheduler.DEFAULT_GROUP);

// 设置任务执行类

jobDetail.setJobClass(getClassByTask(job.getJobClass()));

// 添加任务参数

CronTrigger cronTrigger = new CronTrigger("cron_" + i, Scheduler.DEFAULT_GROUP,

jobDetail.getName(), Scheduler.DEFAULT_GROUP);
 			cronTrigger.setCronExpression(getCronExpressionFromDB(job.getId()));
 			// 调度任务
 			scheduler.scheduleJob(jobDetail, cronTrigger);
 		} catch (SchedulerException e) {
 			logger.error("JobService SchedulerException", e);
 		} catch (ClassNotFoundException e) {
 			logger.error("JobService ClassNotFoundException", e);
 		} catch (Exception e) {
 			logger.error("JobService Exception", e);
 		}
 	}
 }

}

}
/**
@param taskClassName
       任务执行类名

@return
@throws ClassNotFoundException

*/

@SuppressWarnings("rawtypes")

private Class getClassByTask(String taskClassName) throws ClassNotFoundException {

return Class.forName(taskClassName);

}
public String getCronExpressionFromDB(String id) throws Exception {

// 设置任务规则

Job job = this.get(id);

if (null != job) {

if (Job.EXECYCLE_CRON == Integer.parseInt(job.getExecycle())) {

return job.getCronExpression();

} else {

Integer execycle = Integer.parseInt(job.getJobIntervalUnit());

String excep = "";

if (execycle.equals(Job.EXECYCLE_MONTH)) {

excep = "0  " + job.getMinute() + " " + job.getHour() + " " + job.getDayOfMonth() + " * ?";

} else if (execycle.equals(Job.EXECYCLE_WEEK)) {

excep = "0  " + job.getMinute() + " " + job.getHour() + " " + " ? " + " * " + job.getDayOfWeek();

} else if (execycle.equals(Job.EXECYCLE_DAY)) {

excep = "0  " + job.getMinute() + " " + job.getHour() + " " + " * * ?";

} else if (execycle.equals(Job.EXECYCLE_HOUR)) {

excep = "0 0 */" + job.getIntervalHour() + " * * ?";

} else if (execycle.equals(Job.EXECYCLE_MINUTE)) {

excep = "0  */" + job.getIntervalMinute() + " * * * ?";

}

return excep;

}

}

return "";

}
private void startTask(Job job, String id) {

try {

String cronExpress = getCronExpressionFromDB(id);

if (StringUtils.isNotEmpty(cronExpress) && cronExpress.indexOf("null") == -1) {

JobDetail jobDetail = new JobDetail();

jobDetail.setName(id);

jobDetail.setGroup(Scheduler.DEFAULT_GROUP);

jobDetail.setJobClass(getClassByTask(job.getJobClass()));

CronTrigger cronTrigger = new CronTrigger("cron_" + id, Scheduler.DEFAULT_GROUP, jobDetail.getName(),

Scheduler.DEFAULT_GROUP);

cronTrigger.setCronExpression(cronExpress);

scheduler.scheduleJob(jobDetail, cronTrigger);

}

} catch (ParseException e) {

logger.error("JobService ParseException", e);

} catch (Exception e) {

logger.error("JobService Exception", e);

}

}
private void endTask(String id) {

try {

scheduler.deleteJob(id, Scheduler.DEFAULT_GROUP);

} catch (SchedulerException e) {

logger.error("JobService endTask", e);

}

}
@Autowired

private Scheduler scheduler;
}

6. 编写相关job的Controller、dao、dao.xml我这边就不写了，其实就是对数据的增删改查操作

7. 启动项目验证quartz是否成功：

    项目启动个控制台：

      任务列表：

       任务添加和修改界面：

 到此完毕！