传统Spring+Quartz实现的定时器一般都是通过配置文件中配置的，这就意味着如果我们修改了定时任务的时间，就得重新启动一下Tomcat，而且每次新建一个任务就得在spring中添加相关的配置信息，非常麻烦。基于上面的问题，这边给大家介绍一下Spring+Quartz如何实现动态定时器，如何避免创建多个定时任务的配置文件。
1.在开始之前，我们需求引入Quartz相关的依赖，pom.xml文件如下所示：
<!-- 定时任务 -->
<
dependency
>
<
groupId
>
org.springframework
</
groupId
>
<
artifactId
>
spring-context-support
</
artifactId
>
<
version
>
4.2.4.RELEASE
</
version
>
</
dependency
>
<
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
>
2.我们需要在配置文件中配置定时任务的容器，也就是SchedulerFactoryBean，然后再配置一个定时任务管理器，这个类是我们自己定义的，而上面的SchedulerFactoryBean是来自依赖中的库。具体代码如下所示：
<?
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:
mongo
="http://www.springframework.org/schema/data/mongo"
xsi
:schemaLocation
="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/data/mongo
http://www.springframework.org/schema/data/mongo/spring-mongo.xsd"
>
<!-- 总管理类 如果将lazy-init='false'那么容器启动就会执行调度程序 -->
<
bean
id
="startQuertz"
lazy-init
="true"
autowire
="no"
class
="org.springframework.scheduling.quartz.
SchedulerFactoryBean
"
></
bean
>
<!--这个类是用来设置触发时间的， startJobs方法启动调度容器，然后按照上面触发器每隔1s执行所配置的myJob2.doSomething()方法 -->
<
bean
id
="quartzManager"
class
="com.infun.platform.quartz.QuartzManager"
lazy-init
="false"
init-method
="startJobs"
>
<!--这个对象一定要注入，这样类才能进行管理，还有在类型要用get set方法，不然会报错。-->
<
property
name
="scheduler"
ref
="startQuertz"
/>
</
bean
>
</
beans
>
这边我给这个配置文件取名为quartz.xml
3.第三步就是重中之重的，定时任务管理器的编写了，它负责去创建定时任务、修改任务触发事件、删除任务、停止定时任务容器等功能。下面我们具体看代码：
package
com.infun.platform.quartz;
import
org.quartz.*;
/**
* 定时任务配置管理中心
*
*
@author
linzhiqiang
*
@date
2018/6/5
*/
public class
QuartzManager {
private
Scheduler
scheduler
;
/**
*
@param
jobName
任务名
*
@param
jobGroupName
任务组名
*
@param
triggerName
触发器名
*
@param
triggerGroupName
触发器组名
*
@param
jobClass
任务
*
@param
cron
时间设置，参考quartz说明文档
*
@param
quartzTask
task参数
*
@Description:
添加一个定时任务
*/
@SuppressWarnings
({
"unchecked"
,
"rawtypes"
})
public void
addJob(String jobName, String jobGroupName,
String triggerName, String triggerGroupName, Class jobClass, String cron,TaskData quartzTask) {
try
{
JobDataMap jobMap=
new
JobDataMap();
jobMap.put(
"task"
, quartzTask);
// 任务名，任务组，任务执行类
JobDetail jobDetail = JobBuilder.
newJob
(jobClass).withIdentity(jobName, jobGroupName)
.usingJobData(jobMap)
.build();
// 触发器
TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.
newTrigger
();
// 触发器名,触发器组
triggerBuilder.withIdentity(triggerName, triggerGroupName);
triggerBuilder.
startNow
();
// 触发器时间设定
triggerBuilder.withSchedule(CronScheduleBuilder.
cronSchedule
(cron));
// 创建Trigger对象
CronTrigger trigger = (CronTrigger) triggerBuilder.build();
// 调度容器设置JobDetail和Trigger
scheduler
.scheduleJob(jobDetail, trigger);
// 启动
if
(!
scheduler
.isShutdown()) {
scheduler
.start();
}
}
catch
(Exception e) {
throw new
RuntimeException(e);
}
}
/**
*
@param
jobName
*
@param
jobGroupName
*
@param
triggerName
触发器名
*
@param
triggerGroupName
触发器组名
*
@param
cron
时间设置，参考quartz说明文档
*
@Description:
修改一个任务的触发时间
*/
public void
modifyJobTime(String jobName,
String jobGroupName, String triggerName, String triggerGroupName, String cron) {
try
{
TriggerKey triggerKey = TriggerKey.
triggerKey
(triggerName, triggerGroupName);
CronTrigger trigger = (CronTrigger)
scheduler
.getTrigger(triggerKey);
if
(trigger ==
null
) {
return
;
}
String oldTime = trigger.getCronExpression();
if
(!oldTime.equalsIgnoreCase(cron)) {
/** 方式一 ：调用 rescheduleJob 开始 */
// 触发器
TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.
newTrigger
();
// 触发器名,触发器组
triggerBuilder.withIdentity(triggerName, triggerGroupName);
triggerBuilder.
startNow
();
// 触发器时间设定
triggerBuilder.withSchedule(CronScheduleBuilder.
cronSchedule
(cron));
// 创建Trigger对象
trigger = (CronTrigger) triggerBuilder.build();
// 方式一 ：修改一个任务的触发时间
scheduler
.rescheduleJob(triggerKey, trigger);
/** 方式一 ：调用 rescheduleJob 结束 */
/** 方式二：先删除，然后在创建一个新的Job */
//JobDetail jobDetail = scheduler.getJobDetail(JobKey.jobKey(jobName, jobGroupName));
//Class<? extends Job> jobClass = jobDetail.getJobClass();
//removeJob(jobName, jobGroupName, triggerName, triggerGroupName);
//addJob(jobName, jobGroupName, triggerName, triggerGroupName, jobClass, cron);
/** 方式二 ：先删除，然后在创建一个新的Job */
}
}
catch
(Exception e) {
throw new
RuntimeException(e);
}
}
/**
*
@param
jobName
*
@param
jobGroupName
*
@param
triggerName
*
@param
triggerGroupName
*
@Description:
移除一个任务
*/
public void
removeJob(String jobName, String jobGroupName,
String triggerName, String triggerGroupName) {
try
{
TriggerKey triggerKey = TriggerKey.
triggerKey
(triggerName, triggerGroupName);
scheduler
.pauseTrigger(triggerKey);
// 停止触发器
scheduler
.unscheduleJob(triggerKey);
// 移除触发器
scheduler
.deleteJob(JobKey.
jobKey
(jobName, jobGroupName));
// 删除任务
}
catch
(Exception e) {
throw new
RuntimeException(e);
}
}
/**
*
@Description:启动所有定时任务
*/
public void
startJobs() {
try
{
scheduler
.start();
}
catch
(Exception e) {
throw new
RuntimeException(e);
}
}
/**
*
@Description:关闭所有定时任务
*/
public void
shutdownJobs() {
try
{
if
(!
scheduler
.isShutdown()) {
scheduler
.shutdown();
}
}
catch
(Exception e) {
throw new
RuntimeException(e);
}
}
public
Scheduler getScheduler() {
return
scheduler
;
}
public void
setScheduler(Scheduler scheduler) {
this
.
scheduler
= scheduler;
}
}
4.最后就是具体任务类的编写了，这边有几种方式：一种是你所有的定时任务都写再一个类里面，通过if去判断，二是你写多个任务类直接启动相关任务类就可以了，三是你就写一个任务类，但是不是通过if去判断，而是通过接口实现类去实现这个接口。关于三种方式，我推荐第三种，因为第三者可扩展性最高。下面我们具体看一下任务类的实现：
package
com.infun.platform.quartz;
import
org.quartz.Job;
import
org.quartz.JobDataMap;
import
org.quartz.
JobExecutionContext
;
import
org.quartz.JobExecutionException;
/**
*
* 小队定时任务
*
@author
linzhiqiang
*
@date
2018/6/4
*/
public class
QuartzTask
implements
Job {
@Override
public void
execute(
JobExecutionContext
jobExecutionContext)
throws
JobExecutionException {
//执行任务
JobDataMap dataMap = jobExecutionContext.getJobDetail().getJobDataMap();
TaskData quartzTask = (TaskData)dataMap.get(
"task"
);
// 调用接口函数
quartzTask.execute();
}
}
任务的参数接口代码：
package
com.infun.platform.quartz;
/**
* 任务接口，接口具体实现由调用者来实现
*
@author
linzhiqiang
*
@date
2018/6/5
*/
public interface
TaskData {
/**
* 任务具体的执行方法
*/
public void
execute();
}
任务的参数接口实现类代码：
package
com.infun.platform.quartz;
/**
*
*
@author
linzhiqiang
*
@date
2018/6/5
*/
public class
TaskDataImpl
implements
TaskData {
@Override
public void
execute() {
System.
out
.println(
"定时任务。。。。。。。。。。。。执行中。。。。。"
);
}
}
最后我们写一个测试类来测试一下，定时任务有没有生效，测试类如下所示：
package
com.infun.platform.quartz;
import
org.springframework.beans.BeansException;
import
org.springframework.context.ApplicationContext;
import
org.springframework.context.support.ClassPathXmlApplicationContext;
/**
*
*
@author
linzhiqiang
*
@date
2018/6/5
*/
public class
Test {
public static void
main(String[] args)
throws
BeansException {
ApplicationContext ctx =
new
ClassPathXmlApplicationContext(
"quartz.xml"
);
QuartzManager quartzManager = (QuartzManager) ctx.getBean(
"quartzManager"
);
try
{
System.
out
.println(
"【系统启动】开始(每1秒输出一次 job2)..."
);
Thread.
sleep
(
5000
);
System.
out
.println(
"【增加job1启动】开始(每1秒输出一次)..."
);
quartzManager.addJob(
"test"
,
"test"
,
"test"
,
"test"
, QuartzTask.
class
,
"0/1 * * * * ?"
,
new
TaskDataImpl());
Thread.
sleep
(
5000
);
System.
out
.println(
"【修改job1时间】开始(每2秒输出一次)..."
);
quartzManager.modifyJobTime(
"test"
,
"test"
,
"test"
,
"test"
,
"0/2 * * * * ?"
);
//
Thread.
sleep
(
10000
);
System.
out
.println(
"【移除job1定时】开始..."
);
quartzManager.removeJob(
"test"
,
"test"
,
"test"
,
"test"
);
// 关掉任务调度容器
quartzManager.shutdownJobs();
}
catch
(Exception e) {
e.printStackTrace();
}
}
}
运行结果如下所示：
结果显示定时任务成功启动，并且正确执行。这里我们可以修改一下测试类，将我们需要的定时任务做成API暴露给其它模块来调用，API类如下所示：
package
com.infun.platform.quartz;
/**
*
* 任务调度服务
*
@author
linzhiqiang
*
@date
2018/6/5
*/
public class
QuartzService {
public void
setQuartzManager(QuartzManager quartzManager) {
this
.
quartzManager
= quartzManager;
}
private
QuartzManager
quartzManager
;
/**
* 启动定时任务
*
@param
jobClass
任务的task类
*
@param
cron
定时任务的表达式
*/
public void
startTask(Class jobClass, String cron,TaskData quartzTask){
String jobName = jobClass.getName();
quartzManager
.addJob(jobName, jobName, jobName, jobName, jobClass, cron, quartzTask);
}
/**
* 修改定时任务时间
*
@param
jobName
任务的task名称
*
@param
cron
定时任务的表达式
*/
public void
updateTaskTime(String jobName, String cron){
quartzManager
.modifyJobTime(jobName,jobName,jobName,jobName, cron);
}
/**
* 移除定时任务
*
@param
jobName
任务的task名称
*
@param
cron
定时任务的表达式
*/
public void
removeTask(String jobName, String cron){
quartzManager
.removeJob(jobName,jobName,jobName,jobName);
}
/**
* 关闭定时任务容器
* 慎用
*/
public void
shutdownJobs(){
// 关掉任务调度容器
quartzManager
.shutdownJobs();
}
}
Spring整合Quartz实现动态定时器就全部结束了，我们可以将配置文件加入到web.xml中去，这样我们项目一启动就可以马上执行定时任务了。
想要更多干货、技术猛料的孩子，快点拿起手机扫码关注我，我在这里等你哦~