任务调度
-
- 任务调度
定时任务调度：基于给定的时间点、给定的时间间隔、给定的执行次数自动执行的任务。
-
-
- unix crontab命令
-
crontab [-u user] file
crontab [-u user] [ -e | -l | -r]
-
-
- Timer
-
介绍
Timer，简单无门槛，一般也没人用。单线程。
Timer位于java.util包下，其内部包含且仅包含一个后台线程（TimeThread）对多个业务任务（TimeTask）进行定时定频率的调度。
参数说明：
task：所要执行的任务，需要extends TimeTask override run()
time/firstTime：首次执行任务的时间
period：周期性执行Task的时间间隔，单位是毫秒
delay：执行task任务前的延时时间，单位是毫秒
很显然，通过上述的描述，我们可以实现：
延迟多久后执行一次任务；指定时间执行一次任务；延迟一段时间，并周期性执行任务；指定时间，并周期性执行任务；
注意点
1：如果time/firstTime指定的时间，在当前时间之前，会发生什么呢？
在时间等于或者超过time/firstTime的时候，会执行task！也就是说，如果time/firstTime指定的时间在当前时间之前，就会立即得到执行。
延时问题！
2：schedule和scheduleAtFixedRate有什么区别？
scheduleAtFixedRate：每次执行时间为上一次任务开始起向后推一个period间隔，也就是说下次执行时间相对于上一次任务开始的时间点，因此执行时间不会延后，但是存在任务并发执行的问题。
schedule：每次执行时间为上一次任务结束后推一个period间隔，也就是说下次执行时间相对于上一次任务结束的时间点，因此执行时间会不断延后。
3：如果执行task发生异常，是否会影响其他task的定时调度？
如果TimeTask抛出RuntimeException，那么Timer会停止所有任务的运行！
4：Timer的一些缺陷？
前面已经提及到Timer背后是一个单线程，因此Timer存在管理并发任务的缺陷：所有任务都是由同一个线程来调度，所有任务都是串行执行，意味着同一时间只能有一个任务得到执行，而前一个任务的延迟或者异常会影响到之后的任务。
其次，Timer的一些调度方式还算比较简单，无法适应实际项目中任务定时调度的复杂度。
5：停止和移除
cancel()：终止Timer计时器，丢弃所有当前已安排的任务（TimeTask也存在cancel()方法，不过终止的是TimeTask）
purge()：从计时器的任务队列中移除已取消的任务，并返回个数
代码示例
package schedule.timer;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Timer;
import java.util.TimerTask;
/**
* Timer背后是一个单线程，因此Timer存在管理并发任务的缺陷：所有任务都是由同一个线程来调度，所有任务都是串行执行，意味着同一时间只能有一个任务得到执行，而前一个任务的延迟或者异常会影响到之后的任务。
* 其次，Timer的一些调度方式还算比较简单，无法适应实际项目中任务定时调度的复杂度。
*
*
*/
public class TimerTest {
public static void main(String[] args) {
Timer timer = new Timer();
timer.schedule(new MyTask(), Calendar.getInstance().getTime(), 1000);
}
}
class MyTask extends TimerTask{
@Override
public void run() {
System.out.println("start at :"+new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(this.scheduledExecutionTime()));
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
-
-
- ScheduledExecutorService
-
介绍
JDK5之后便提供了基于线程池的定时任务调度：ScheduledExecutorService。
设计理念：每一个被调度的任务都会被线程池中的一个线程去执行，因此任务可以并发执行，而且相互之间不受影响。
示例
package schedule.scheduledExecutor;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ScheduledExecutorServiceTest {
public static void main(String[] args) {
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);
scheduledExecutorService.scheduleAtFixedRate(new ExecutorDemo(), 1000, 2000, TimeUnit.MILLISECONDS);
}
}
class ExecutorDemo implements Runnable{
@Override
public void run() {
System.out.println("执行"+new Date());
}
}
-
-
- spring task
-
spring @Scheduled注解，一般集成于项目中，小任务很方便。
fixedRate和fixedDelay的区别
fixedRate ：每隔多少毫秒执行一次该方法， 以上一次执行开始时间计算
fixedDelay：当一次方法执行完毕之后，延迟多少毫秒再执行该方法
例子1 注解方式
package schedule.springTask1;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringTaskAnnotationTest {
public static void main(String[] args) throws BeansException {
ApplicationContext ctx = new ClassPathXmlApplicationContext("/schedule/springTask1/spring-mvc.xml");
}
}
package schedule.springTask1;
import java.util.Date;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
/**
* 基于注解的定时器
*/
@Component
public class SpringTaskAnnotation {
// 定时计算。每一秒执行一次
@Scheduled(cron = "0/1 * * * * *")
public void show() {
System.out.println(new Date() + " : Annotation：is show run");
}
/**
* 心跳更新。启动时执行一次，之后每隔2秒执行一次
*/
@Scheduled(fixedRate = 1000 * 2)
public void print() {
System.out.println(new Date() + " : Annotation：is print run");
}
// 启动加载缓存, 以上一次执行完为准
@Scheduled(fixedDelay = 1 * 1000)
public void init() {
System.out.println(new Date() + ": Annotation：is init run");
}
}
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:task="http://www.springframework.org/schema/task"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd">
<task:annotation-driven />
<context:annotation-config />
<context:component-scan base-package="schedule.springTask1" />
beans>
例子2 xml方式
package schedule.springTask2;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringTaskXmlTest {
public static void main(String[] args) throws BeansException {
ApplicationContext ctx = new ClassPathXmlApplicationContext("/schedule/springTask2/spring-mvc.xml");
}
}
package schedule.springTask2;
import java.util.Date;
/**
* 基于xml的定时器
*/
public class SpringTaskXml {
public void show() {
System.out.println(new Date() + " : XMl is show run");
}
public void print() {
System.out.println(new Date() + " : XMl print run");
}
}
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:task="http://www.springframework.org/schema/task"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd">
<bean id="task" class="schedule.springTask2.SpringTaskXml">bean>
<task:scheduled-tasks>
<task:scheduled ref="task" method="show"
cron="*/5 * * * * ?" />
<task:scheduled ref="task" method="print"
cron="*/10 * * * * ?" />
task:scheduled-tasks>
beans>
-
-
- Spring Quartz
-
开源工具 Quartz，分布式集群开源工具，可以说是中小型公司必选，当然也视自身需求而定。
介绍
两种方式实现Spirng定时任务：
1.继承自org.springframework.scheduling.quartz.QuartzJobBean
2.作业类即普通的java类，不需要继承自任何基类。
定时器任务有两种触发器：
1.按照一定频度调用任务，在Spring Quartz中对应的触发器为：org.springframework.scheduling.quartz.SimpleTriggerBean
2.按照指定时间调用任务，在Spring Quartz中对应的调度器为：org.springframework.scheduling.quartz.CronTriggerBean
说明：
1、从代码上来看，有XxxBuilder、XxxFactory，说明Quartz用到了Builder、Factory模式，还有非常易懂的链式编程风格。
2、Quartz有3个核心概念：调度器（Scheduler）、任务（Job&JobDetail）、触发器（Trigger）。（一个任务可以被多个触发器触发，一个触发器只能触发一个任务）
3、注意当Scheduler调度Job时，实际上会通过反射newInstance一个新的Job实例（待调度完毕后销毁掉），同时会把JobExecutionContext传递给Job的execute方法，Job实例通过JobExecutionContext访问到Quartz运行时的环境以及Job本身的明细数据。
4、JobDataMap可以装载任何可以序列化的数据，存取很方便。需要注意的是JobDetail和Trigger都可以各自关联上JobDataMap。JobDataMap除了可以通过上述代码获取外，还可以在YourJob实现类中，添加相应setter方法获取。
5、Trigger用来告诉Quartz调度程序什么时候执行，常用的触发器有2种：SimpleTrigger（类似于Timer）、CronTrigger（类似于Linux的Crontab）。
6、实际上，Quartz在进行调度器初始化的时候，会加载quartz.properties文件进行一些属性的设置，比如Quartz后台线程池的属性（threadCount）、作业存储设置等。它会先从工程中找，如果找不到那么就是用quartz.jar中的默认的quartz.properties文件。
7、Quartz存在监听器的概念，比如任务执行前后、任务的添加等，可以方便实现任务的监控。
cronExpression配置说明
| 字段 |
允许值 |
允许的特殊字符 |
| 秒 |
0-59 |
, - * / |
| 分 |
0-59 |
, - * / |
| 小时 |
0-23 |
, - * / |
| 日期 |
1月31日 |
, - * ? / L W C |
| 月份 |
1-12 或者 JAN-DEC |
, - * / |
| 星期 |
1-7 或者 SUN-SAT |
, - * ? / L C # |
| 年（可选） |
留空, 1970-2099 |
, - * / |
特殊字符说明：
| 字符 |
意义 |
| * |
表示所有值； |
| ? |
表示未说明的值，即不关心它为何值； |
| - |
表示一个指定的范围； |
| , |
表示附加一个可能值； |
| / |
符号前表示开始时间，符号后表示每次递增的值； |
| L(“last”) |
(“last”) “L” 用在day-of-month字段意思是 |
| W(“weekday”) |
只能用在day-of-month字段。用来描叙最接近指定天的工作日（周一到周五）。例如：在day-of-month字段用“15W”指“最接近这个月第15天的工作日”，即如果这个月第15天是周六，那么触发器将会在这个月第14天即周五触发；如果这个月第15天是周日，那么触发器将会在这个月第16 天即周一触发；如果这个月第15天是周二，那么就在触发器这天触发。注意一点：这个用法只会在当前月计算值，不会越过当前月。“W”字符仅能在day- of-month指明一天，不能是一个范围或列表。也可以用“LW”来指定这个月的最后一个工作日。 |
| # |
只能用在day-of-week字段。用来指定这个月的第几个周几。例：在day-of-week字段用”6#3”指这个月第3个周五（6指周五，3指第3个）。如果指定的日期不存在，触发器就不会触发。 |
| C |
指和calendar联系后计算过的值。例：在day-of-month 字段用“5C”指在这个月第5天或之后包括calendar的第一天；在day-of-week字段用“1C”指在这周日或之后包括calendar的第一天。 |
Cron表达式教程
这里给出一些常用的示例：
0 15 10 ? * 每天10点15分触发
0 15 10 ? 2017 2017年每天10点15分触发
0 14 * ? 每天下午的 2点到2点59分每分触发
0 0/5 14 ? 每天下午的 2点到2点59分(整点开始，每隔5分触发)
0 0/5 14,18 ? 每天下午的 2点到2点59分、18点到18点59分(整点开始，每隔5分触发)
0 0-5 14 ? 每天下午的 2点到2点05分每分触发
0 15 10 ? * 6L 每月最后一周的星期五的10点15分触发
0 15 10 ? * 6#3 每月的第三周的星期五开始触发
我们可以通过一些Cron在线工具非常方便的生成，比如http://www.pppet.net/等。
CronTrigger
CronTriggers往往比SimpleTrigger更有用，如果您需要基于日历的概念，而非SimpleTrigger完全指定的时间间隔，复发的发射工作的时间表。 CronTrigger，你可以指定触发的时间表如“每星期五中午”，或“每个工作日9:30时”，甚至“每5分钟一班9:00和10:00逢星期一上午，星期三星期五“。 即便如此，SimpleTrigger一样，CronTrigger拥有的startTime指定的时间表时生效，指定的时间表时，应停止（可选）结束时间。
Cron表达式
cron的表达式被用来配置CronTrigger实例。 cron的表达式是字符串，实际上是由七子表达式，描述个别细节的时间表。这些子表达式是分开的空白，代表：
1. Seconds
2. Minutes
3. Hours
4. Day-of-Month
5. Month
6. Day-of-Week
7. Year (可选字段)
例 "0 0 12 ? * WED" 在每星期三下午12:00 执行,
个别子表达式可以包含范围, 例如，在前面的例子里("WED")可以替换成 "MON-FRI", "MON, WED, FRI"甚至"MON-WED,SAT". “*” 代表整个时间段.
每一个字段都有一套可以指定有效值，如
Seconds (秒) ：可以用数字0－59 表示，
Minutes(分) ：可以用数字0－59 表示，
Hours(时) ：可以用数字0-23表示,
Day-of-Month(天) ：可以用数字1-31 中的任一一个值，但要注意一些特别的月份
Month(月) ：可以用0-11 或用字符串 “JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV and DEC” 表示
Day-of-Week(每周)：可以用数字1-7表示（1 ＝ 星期日）或用字符口串“SUN, MON, TUE, WED, THU, FRI and SAT”表示
“/”：为特别单位，表示为“每”如“0/15”表示每隔15分钟执行一次,“0”表示为从“0”分开始, “3/20”表示表示每隔20分钟执行一次，“3”表示从第3分钟开始执行
“?”：表示每月的某一天，或第周的某一天
“L”：用于每月，或每周，表示为每月的最后一天，或每个月的最后星期几如“6L”表示“每月的最后一个星期五”
“W”：表示为最近工作日，如“15W”放在每月（day-of-month）字段上表示为“到本月15日最近的工作日”
““#”：是用来指定“的”每月第n个工作日,例 在每周（day-of-week）这个字段中内容为"6#3" or "FRI#3" 则表示“每月第三个星期五”
例子 1 cron简单和复杂例子
可指定执行类和指定方法，可以注入service
package schedule.quartz1;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringTaskAnnotationTest {
public static void main(String[] args) throws BeansException {
ApplicationContext ctx = new ClassPathXmlApplicationContext("/schedule/quartz1/spring-mvc.xml");
}
}
package schedule.quartz1;
public class SimpleJob {
protected void execute() {
System.out.println("简单定时任务执行中…");
}
}
package schedule.quartz1;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;
public class ComplexJob extends QuartzJobBean {
private int timeout;
// 调度工厂实例化后，经过timeout时间开始执行调度
public void setTimeout(int timeout) {
this.timeout = timeout;
}
/**
* 要调度的具体任务
*/
@Override
protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
System.out.println("复杂定时任务执行中…");
}
}
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:task="http://www.springframework.org/schema/task"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd">
<bean id="simpleJob" class="schedule.quartz1.SimpleJob">bean>
<bean id="simpleJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
<property name="targetObject" ref="simpleJob" />
<property name="targetMethod" value="execute" />
<property name="concurrent" value="false" />
bean>
<bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean">
<property name="jobDetail" ref="simpleJobDetail" />
<property name="startDelay" value="1000" />
<property name="repeatInterval" value="2000" />
bean>
<bean id="complexJobDetail" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
<property name="jobClass" value="schedule.quartz1.ComplexJob" />
<property name="jobDataMap">
<map>
<entry key="timeout" value="1" />
map>
property>
<property name="durability" value="true" />
bean>
<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
<property name="jobDetail" ref="complexJobDetail" />
<property name="cronExpression" value="0/5 * * ? * *" />
bean>
<bean
class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
<list>
<ref bean="simpleTrigger" />
<ref bean="cronTrigger" />
list>
property>
bean>
beans>
例子 2 Scheduler start/stop manager配置方式
可以指定执行类（继承job），但不能注入service
package schedule.quartz2;
import org.quartz.SchedulerException;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringTaskAnnotationTest {
public static void main(String[] args) throws BeansException, InterruptedException, SchedulerException {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("/schedule/quartz2/spring-mvc.xml");
QuartzManager quartzManager = applicationContext.getBean(QuartzManager.class);
quartzManager.initJobs();
quartzManager.addJob("xxxx", "yyyy", "zzzz", "gggg",MyJob.class, "0/3 * * ? * *");
Thread.sleep(2000);
System.out.println("--change to 2s--");
quartzManager.trigger("xxxxcc", "yyyy", "zzzzx", "ggggx",MyJob2.class, "0/1 * * ? * *");
quartzManager.modifyJobTime("xxxx", "yyyy", "zzzz", "gggg", "0/2 * * ? * *");
// Thread.sleep(20000);
System.out.println("--stop--");
// quartzManager.shutdownJobs();
Thread.sleep(20000);
}
}
package schedule.quartz2;
import java.util.HashSet;
import java.util.List;
import org.apache.commons.lang3.StringUtils;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.springframework.beans.factory.annotation.Autowired;
public class QuartzManager {
private Scheduler scheduler;
@Autowired
private IJobService jobService;
//初始化所有的jobs
public void initJobs() {
Long count = jobService.listQuartzEntity(null);
if(0!=count) {
System.out.println(".....");
}
}
/**
* @Description: 添加一个定时任务
*
* @param jobName 任务名
* @param jobGroupName 任务组名
* @param triggerName 触发器名
* @param triggerGroupName 触发器组名
* @param jobClass 任务
* @param cron 时间设置，参考quartz说明文档
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public void addJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName, Class jobClass, String cron) {
try {
// 任务名，任务组，任务执行类
JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
JobDetail jobDetail = null;
if(!scheduler.checkExists(jobKey)){
jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
}else{
jobDetail = scheduler.getJobDetail(jobKey);
}
TriggerKey triggerKey = new TriggerKey(triggerName, triggerGroupName);
if(!scheduler.checkExists(triggerKey)){
// 触发器
TriggerBuilder
// 触发器名,触发器组
triggerBuilder.withIdentity(triggerName, triggerGroupName);
triggerBuilder.startNow();
// 触发器时间设定
triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
// 创建Trigger对象
CronTrigger trigger = (CronTrigger) triggerBuilder.build();
// 调度容器设置JobDetail和Trigger
scheduler.scheduleJob(jobDetail, trigger);
// scheduler.rescheduleJob(triggerKey, trigger);
//https://stackoverflow.com/questions/34176482/unable-to-store-job-because-one-already-exists-with-this-identification
// 启动
if (!scheduler.isShutdown()) {
scheduler.start();
}
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public void addJobs(String jobName, String jobGroupName, List
try {
// 任务名，任务组，任务执行类
JobDetail jobDetail = scheduler.getJobDetail(JobKey.jobKey(jobName, jobGroupName));
if(null==jobDetail){
jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
}
if(null!=triggers && !triggers.isEmpty()){
HashSet
for (SingleTrigger singleTrigger : triggers) {
if(null==scheduler.getTrigger(new TriggerKey(singleTrigger.getTriggerName(), singleTrigger.getTriggerGroup()))){
// 触发器
TriggerBuilder
// 触发器名,触发器组
triggerBuilder.withIdentity(singleTrigger.getTriggerName(), singleTrigger.getTriggerGroup());
triggerBuilder.startNow();
// 触发器时间设定
triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(singleTrigger.getTriggerCron()));
// 创建Trigger对象
CronTrigger trigger = (CronTrigger) triggerBuilder.build();
triggerSet.add(trigger);
}
}
// 调度容器设置JobDetail和Trigger
scheduler.scheduleJob(jobDetail, triggerSet, true);
// 启动
if (!scheduler.isShutdown()) {
scheduler.start();
}
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 触发任务
* @throws SchedulerException
*/
public void trigger(String jobName, String jobGroupName, String triggerName, String triggerGroupName, Class jobClass, String cron) throws SchedulerException {
JobDetail jobDetail = scheduler.getJobDetail(JobKey.jobKey(jobName, jobGroupName));
//没有对应的job和trigger
if(null==jobDetail && null==scheduler.getTrigger(new TriggerKey(triggerName, triggerGroupName))) {
addJob(jobName, jobGroupName, triggerName, triggerGroupName, jobClass, cron);
}else {
JobKey key = new JobKey(jobName, jobGroupName);
scheduler.triggerJob(key);
}
}
/**
* 停止任务
* @throws SchedulerException
*/
public void pauseJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName, Class jobClass, String cron) throws SchedulerException {
JobDetail jobDetail = scheduler.getJobDetail(JobKey.jobKey(jobName, jobGroupName));
//没有对应的job和trigger
if(null!=jobDetail && null!=scheduler.getTrigger(new TriggerKey(triggerName, triggerGroupName))) {
JobKey key = new JobKey(jobName, jobGroupName);
scheduler.pauseJob(key);
}
}
/**
* 恢复任务
* @throws SchedulerException
*/
public void resumeJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName, Class jobClass, String cron) throws SchedulerException {
JobDetail jobDetail = scheduler.getJobDetail(JobKey.jobKey(jobName, jobGroupName));
//没有对应的job和trigger
if(null!=jobDetail && null!=scheduler.getTrigger(new TriggerKey(triggerName, triggerGroupName))) {
JobKey key = new JobKey(jobName, jobGroupName);
scheduler.resumeJob(key);
}
}
/**
* @Description: 修改一个任务的触发时间
*
* @param jobName
* @param jobGroupName
* @param triggerName 触发器名
* @param triggerGroupName 触发器组名
* @param cron 时间设置，参考quartz说明文档
*/
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
// 触发器名,触发器组
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 jobClass = jobDetail.getJobClass();
// removeJob(jobName, jobGroupName, triggerName,
// triggerGroupName);
// addJob(jobName, jobGroupName, triggerName, triggerGroupName,
// jobClass, cron);
/** 方式二 ：先删除，然后在创建一个新的Job */
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* @Description: 移除一个trigger
*
* @param jobName
* @param jobGroupName
* @param triggerName
* @param triggerGroupName
*/
public void removeTrigger(String jobName, String jobGroupName, String triggerName, String triggerGroupName) {
try {
TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
scheduler.pauseTrigger(triggerKey);// 停止触发器
scheduler.unscheduleJob(triggerKey);// 移除触发器
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* @Description: 移除一个任务
*
* @param jobName
* @param jobGroupName
* @param triggerName
* @param triggerGroupName
*/
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;
}
public String transCron(String time) {
String seconds = StringUtils.substringAfterLast(time, ":");
String minute = StringUtils.substringAfter(time, ":").substring(0, 2);
String hour = StringUtils.substringAfter(time, " ").substring(0, 2);
String day = StringUtils.substringAfterLast(time, "-").substring(0, 2);
String month = StringUtils.substringAfter(time, "-").substring(0, 2);
return seconds + " " + minute + " " + hour + " " + day + " " + month + " ?";
}
}
package schedule.quartz2;
import lombok.Data;
@Data
public class QuartzEntity{
private String jobName;//任务名称
private String jobGroup;//任务分组
private String description;//任务描述
private String jobClassName;//执行类
private String cronExpression;//执行时间
private String triggerName;//执行时间
private String triggerState;//任务状态
private String oldJobName;//任务名称 用于修改
private String oldJobGroup;//任务分组 用于修改
}
package schedule.quartz2;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class MyJob implements Job {
private Logger logger = LoggerFactory.getLogger(MyJob.class);
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
try {
logger.info("【test】动态定时调度测试");
} catch (Exception e) {
e.printStackTrace();
}
}
}
package schedule.quartz2;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class MyJob2 implements Job {
private Logger logger = LoggerFactory.getLogger(MyJob2.class);
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
try {
logger.info("【test】动态定时调度测试 ------------2");
} catch (Exception e) {
e.printStackTrace();
}
}
}
package schedule.quartz2;
import java.util.List;
public interface IJobService {
List
Long listQuartzEntity(QuartzEntity quartz);
}
package schedule.quartz2;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
@Service("jobService")
public class JobServiceImpl implements IJobService {
@Autowired
private DynamicQuery dynamicQuery;
@Override
public List
Integer pageNo, Integer pageSize) {
StringBuffer nativeSql = new StringBuffer();
nativeSql.append("SELECT job.JOB_NAME as jobName,job.JOB_GROUP as jobGroup,job.DESCRIPTION as description,job.JOB_CLASS_NAME as jobClassName,");
nativeSql.append("cron.CRON_EXPRESSION as cronExpression,tri.TRIGGER_NAME as triggerName,tri.TRIGGER_STATE as triggerState,");
nativeSql.append("job.JOB_NAME as oldJobName,job.JOB_GROUP as oldJobGroup ");
nativeSql.append("FROM qrtz_job_details AS job LEFT JOIN qrtz_triggers AS tri ON job.JOB_NAME = tri.JOB_NAME ");
nativeSql.append("LEFT JOIN qrtz_cron_triggers AS cron ON cron.TRIGGER_NAME = tri.TRIGGER_NAME ");
nativeSql.append("WHERE tri.TRIGGER_TYPE = 'CRON'");
Object[] params = new Object[]{};
if(!StringUtils.isEmpty(quartz.getJobName())){//加入JobName搜索其他条件自行实现
nativeSql.append(" AND job.JOB_NAME = ?");
params = new Object[]{quartz.getJobName()};
}
return null;
}
@Override
public Long listQuartzEntity(QuartzEntity quartz) {
return 0L;
// StringBuffer nativeSql = new StringBuffer();
// nativeSql.append("SELECT COUNT(*)");
// nativeSql.append("FROM qrtz_job_details AS job LEFT JOIN qrtz_triggers AS tri ON job.JOB_NAME = tri.JOB_NAME ");
// nativeSql.append("LEFT JOIN qrtz_cron_triggers AS cron ON cron.TRIGGER_NAME = tri.TRIGGER_NAME ");
// nativeSql.append("WHERE tri.TRIGGER_TYPE = 'CRON'");
// return dynamicQuery.nativeQueryCount(nativeSql.toString(), new Object[]{});
}
}
package schedule.quartz2;
import java.util.List;
/**
* 扩展SpringDataJpa, 支持动态jpql/nativesql查询并支持分页查询
* 使用方法：注入ServiceImpl
*/
public interface DynamicQuery {
}
package schedule.quartz2;
import org.springframework.stereotype.Repository;
@Repository
public class DynamicQueryImpl implements DynamicQuery {
}
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:task="http://www.springframework.org/schema/task"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd">
<context:component-scan base-package="schedule.quartz2">context:component-scan>
<bean id="startQuartz" lazy-init="true" autowire="no"
class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
<list>
list>
property>
bean>
<bean id="quartzManager" class="schedule.quartz2.QuartzManager" lazy-init="false" init-method="startJobs">
<property name="scheduler" ref="startQuartz" />
bean>
<bean id="complexJobDetail" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
<property name="jobClass" value="schedule.quartz2.MyJob" />
<property name="jobDataMap">
<map>
<entry key="timeout" value="1" />
map>
property>
<property name="durability" value="true" />
bean>
<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
<property name="jobDetail" ref="complexJobDetail" />
<property name="cronExpression" value="0/5 * * ? * *" />
bean>
beans>
package schedule.quartz2;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.quartz.SchedulerException;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringTaskAnnotationTest {
public static void main(String[] args) throws BeansException, InterruptedException, SchedulerException {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("/schedule/quartz2/spring-mvc.xml");
QuartzManager quartzManager = applicationContext.getBean(QuartzManager.class);
quartzManager.initJobs();
List
triggers.add(new SingleTrigger("a1","b1","0/1 * * ? * *"));
triggers.add(new SingleTrigger("a2","b2","0/2 * * ? * *"));
triggers.add(new SingleTrigger("a3","b3","0/3 * * ? * *"));
triggers.add(new SingleTrigger("a4","b4","0/4 * * ? * *"));
quartzManager.addJobs("xxxx", "yyyy", triggers ,MyJob.class, "0/3 * * ? * *");
Thread.sleep(7000);
System.out.println("--- start to change cron ---");
quartzManager.removeTrigger("xxxx", "yyyy", "a1","b1");
quartzManager.modifyJobTime("xxxx", "yyyy", "a2","b2", "0/5 * * ? * *");
Thread.sleep(7000);
System.out.println("--- start to replace cron ---");
triggers = new ArrayList
triggers.add(new SingleTrigger("a5","b5","0/1 * * ? * *"));
quartzManager.addJobs("xxxx", "yyyy", triggers ,MyJob.class, "0/3 * * ? * *");
System.out.println(quartzManager.getScheduler().getTriggerGroupNames());
Thread.sleep(200000);
}
}
例子 3 Scheduler start/stop java方式
java方式初始化
package schedule.quartz3;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;
public class QuartzTest {
public static void main(String[] args) throws Exception {
// 从调度程序工厂获取一个调度程序的实例
Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
// 显示调度程序的名称（这里会展示我们在quartz.properties文件中的名称）
System.out.println("scheduleName = " + scheduler.getSchedulerName());
/**
* 重要: 定义一个job，并绑定到我们自定义的HelloJob的class对象
* 这里并不会马上创建一个HelloJob实例，实例创建是在scheduler安排任务触发执行时创建的 这种机制也为后面使用Spring集成提供了便利
*/
JobDetail job = JobBuilder.newJob(MyJob.class).withIdentity("job1", "group1").build();
// 声明一个触发器，现在就执行(schedule.start()方法开始调用的时候执行)；并且每间隔2秒就执行一次
// 触发器
TriggerBuilder
// 触发器名,触发器组
triggerBuilder.withIdentity("trigger1", "group1");
triggerBuilder.startNow();
// 触发器时间设定
// triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule("0/3 * * ? * *"));
triggerBuilder.withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(3).repeatForever());
Trigger trigger = triggerBuilder.build();
// 告诉quartz使用定义的触发器trigger安排执行任务job
scheduler.scheduleJob(job, trigger);
// 启动任务调度程序,内部机制是线程的启动
scheduler.start();
// 关闭任务调度程序,如果不关闭，调度程序schedule会一直运行着
// scheduler.shutdown();
}
}
package schedule.quartz2;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.impl.triggers.CronTriggerImpl;
import org.quartz.impl.triggers.SimpleTriggerImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class MyJob implements Job {
private Logger logger = LoggerFactory.getLogger(MyJob.class);
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
try {
if(context.getTrigger() instanceof CronTriggerImpl){
CronTriggerImpl xxx = ((CronTriggerImpl)context.getTrigger());
logger.info("动态定时调度测试 job group:"+xxx.getJobGroup()+", job name:"+xxx.getJobName() +", trigger group:"+xxx.getGroup()+", trigger name:"+xxx.getName()+", cronExpression "+xxx.getCronExpression());
}else if(context.getTrigger() instanceof SimpleTriggerImpl){
SimpleTriggerImpl xxx = ((SimpleTriggerImpl)context.getTrigger());
logger.info("动态定时调度测试 job group:"+xxx.getJobGroup()+", job name:"+xxx.getJobName() +", trigger group:"+xxx.getGroup()+", trigger name:"+xxx.getName()+", cronExpression "+xxx);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
例子4 注入service
SchedulerFactoryBean+AdaptableJobFactory+QuartzJobBean
Caused by: java.lang.NoSuchMethodError: org.springframework.util.ReflectionUtils.accessibleConstructor(Ljava/lang/Class;[Ljava/lang/Class;)Ljava/lang/reflect/Constructor;
一般是引入了两个重复的spring Jar包，如既引入了spring.framework 又引入了spring.core，去掉一个就好
用tree方式查看
-
-
- XXL-JOB
-
分布式任务 XXL-JOB，是一个轻量级分布式任务调度框架，支持通过 Web 页面对任务进行 CRUD 操作，支持动态修改任务状态、暂停/恢复任务，以及终止运行中任务，支持在线配置调度任务入参和在线查看调度结果。
https://github.com/xuxueli/xxl-job
https://www.cnblogs.com/xuxueli/p/5021979.html
-
-
- Elastic-Job
-
分布式任务 Elastic-Job，是一个分布式调度解决方案，由两个相互独立的子项目 Elastic-Job-Lite 和 Elastic-Job-Cloud 组成。定位为轻量级无中心化解决方案，使用 jar 包的形式提供分布式任务的协调服务。支持分布式调度协调、弹性扩容缩容、失效转移、错过执行作业重触发、并行调度、自诊。
https://gitee.com/52itstyle/spring-boot-quartz