先说点无关本文的问题，这段时间特别的不爽，可能有些同学也遇到过。其实也可以说是小事一桩，但感觉也是不容忽视的。我刚毕业时的公司，每个人每次提交代码都有着严格的规范，像table和space的缩进都有严格的要求，可以说你不遵守开发规范就相当于线上bug问题，还是比较严重的。现在发现外面的公司真的是没那么重视这个不重要却又特别重要的问题啊，啊啊啊啊啊啊！！！
什么是动态配置定时任务？
回归正题，说下这次主题，动态配置。没接触过定时任务的同学可以先看下此篇：java定时任务实现的几种方式
定时任务实现方式千人千种，不过基础的无外乎 1、jdk 的timer类 2、quartz 3、springtask 。生产上三种方式我都有使用过。但是使用过程中用的最多的便是xml配置的方式，这种方式最简单，无代码侵入，也比较好理解。
但是却有个致命的缺点，比如你要改某个任务的触发时间，亦或是你要新增一个任务，暂停一个任务。怎么做？
停应用！改xml配置！重新启动！
是不是很致命。最近重新研究了下quartz的配置，实现了不停机添加、暂停、删除、立即触发任务的方法，在本篇分享出来，其实也不算是完全的研究，在上家公司已经有大佬实现了，这次是也是基于大佬的理解重新实现下。
国际惯例~先看效果图 ps：文末有彩蛋哦~~
管理界面：
效果图：实在不知道该跑什么了，每隔十秒打一段话吧
技术实现 maven依赖
使用springboot做框架支持
|
1
2
3
4
5
6
7
8
9
10
|
<!-- quartz -->
<dependency>
<groupid>org.quartz-scheduler</groupid>
<artifactid>quartz</artifactid>
<version>2.2.1</version>
</dependency>
<dependency>
<groupid>org.springframework</groupid>
<artifactid>spring-context-support</artifactid>
</dependency>
|
数据表
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
create table `sys_task` (
`id` bigint(20) not null auto_increment,
`job_name` varchar(255) default null comment '任务名',
`description` varchar(255) default null comment '任务描述',
`cron_expression` varchar(255) default null comment 'cron表达式',
`bean_class` varchar(255) default null comment '任务执行时调用哪个类的方法 包名+类名',
`job_status` varchar(255) default null comment '任务状态',
`job_group` varchar(255) default null comment '任务分组',
`create_user` varchar(64) default null comment '创建者',
`create_time` datetime default null comment '创建时间',
`update_user` varchar(64) default null comment '更新者',
`update_time` datetime default null comment '更新时间',
primary key (`id`)
) engine=myisam auto_increment=32 default charset=utf8;
|
实现步骤
①启动项目，启动task监听
②读取数据库，将开启的任务job和trigger加载到scheduler调度器
③根据任务调度运行job类
④每次运行利用adaptablejobfactory实例化job类，以便注入要运行的service
听着是不是很简单，但却还是一头雾水，且听我慢慢道来~~
代码逻辑
第一步：启动项目，加载监听
quartz配置
springboot的配置方法，常规spring项目可以在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
|
@configuration
public class quartzconfigration {
@autowired
private jobfactory jobfactory;
@bean
public schedulerfactorybean schedulerfactorybean() {
schedulerfactorybean schedulerfactorybean = new schedulerfactorybean();
try {
schedulerfactorybean.setoverwriteexistingjobs(true);
schedulerfactorybean.setquartzproperties(quartzproperties());
schedulerfactorybean.setjobfactory(jobfactory);
} catch (exception e) {
e.printstacktrace();
}
return schedulerfactorybean;
}
// 指定quartz.properties，可在配置文件中配置相关属性
@bean
public properties quartzproperties() throws ioexception {
propertiesfactorybean propertiesfactorybean = new propertiesfactorybean();
propertiesfactorybean.setlocation(new classpathresource("/config/quartz.properties"));
propertiesfactorybean.afterpropertiesset();
return propertiesfactorybean.getobject();
}
// 创建schedule
@bean(name = "scheduler")
public scheduler scheduler() {
return schedulerfactorybean().getscheduler();
}
}
|
监听器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
@component
@order(value = 1)
public class schedulejobinitlistener implements commandlinerunner {
@autowired
taskservice schedulejobservice;
@override
public void run(string... arg0) throws exception {
try {
schedulejobservice.initschedule();
} catch (exception e) {
e.printstacktrace();
}
}
}
|
commandlinerunner类似spring框架的applicationlistener监听器。
官方的解释是:
interface used to indicate that a bean should run when it is contained within a springapplication. multiple commandlinerunner beans can be defined within the same application context and can be ordered using the ordered interface or order @order annotation.
第二步：读取数据库，加载scheduler调度器
job方法
|
1
2
3
4
5
6
7
8
9
10
|
@override
public void initschedule() throws schedulerexception {
// 这里获取任务信息数据
list<taskdo> joblist = taskmapper.list();
for (taskdo task : joblist) {
if (jobstatusenum.running.getcode().equals(task.getjobstatus())) {
quartzmanager.addjob(task);
}
}
}
|
添加任务到quartz调度器
|
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
|
/**
* 添加任务*/
@suppresswarnings("unchecked")
public void addjob(taskdo task) {
try {
// 创建jobdetail实例，绑定job实现类
// 指明job的名称，所在组的名称，以及绑定job类
class<? extends job> jobclass = (class<? extends job>) (class.forname(task.getbeanclass()).newinstance()
.getclass());
jobdetail jobdetail = jobbuilder.newjob(jobclass).withidentity(task.getjobname(), task.getjobgroup())// 任务名称和组构成任务key
.build();
// 定义调度触发规则
// 使用corntrigger规则
trigger trigger = triggerbuilder.newtrigger().withidentity(task.getjobname(), task.getjobgroup())// 触发器key
.startat(datebuilder.futuredate(1, intervalunit.second))
.withschedule(cronschedulebuilder.cronschedule(task.getcronexpression())).startnow().build();
// 把作业和触发器注册到任务调度中
scheduler.schedulejob(jobdetail, trigger);
// 启动
if (!scheduler.isshutdown()) {
scheduler.start();
}
} catch (exception e) {
e.printstacktrace();
}
}
|
scheduler作为quartz的核心调度器，有将近50多个api接口，包括任务的添加，暂停，恢复，删除等一系列的api，这里仅介绍一些常用的，想要了解更多可以稍后看下彩蛋部分。
1、start()方法：只有调用start()方法后，scheduler线程才开始启动触发器trigger，运行job
2、pausejob(jobkey jobkey) ：根据指定的jobdetail key暂停job。
3、resumejob(jobkey jobkey) ：根据指定的key恢复一个job。
4、deletejob(jobkey jobkey) ：删除一个job
5、triggerjob(jobkey jobkey) ：触发一个jobdetail(现在执行)。
6、reschedulejob(triggerkey triggerkey, trigger newtrigger)：
用给定的键删除触发器，并存储新的触发器，它必须与同一个作业相关联（新触发器必须具有指定的作业名和组）-然而，新触发器不必具有与旧触发器相同的名称。
第三步：根据任务调度运行job类
其实这一步是不需要我们编写的，在我们将正确的jobdetail 和 trigger 表达式加载到任务调度后，调度器会自动触发任务的执行
第四步：实例化job类，注入要运行的service
工厂类
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
@component
public class jobfactory extends adaptablejobfactory {
//这个对象spring会帮我们自动注入进来,也属于spring技术范畴.
//为什么需要这个类呢，在我写的这个demo中，大家可以将此类删掉，发现程序也可以正确运行，可是我为什么还是加上呢。
//大家可以看下我们的任务类，大家可以看到job对象的实例化过程是在quartz中进行的，这时候我们将spring的东西注入进来，肯定是行不通的，所以需要这个类
@autowired
private autowirecapablebeanfactory capablebeanfactory;
@override
protected object createjobinstance(triggerfiredbundle bundle) throws exception {
//调用父类的方法
object jobinstance = super.createjobinstance(bundle);
//进行注入
capablebeanfactory.autowirebean(jobinstance);
return jobinstance;
}
}
|
任务类
|
1
2
3
4
5
6
7
8
9
10
11
12
|
@disallowconcurrentexecution //作业不并发
@component
public class helloworldjob implements job{
@override
public void execute(jobexecutioncontext arg0) throws jobexecutionexception {
system.out.println("欢迎使用yyblog,这是一个定时任务 --小卖铺的老爷爷!"+ dateutils.fulltime(new date()));
}
}
|
好了，大功告成，一个简单的动态配置的定时任务已经完成。是不是so easy，下面我们再来简单实现下其他的几种常用的api吧。
暂停一个job
|
1
2
3
4
|
public void pausejob(taskdo task) throws schedulerexception {
jobkey jobkey = jobkey.jobkey(task.getjobname(), task.getjobgroup());
scheduler.pausejob(jobkey);
}
|
恢复一个job
|
1
2
3
4
|
public void resumejob(taskdo task) throws schedulerexception {
jobkey jobkey = jobkey.jobkey(task.getjobname(), task.getjobgroup());
scheduler.resumejob(jobkey);
}
|
删除一个job
|
1
2
3
4
|
public void deletejob(taskdo task) throws schedulerexception {
jobkey jobkey = jobkey.jobkey(task.getjobname(), task.getjobgroup());
scheduler.deletejob(jobkey);
}
|
立即触发job
|
1
2
3
4
|
public void runjobnow(taskdo task) throws schedulerexception {
jobkey jobkey = jobkey.jobkey(task.getjobname(), task.getjobgroup());
scheduler.triggerjob(jobkey);
}
|
更新job表达式
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public void updatejobcron(taskdo task) throws schedulerexception {
triggerkey triggerkey = triggerkey.triggerkey(task.getjobname(), task.getjobgroup());
crontrigger trigger = (crontrigger) scheduler.gettrigger(triggerkey);
cronschedulebuilder schedulebuilder = cronschedulebuilder.cronschedule(task.getcronexpression());
trigger = trigger.gettriggerbuilder().withidentity(triggerkey).withschedule(schedulebuilder).build();
scheduler.reschedulejob(triggerkey, trigger);
}
|
彩蛋部分~
好了，正文部分基本上就这些，不多废话了，本文没有太多的讲解原理，只是简单的应用，水平不够还望大家见谅。
看了上面的效果图是不是还是有种看的见摸不着的感觉，老爷爷这里也做了个线上的实例供大家体验~有兴趣的同学可以亲自试验一下。
实例地址： http://www.laoyeye.net/management/index 账号/密码：test/123456 菜单：系统设置/计划任务
当然了还有最重要的源码和API文档我也不会忘的。
源码地址： https://github.com/allanzhuo/yyblog
Quartz文档地址： https://github.com/allanzhuo/yyblog/tree/master/doc
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。
原文链接：http://www.cnblogs.com/laoyeye/p/9352002.html