参考：https://blog.csdn.net/wenniuwuren/article/details/41483667
参考：http://www.cnblogs.com/mengrennwpu/p/7141125.html
入门简介：
基本上任何公司都会用到调度这个功能， 比如我们公司需要定期执行调度生成报表， 或者比如博客什么的定时更新之类的，都可以靠Quartz来完成。正如官网所说，小到独立应用大到大型电子商务网站， Quartz都能胜任。
quartz是什么？
Quartz is a richly featured, open source job scheduling library that can be integrated within virtually any Java application - from the smallest stand-alone application to the largest e-commerce system. Quartz can be used to create simple or complex schedules for executing tens, hundreds, or even tens-of-thousands of jobs; jobs whose tasks are defined as standard Java components that may execute virtually anything you may program them to do. The Quartz Scheduler includes many enterprise-class features, such as support for JTA transactions and clustering.基于官网解释，可以看出quartz是开源且具有丰富特性的"任务调度库"，能够集成于任何的java应用，小到独立的应用，大至电子商业系统。quartz能够创建亦简单亦复杂的调度，以执行上十、上百，甚至上万的任务。任务job被定义为标准的java组件，能够执行任何你想要实现的功能。quartz调度框架包含许多企业级的特性，如JTA事务、集群的支持。
简而言之，quartz就是基于java实现的任务调度框架，用于执行你想要执行的任何任务。其次，quartz也支持.Net平台。
quartz目前的最新版本为quartz-2.2.3，下载有两种方式，完整包或Maven依赖。
(1) 完整包的下载完整包的下载地址：quartz-2.2.3-distribution.tar.gz，完整包中包含例子、源码、依赖以及说明文档等
(2) Maven依赖的导入
官网目前提供的Maven依赖为2.2.1，mvnrepository目前已支持2.3.0，版本之间的更新特性本人尚未研究。quartz的依赖至少有sl4j-api相关的jar包。
<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> quartz的核心接口
| 接口 | 含义 |
| Scheduler | scheduler的主要API接口 |
| Job | 任务实现接口，期望调度器能够执行 |
| JobDetail | 用于定义Job实例 |
| Trigger | 调度器基于特定时间来执行指定任务的组件 |
| JobBuilder | 用于定义、创建JobDetail实例 |
| TriggerBuilder | 用于定义、创建Trigger实例 |
Quartz体系结构：
明白Quartz怎么用，首先要了解Scheduler(调度器)、Job(任务)和Trigger(触发器)这3个核心的概念。
1. Job： 是一个接口，只定义一个方法execute(JobExecutionContext context)，在实现接口的execute方法中编写所需要定时执行的Job(任务)， JobExecutionContext类提供了调度应用的一些信息。Job运行时的信息保存在JobDataMap实例中；
public void execute(JobExecutionContext context) throws JobExecutionException;其中JobExecutionContext对象让Job能访问Quartz运行时环境的所有信息和Job本身的明细数据。运行时环境信息包括注册到Scheduler上与该Job相关联的JobDetail和Trigger。
例：Quartz使用(1) - 初识quartz示例中HelloWordJob获取运行环境时信息如下：
package org.ws.quartz.test1;
import org.quartz.Job;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class HelloWorldJob implements Job{
private static Logger logger = LoggerFactory.getLogger(HelloWorldJob.class);
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
logger.info("Hello World");
// 每一个Job都有其自己所属的JobDetail
JobDetail jobDetail = context.getJobDetail();
// JobDetail的名称和组名
logger.info("Name and Group: "+jobDetail.getKey());
// 获取Scheduler
Scheduler scheduler = context.getScheduler();
try {
logger.info("Scheduler name: "+scheduler.getSchedulerName());
} catch (SchedulerException e) {
e.printStackTrace();
}
logger.info("job class: "+jobDetail.getJobClass());
// 任务执行的时间
logger.info("Job fired at "+context.getFireTime());
// 任务下一次执行的时间
logger.info("Job nexe fire time: "+context.getNextFireTime());
}
}运行结果如下：
2017-07-09 16:00:59 [INFO]-[org.ws.quartz.test1.SimpleQuartzExample] init scheduler componets
2017-07-09 16:00:59 [INFO]-[org.ws.quartz.test1.SimpleQuartzExample] execute scheduler
2017-07-09 16:00:59 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Hello World
2017-07-09 16:00:59 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Name and Group: HelloWorld_Group.HelloWorld_Job
2017-07-09 16:00:59 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Scheduler name: DefaultQuartzScheduler
2017-07-09 16:00:59 [INFO]-[org.ws.quartz.test1.HelloWorldJob] job class: class org.ws.quartz.test1.HelloWorldJob
2017-07-09 16:00:59 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Job fired at Sun Jul 09 16:00:59 CST 2017
2017-07-09 16:00:59 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Job nexe fire time: Sun Jul 09 16:01:09 CST 2017
2017-07-09 16:01:09 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Hello World
2017-07-09 16:01:09 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Name and Group: HelloWorld_Group.HelloWorld_Job
2017-07-09 16:01:09 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Scheduler name: DefaultQuartzScheduler
2017-07-09 16:01:09 [INFO]-[org.ws.quartz.test1.HelloWorldJob] job class: class org.ws.quartz.test1.HelloWorldJob
2017-07-09 16:01:09 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Job fired at Sun Jul 09 16:01:09 CST 2017
2017-07-09 16:01:09 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Job nexe fire time: Sun Jul 09 16:01:19 CST 2017
2017-07-09 16:01:19 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Hello World
2017-07-09 16:01:19 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Name and Group: HelloWorld_Group.HelloWorld_Job
2017-07-09 16:01:19 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Scheduler name: DefaultQuartzScheduler
2017-07-09 16:01:19 [INFO]-[org.ws.quartz.test1.HelloWorldJob] job class: class org.ws.quartz.test1.HelloWorldJob
2017-07-09 16:01:19 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Job fired at Sun Jul 09 16:01:19 CST 2017
2017-07-09 16:01:19 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Job nexe fire time: Sun Jul 09 16:01:29 CST 2017
2017-07-09 16:01:29 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Hello World
2017-07-09 16:01:29 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Name and Group: HelloWorld_Group.HelloWorld_Job
2017-07-09 16:01:29 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Scheduler name: DefaultQuartzScheduler
2017-07-09 16:01:29 [INFO]-[org.ws.quartz.test1.HelloWorldJob] job class: class org.ws.quartz.test1.HelloWorldJob
2017-07-09 16:01:29 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Job fired at Sun Jul 09 16:01:29 CST 2017
2017-07-09 16:01:29 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Job nexe fire time: Sun Jul 09 16:01:39 CST 2017
2017-07-09 16:01:39 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Hello World
2017-07-09 16:01:39 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Name and Group: HelloWorld_Group.HelloWorld_Job
2017-07-09 16:01:39 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Scheduler name: DefaultQuartzScheduler
2017-07-09 16:01:39 [INFO]-[org.ws.quartz.test1.HelloWorldJob] job class: class org.ws.quartz.test1.HelloWorldJob
2017-07-09 16:01:39 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Job fired at Sun Jul 09 16:01:39 CST 2017
2017-07-09 16:01:39 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Job nexe fire time: Sun Jul 09 16:01:49 CST 2017
2017-07-09 16:01:49 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Hello World
2017-07-09 16:01:49 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Name and Group: HelloWorld_Group.HelloWorld_Job
2017-07-09 16:01:49 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Scheduler name: DefaultQuartzScheduler
2017-07-09 16:01:49 [INFO]-[org.ws.quartz.test1.HelloWorldJob] job class: class org.ws.quartz.test1.HelloWorldJob
2017-07-09 16:01:49 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Job fired at Sun Jul 09 16:01:49 CST 2017
2017-07-09 16:01:49 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Job nexe fire time: Sun Jul 09 16:01:59 CST 2017
2017-07-09 16:01:59 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Hello World
2017-07-09 16:01:59 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Name and Group: HelloWorld_Group.HelloWorld_Job
2017-07-09 16:01:59 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Scheduler name: DefaultQuartzScheduler
2017-07-09 16:01:59 [INFO]-[org.ws.quartz.test1.HelloWorldJob] job class: class org.ws.quartz.test1.HelloWorldJob
2017-07-09 16:01:59 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Job fired at Sun Jul 09 16:01:59 CST 2017
2017-07-09 16:01:59 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Job nexe fire time: Sun Jul 09 16:02:09 CST 2017
2017-07-09 16:01:59 [INFO]-[org.ws.quartz.test1.SimpleQuartzExample] shut down scheduler2. JobDetail： Quartz每次调度Job时， 都重新创建一个Job实例， 所以它不直接接受一个Job的实例，相反它接收一个Job实现类(JobDetail:描述Job的实现类及其它相关的静态信息，如Job名字、描述、关联监听器等信息)，以便运行时通过newInstance()的反射机制实例化Job。
JobDetail是作为Job实例进行定义的，注意部署在Scheduler上的每一个Job只创建一个JobDetail实例。且需要注意的是注册到Scheduler上的不是Job对象，而是JobDetail实例。
Job 的实例要到该执行它们的时候才会实例化出来。每次 Job 被执行，一个新的 Job 实例会被创建。其中暗含的意思就是你的 Job 不必担心线程安全性，因为同一时刻仅有一个线程去执行给定 Job 类的实例，甚至是并发执行同一 Job 也是如此。
可以使用JobDataMap来定义Job的状态，JobDataMap中可以存入key-value对，这些数据可以在Job实现类中进行传递和访问。这是向你的Job传送配置信息的便捷方法。
Job 能通过 JobExecutionContext 对象访问 JobDataMap
例：在Quartz使用(1) - 初识quartz示例中，可以在等待时间修改为20s, SimpleQuartzExample.createJobDetail方法修改为：
protected JobDetail createJobDetail(){
return JobBuilder.newJob(HelloWorldJob.class) // 待执行的任务
.withIdentity("HelloWorld_Job", "HelloWorld_Group") // 名称与组名组成Scheduler中任务的唯一标识
.usingJobData("message", "welcom to study quartz") // 存储Job的状态信息
.build(); // 构建
}同时HelloWorldJob中的execute方法修改如下：
public void execute(JobExecutionContext context) throws JobExecutionException {
logger.info("Hello World, "+context.getJobDetail().getJobDataMap().get("message"));
}执行结果如下：
2017-07-09 16:17:51 [INFO]-[org.ws.quartz.test1.SimpleQuartzExample] init scheduler componets
2017-07-09 16:17:51 [INFO]-[org.ws.quartz.test1.SimpleQuartzExample] execute scheduler
2017-07-09 16:17:51 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Hello World, welcom to study quartz
2017-07-09 16:18:01 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Hello World, welcom to study quartz
2017-07-09 16:18:11 [INFO]-[org.ws.quartz.test1.HelloWorldJob] Hello World, welcom to study quartz
2017-07-09 16:18:11 [INFO]-[org.ws.quartz.test1.SimpleQuartzExample] shut down scheduler有状态的Job可以理解为多次Job调用期间可以持有一些状态信息，这些状态信息存储在JobDataMap中，而默认的无状态job每次调用时都会创建一个新的JobDataMap。
有状态的Job示例：
调度主方法：
package org.ws.quartz.test1;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SimpleQuartzExample {
private static Logger logger = LoggerFactory.getLogger(SimpleQuartzExample.class);
public static void main(String[] args) throws SchedulerException, InterruptedException {
SimpleQuartzExample exam = new SimpleQuartzExample();
logger.info("init scheduler componets");
// 创建任务
JobDetail jobDetail = exam.createJobDetail();
// 创建触发器
Trigger trigger = exam.createTrigger();
// 创建调度器
Scheduler scheduler = exam.createScheduler();
// 构建调度任务
scheduler.scheduleJob(jobDetail, trigger);
logger.info("execute scheduler");
// 开启调度器
scheduler.start();
// 一分钟后关闭调度器
Thread.sleep(20000);
scheduler.shutdown();
logger.info("shut down scheduler");
}
protected Scheduler createScheduler() throws SchedulerException{
return StdSchedulerFactory.getDefaultScheduler();
}
protected JobDetail createJobDetail(){
return JobBuilder.newJob(HelloWorldJob.class) // 待执行的任务
.withIdentity("HelloWorld_Job", "HelloWorld_Group") // 名称与组名组成Scheduler中任务的唯一标识
.usingJobData("count", 0) // 将count初始化为0
.build(); // 构建
}
protected Trigger createTrigger(){
return TriggerBuilder.newTrigger()
.withIdentity("HelloWorld_Trigger", "HelloWorld_Group") // 名称与组名组成Scheduler中触发器的唯一标识
.withSchedule(
SimpleScheduleBuilder.simpleSchedule() // 创建SimpleTrigger
.withIntervalInSeconds(10) // 10秒间隔
.repeatForever() // 重复循环
).build(); // 构建
}
}HelloWorldJob方法：
package org.ws.quartz.test1;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.PersistJobDataAfterExecution;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@PersistJobDataAfterExecution
public class HelloWorldJob implements Job{
private static Logger logger = LoggerFactory.getLogger(HelloWorldJob.class);
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
int count = jobDataMap.getInt("count");
logger.info("count: "+count);
++count;
jobDataMap.put("count", count);
}
}执行结果：
2017-07-09 16:38:55 [INFO]-[org.ws.quartz.test1.SimpleQuartzExample] init scheduler componets
2017-07-09 16:38:55 [INFO]-[org.ws.quartz.test1.SimpleQuartzExample] execute scheduler
2017-07-09 16:38:55 [INFO]-[org.ws.quartz.test1.HelloWorldJob] count: 0
2017-07-09 16:39:05 [INFO]-[org.ws.quartz.test1.HelloWorldJob] count: 1
2017-07-09 16:39:15 [INFO]-[org.ws.quartz.test1.HelloWorldJob] count: 2
2017-07-09 16:39:15 [INFO]-[org.ws.quartz.test1.SimpleQuartzExample] shut down scheduler如果不增加@PersistJobDataAfterExecution注解，运行结果为：
2017-07-09 16:40:58 [INFO]-[org.ws.quartz.test1.SimpleQuartzExample] init scheduler componets
2017-07-09 16:40:59 [INFO]-[org.ws.quartz.test1.SimpleQuartzExample] execute scheduler
2017-07-09 16:40:59 [INFO]-[org.ws.quartz.test1.HelloWorldJob] count: 0
2017-07-09 16:41:08 [INFO]-[org.ws.quartz.test1.HelloWorldJob] count: 0
2017-07-09 16:41:18 [INFO]-[org.ws.quartz.test1.HelloWorldJob] count: 0
2017-07-09 16:41:19 [INFO]-[org.ws.quartz.test1.SimpleQuartzExample] shut down scheduler可见 @PersistJobDataAfterExecution的作用在于持久化保存在JobDataMap中的传递参数，使得多次执行Job，可以获取传递参数的状态信息。
3.3 @DisallowConcurrentExecution
quartz中另一个常用的注解为@DisallowConcurrentExecution，该注解可以同一个时刻，同一个任务只能执行一次，不能并行执行两个或多个同一任务。但需要注意的是，多个不同的任务是可以同时执行的。
3. Trigger： 是一个类，描述触发Job执行的时间触发规则。主要有SimpleTrigger和CronTrigger这两个子类。当且仅当需调度一次或者以固定时间间隔周期执行调度，SimpleTrigger是最适合的选择；而CronTrigger则可以通过Cron表达式定义出各种复杂时间规则的调度方案：如工作日周一到周五的15：00~16：00执行调度等；
通用Trigger属性
quartz中所有的触发器Trigger都有一些共有属性，如TriggerKey，startTime等，这些属性可以使用TriggerBuilder进行设置。常用的属性举例如下：
(1) triggerKey：触发器的标识，由名称与分组唯一指定，便于调度器调用与查找。
(2) jobKey: 当触发器被触发时，标识哪一个任务Job应该被执行。
(3) startTime: 表示触发器第一次开始触发的时间。
(4) endTime: 表示触发器终止触发的时间。
优先级
当存在多个触发器时，quartz可能没有足够的资源立即触发所有配置为同一时间触发的triggers，因此可以设置每个Trigger的优先级。默认的优先级为5，可取任意的整型值，包括正数或负数。注意优先级仅用于所有相同时间触发的triggers。
未启动指令"Misfire Instructions"
Trigger未触发一般产生于调度器被关闭，或线程池不足时。不同的Trigger类型有不同的未启动指令。默认的，他们会使用"smart policy"指定。这些指令的使用场景在于，当scheduler开启时，它将搜索所有未启动的持久化的触发器，然后基于触发器各自配置"未启动指令"来更新触发器。未启动指令用于当trigger未正常触发时，是否恢复执行的场景。
Cron表达式的格式：秒 分 时 日 月 周 年(可选)。
字段名 允许的值 允许的特殊字符
秒 0-59 , - * /
分 0-59 , - * /
小时 0-23 , - * /
日 1-31 , - * ? / L W C
月 1-12 or JAN-DEC , - * /
周几 1-7 or SUN-SAT , - * ? / L C # SUN, MON, TUE, WED, THU, FRI and SAT
年 (可选字段) empty, 1970-2099 , - * /
“?”字符：表示不确定的值
“,”字符：指定数个值
“-”字符：指定一个值的范围
“/”字符：指定一个值的增加幅度。n/m表示从n开始，每次增加m
“L”字符：用在日表示一个月中的最后一天，用在周表示该月最后一个星期X
“W”字符：指定离给定日期最近的工作日(周一到周五)
“#”字符：表示该月第几个周X。6#3表示该月第3个周五
秒 0-59 , - * /
分 0-59 , - * /
小时 0-23 , - * /
日 1-31 , - * ? / L W C
月 1-12 or JAN-DEC , - * /
周几 1-7 or SUN-SAT , - * ? / L C # SUN, MON, TUE, WED, THU, FRI and SAT
年 (可选字段) empty, 1970-2099 , - * /
“?”字符：表示不确定的值
“,”字符：指定数个值
“-”字符：指定一个值的范围
“/”字符：指定一个值的增加幅度。n/m表示从n开始，每次增加m
“L”字符：用在日表示一个月中的最后一天，用在周表示该月最后一个星期X
“W”字符：指定离给定日期最近的工作日(周一到周五)
“#”字符：表示该月第几个周X。6#3表示该月第3个周五
Cron表达式范例：
每隔5秒执行一次：*/5 * * * * ?
每隔1分钟执行一次：0 */1 * * * ?
每天23点执行一次：0 0 23 * * ?
每天凌晨1点执行一次：0 0 1 * * ?
每月1号凌晨1点执行一次：0 0 1 1 * ?
每月最后一天23点执行一次：0 0 23 L * ?
每周星期天凌晨1点实行一次：0 0 1 ? * L
在26分、29分、33分执行一次：0 26,29,33 * * * ?
每天的0点、13点、18点、21点都执行一次：0 0 0,13,18,21 * * ?
4. Calendar：org.quartz.Calendar和java.util.Calendar不同， 它是一些日历特定时间点的集合（可以简单地将org.quartz.Calendar看作java.util.Calendar的集合——java.util.Calendar代表一个日历时间点，无特殊说明后面的Calendar即指org.quartz.Calendar）。 一个Trigger可以和多个Calendar关联， 以便排除或包含某些时间点。
注意此Calendar为quartz自身的定义接口，而非Java自带的Calendar。
Calendar需要在Scheduler定义过程中，通过scheduler.addCalendar()进行初始化和注册。
示例：
import static org.quartz.JobBuilder.*;
import static org.quartz.TriggerBuilder.*;
import static org.quartz.SimpleScheduleBuilder.*;
Trigger t = newTrigger()
.withIdentity("myTrigger")
.forJob("myJob")
.withSchedule(dailyAtHourAndMinute(9, 30)) // execute job daily at 9:30
.modifiedByCalendar("myHolidays") // but not on holidays
.build();
// .. schedule job with trigger
Trigger t2 = newTrigger()
.withIdentity("myTrigger2")
.forJob("myJob2")
.withSchedule(dailyAtHourAndMinute(11, 30)) // execute job daily at 11:30
.modifiedByCalendar("myHolidays") // but not on holidays
.build();
// .. schedule job with trigger2假设，我们安排每周星期一早上10:00执行任务，但是如果碰到法定的节日，任务则不执行，这时就需要在Trigger触发机制的基础上使用Calendar进行定点排除。针对不同时间段类型，Quartz在org.quartz.impl.calendar包下提供了若干个Calendar的实现类，如AnnualCalendar、MonthlyCalendar、WeeklyCalendar分别针对每年、每月和每周进行定义；
SimpleTrigger
当需要在规定时间执行一次或在规定的时间段以一定的时间间隔重复触发执行Job时，SimpleTrigger就可以满足。
SimpleTrigger的属性有：开始时间、结束时间、重复次数和重复的时间间隔。重复次数属性的值可以为0、正整数、或常量 SimpleTrigger.REPEAT_INDEFINITELY，重复的时间间隔属性值必须为0或长整型的正整数，以毫秒作为时间单位，当重复的时间间隔为0时，意味着与Trigger同时触发执行。如果有指定结束时间属性值，则结束时间属性优先于重复次数属性，这样的好处在于：当我们需要创建一个每间隔10秒钟触发一次直到指定的结束时间的 Trigger，而无需去计算从开始到结束的所重复的次数，我们只需简单的指定结束时间和使用REPEAT_INDEFINITELY作为重复次数的属性 值即可。
示例：
(1) 创建在特定时间触发，非重复的Trigger
import static org.quartz.TriggerBuilder.*;
import static org.quartz.SimpleScheduleBuilder.*;
import static org.quartz.DateBuilder.*:
SimpleTrigger trigger = (SimpleTrigger) newTrigger()
.withIdentity("trigger1", "group1")
.startAt(myStartTime) // some Date
.forJob("job1", "group1") // identify job with name, group strings
.build();(2) 创建在特定时间触发，重复间隔为10次，重复执行10次的Trigger
import static org.quartz.TriggerBuilder.*;
import static org.quartz.SimpleScheduleBuilder.*;
import static org.quartz.DateBuilder.*:
trigger = newTrigger()
.withIdentity("trigger3", "group1")
.startAt(myTimeToStartFiring) // if a start time is not given (if this line were omitted), "now" is implied
.withSchedule(simpleSchedule()
.withIntervalInSeconds(10)
.withRepeatCount(10)) // note that 10 repeats will give a total of 11 firings
.forJob(myJob) // identify job with handle to its JobDetail itself
.build();(3) 创建5分钟后执行，且触发一次的Trigger
trigger = (SimpleTrigger) newTrigger()
.withIdentity("trigger5", "group1")
.startAt(futureDate(5, IntervalUnit.MINUTE)) // use DateBuilder to create a date in the future
.forJob(myJobKey) // identify job with its JobKey
.build();(4) 创建立即执行，且重复间隔为5分钟，到22点结束的Trigger
trigger = newTrigger()
.withIdentity("trigger7", "group1")
.withSchedule(simpleSchedule()
.withIntervalInMinutes(5)
.repeatForever())
.endAt(dateOf(22, 0, 0))
.build();(5) 创建在下一小时触发，且每2小时执行重复执行的Trigger
trigger = newTrigger()
.withIdentity("trigger8") // because group is not specified, "trigger8" will be in the default group
.startAt(evenHourDate(null)) // get the next even-hour (minutes and seconds zero ("00:00"))
.withSchedule(simpleSchedule()
.withIntervalInHours(2)
.repeatForever())
// note that in this example, 'forJob(..)' is not called
// - which is valid if the trigger is passed to the scheduler along with the job
.build();
scheduler.scheduleJob(trigger, job);SimpleTrigger的未启动指令包含如下：
MISFIRE_INSTRUCTION_SMART_POLICY
MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY
MISFIRE_INSTRUCTION_FIRE_NOW
MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT
MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_REMAINING_REPEAT_COUNT
MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT
MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_EXISTING_COUNT构件SimpleTrigger的时候，可以指定Trigger的未启动指令：
trigger = newTrigger()
.withIdentity("trigger7", "group1")
.withSchedule(simpleSchedule()
.withIntervalInMinutes(5)
.repeatForever()
.withMisfireHandlingInstructionNextWithExistingCount())
.build();CronTrigger
cron表达式
CronTrigger 支持比SimpleTrigger更具体、更复杂的调度。基于cron表达式，CronTrigger支持类似日历的重复间隔，而非单一的时间间隔。
序号 说明 是否必填 允许填写的值 允许的通配符 1 秒 是 0-59 , - * / 2 分 是 0-59 , - * / 3 小时 是 0-23 , - * / 4 日 是 1-31 , - * ? / L W 5 月 是 1-12或JAN-DEC , - * / 6 周 是 1-7或SUN-SAT , - * ? / L # 7 年 否 空或1999-2017 , - * /
通配符的说明：
(1) 反斜线（/）字符表示增量值。例如，在秒字段中“5/15”代表从第 5 秒开始，每 15 秒一次。
(2) 星号（*）字符是通配字符，表示该字段可以接受任何可能的值，例如:在分的字段上设置 "*",表示每一分钟都会触发。
(3) 问号（?）问号表示这个字段不包含具体值。如果指定月内日期，可以在月内日期字段中插入“?”，表示周内日期值无关紧要。
(4) - 表示区间，例如 在小时上设置 "10-12",表示 10,11,12点都会触发。
(5) 逗号（, ） 表示指定多个值，例如在周字段上设置 "MON,WED,FRI" 表示周一，周三和周五触发。
(6) 井号（#）字符为给定月份指定具体的工作日实例。把“MON#2”放在周内日期字段中，表示把任务安排在当月的第二个星期一。
(7) L 表示最后的意思。在日字段设置上，表示当月的最后一天(依据当前月份，如果是二月还会依据是否是润年[leap]), 在周字段上表示星期六，相当于"7"或"SAT"。如果在"L"前加上数字，则表示该数据的最后一个。例如在周字段上设置"6L"这样的格式,则表示“本月最后一个星期五"。
(8) W 表示离指定日期的最近那个工作日(周一至周五). 例如在日字段上设置"15W"，表示离每月15号最近的那个工作日触发。如果15号正好是周六，则找最近的周五(14号)触发, 如果15号是周未，则找最近的下周一(16号)触发.如果15号正好在工作日(周一至周五)，则就在该天触发。如果指定格式为 "1W",它则表示每月1号往后最近的工作日触发。如果1号正是周六，则将在3号下周一触发。(注，"W"前只能设置具体的数字,不允许区间"-")。
注：'L'和 'W'可以组合使用。如果在日字段上设置"LW"，则表示在本月的最后一个工作日触发。
cron表达式的举例如下：
CronTrigger构建10 * * * ?--------------每个小时过10分执行一次 0/32 8,12 * * ? ----------每天8:32,12:32 执行一次 0/2 * * * ?--------------每2分钟执行一次 0 12 * * ?---------------在每天中午12：00触发 15 10 ? * *---------------每天上午10:15 触发 15 10 * * ?---------------每天上午10:15 触发 15 10 * * ? *---------------每天上午10:15 触发 15 10 * * ? 2005---------------在2005年中的每天上午10:15 触发 * 14 * * ?---------------每天在下午2：00至2：59之间每分钟触发一次 0/5 14 * * ?---------------每天在下午2：00至2：59之间每5分钟触发一次 0/5 14,18 * * ?---------------每天在下午2：00至2：59和6：00至6：59之间的每5分钟触发一次 0-5 14 * * ?---------------每天在下午2：00至2：05之间每分钟触发一次 10,44 14 ? 3 WED---------------每三月份的星期三在下午2：00和2：44时触发 15 10 ? * MON-FRI---------------从星期一至星期五的每天上午10：15触发 15 10 15 * ?---------------在每个月的每15天的上午10：15触发 15 10 L * ?---------------在每个月的最后一天的上午10：15触发 15 10 ? * 6L---------------在每个月的最后一个星期五的上午10：15触发 15 10 ? * 6L 2002-2005---------------在2002, 2003, 2004 and 2005年的每个月的最后一个星期五的上午10：15触发 15 10 ? * 6#3---------------在每个月的第三个星期五的上午10：15触发 0 12 1/5 * ?---------------从每月的第一天起每过5天的中午12：00时触发 11 11 11 11 ?---------------在每个11月11日的上午11：11时触发
可以使用TriggerBuilder 来定义CronTrigger对象。示例如下：
import static org.quartz.TriggerBuilder.*;
import static org.quartz.CronScheduleBuilder.*;
import static org.quartz.DateBuilder.*:
trigger = newTrigger()
.withIdentity("trigger3", "group1")
.withSchedule(cronSchedule("0 0/2 8-17 * * ?"))
.forJob("myJob", "group1")
.build();
trigger = newTrigger()
.withIdentity("trigger3", "group1")
.withSchedule(dailyAtHourAndMinute(10, 42))
.forJob(myJobKey)
.build();
trigger = newTrigger()
.withIdentity("trigger3", "group1")
.withSchedule(cronSchedule("0 42 10 * * ?"))
.forJob(myJobKey)
.build();
trigger = newTrigger()
.withIdentity("trigger3", "group1")
.withSchedule(weeklyOnDayAndHourAndMinute(DateBuilder.WEDNESDAY, 10, 42))
.forJob(myJobKey)
.inTimeZone(TimeZone.getTimeZone("Asia/Shanghai"))
.build();
trigger = newTrigger()
.withIdentity("trigger3", "group1")
.withSchedule(cronSchedule("0 42 10 ? * WED"))
.inTimeZone(TimeZone.getTimeZone("Asia/Shanghai"))
.forJob(myJobKey)
.build();CronTrigger Misfire Instruction
CronTrigger的未启动指令包含：
MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY
MISFIRE_INSTRUCTION_DO_NOTHING
MISFIRE_INSTRUCTION_FIRE_NOW
MISFIRE_INSTRUCTION_SMART_POLICY未启动指令的使用：
trigger = newTrigger()
.withIdentity("trigger3", "group1")
.withSchedule(cronSchedule("0 0/2 8-17 * * ?")
.withMisfireHandlingInstructionFireAndProceed())
.forJob("myJob", "group1")
.build();5. Scheduler： 代表一个Quartz的独立运行容器， Trigger和JobDetail可以注册到Scheduler中， 两者在Scheduler中拥有各自的组及名称， 组及名称是Scheduler查找定位容器中某一对象的依据， Trigger的组及名称必须唯一， JobDetail的组和名称也必须唯一（但可以和Trigger的组和名称相同，因为它们是不同类型的）。Scheduler定义了多个接口方法， 允许外部通过组及名称访问和控制容器中Trigger和JobDetail。
Scheduler可以将Trigger绑定到某一JobDetail中， 这样当Trigger触发时， 对应的Job就被执行。一个Job可以对应多个Trigger， 但一个Trigger只能对应一个Job。可以通过SchedulerFactory创建一个Scheduler实例。Scheduler拥有一个SchedulerContext，它类似于ServletContext，保存着Scheduler上下文信息，Job和Trigger都可以访问SchedulerContext内的信息。SchedulerContext内部通过一个Map，以键值对的方式维护这些上下文数据，SchedulerContext为保存和获取数据提供了多个put()和getXxx()的方法。可以通过Scheduler# getContext()获取对应的SchedulerContext实例；
一个调度器的生命周期：通过SchedulerFactory创建，直到执行其shutdown()方法。当Scheduler创建之后，可以进行增加、删除及显示任务Job与触发器Trigger，并且执行其他的调度相关的操作，如暂停一个触发器Trigger。需要注意的是，直到调用start()方法时，Scheduler才正式开始执行job和trigger。
StdSchedulerFactory用于创建Scheduler，其依赖于一系列的属性来决定如何产生Scheduler。可以通过四种途径向StdSchedulerFactory提供属性配置信息。
1) 通过java.util.Properties实例提供
package org.ws.quartz.test2;
import java.util.Properties;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SchedulerExample {
private static Logger logger = LoggerFactory.getLogger(SchedulerExample.class);
public static void main(String[] args) {
// 创建工厂实例
StdSchedulerFactory factory = new StdSchedulerFactory();
// 创建配置工厂的属性对象
Properties props = new Properties();
props.put(StdSchedulerFactory.PROP_THREAD_POOL_CLASS, "org.quartz.simpl.SimpleThreadPool"); // 线程池定义
props.put("org.quartz.threadPool.threadCount", "10"); // 默认Scheduler的线程数
try {
// 使用定义的属性初始化工厂
factory.initialize(props);
Scheduler scheduler = factory.getScheduler();
scheduler.start();
logger.info("scheudler started, metadata: "+scheduler.getMetaData());
} catch (SchedulerException e) {
e.printStackTrace();
}
}
}执行后的结果：
2017-07-09 15:15:17 [INFO]-[org.ws.quartz.test2.SchedulerExample] scheudler started, metadata: Quartz Scheduler (v2.2.1) 'QuartzScheduler' with instanceId 'NON_CLUSTERED' Scheduler class: 'org.quartz.impl.StdScheduler' - running locally.
Running since: Sun Jul 09 15:15:17 CST 2017
Not currently in standby mode.
Number of jobs executed: 0
Using thread pool 'org.quartz.simpl.SimpleThreadPool' - with 10 threads.
Using job-store 'org.quartz.simpl.RAMJobStore' - which does not support persistence. and is not clustered.可以看到对应的配置属性已经生效。
通过Properties设置工厂属性的缺点在用硬编码，假如需要修改例子中线程数量，将不得不修改代码，然后重新编译。后面几种方法可以解决硬编码的问题。
2) 通过外部属性文件提供
使用方法：
public void initialize(String filename) throws SchedulerException;3) 通过含有属性文件内容的java.io.InputStream提供
使用方法：
public void initialize(InputStream propertiesStream) throws SchedulerException;4) quartz.properties配置文件【推荐】
如果调用无参的initialize方法，StdSchedulerFactory会试图从quartz.properties的文件中加载。quartz.properties相关配置后续文章会介绍，注意quartz.properties的加载顺序为：
a. 检查System.getProperty("org.quartz.properties")中是否设置其他属性文件名
b. 如果a未设置，则将会从当前工作目录中加载quartz.properties配置文件
c. 如果b未找到，则试图从系统的classpath中加载该配置文件。
Scheduler在生命周期中也可执行其他操作，如查询、设置standby模式、继续执行、停止执行。standby模式会导致Scheduler暂时停止查找Job去执行。standby模式的设置直接使用scheudler.standby()即可。
Scheduler的停止方法为shutdown()方法，也可以使用有参shutdown(false)，其中参数表示是否让当前正在进行的job正常执行完成才停止Scheduler。
6. ThreadPool： Scheduler使用一个线程池作为任务运行的基础设施，任务通过共享线程池中的线程提高运行效率。
Job有一个StatefulJob子接口，代表有状态的任务，该接口是一个没有方法的标签接口，其目的是让Quartz知道任务的类型，以便采用不同的执行方案。无状态任务在执行时拥有自己的JobDataMap拷贝，对JobDataMap的更改不会影响下次的执行。而有状态任务共享共享同一个JobDataMap实例，每次任务执行对JobDataMap所做的更改会保存下来，后面的执行可以看到这个更改，也即每次执行任务后都会对后面的执行发生影响。
正因为这个原因，无状态的Job可以并发执行，而有状态的StatefulJob不能并发执行，这意味着如果前次的StatefulJob还没有执行完毕，下一次的任务将阻塞等待，直到前次任务执行完毕。有状态任务比无状态任务需要考虑更多的因素，程序往往拥有更高的复杂度，因此除非必要，应该尽量使用无状态的Job。
如果Quartz使用了数据库持久化任务调度信息，无状态的JobDataMap仅会在Scheduler注册任务时保持一次，而有状态任务对应的JobDataMap在每次执行任务后都会进行保存。
Trigger自身也可以拥有一个JobDataMap，其关联的Job可以通过JobExecutionContext#getTrigger().getJobDataMap()获取Trigger中的JobDataMap。不管是有状态还是无状态的任务，在任务执行期间对Trigger的JobDataMap所做的更改都不会进行持久，也即不会对下次的执行产生影响。
Quartz拥有完善的事件和监听体系，大部分组件都拥有事件，如任务执行前事件、任务执行后事件、触发器触发前事件、触发后事件、调度器开始事件、关闭事件等等，可以注册相应的监听器处理感兴趣的事件。
下图描述了Scheduler的内部组件结构，SchedulerContext提供Scheduler全局可见的上下文信息，每一个任务都对应一个JobDataMap，虚线表达的JobDataMap表示对应有状态的任务：
废话不多说， 上代码：
1. 最简单的Job代码(就打印Hello Quartz ！)：
-
package com.wenniuwuren.quartz; import org.quartz.Job; import org.quartz.JobExecutionContext; import org.quartz.JobExecutionException; public class HelloQuartz implements Job { public void execute(JobExecutionContext arg0) throws JobExecutionException { System.out.println("Hello Quartz !"); } }
-
package com.wenniuwuren.quartz;
-
-
import org.quartz.CronScheduleBuilder;
-
import org.quartz.JobBuilder;
-
import org.quartz.JobDetail;
-
import org.quartz.Scheduler;
-
import org.quartz.SchedulerException;
-
import org.quartz.SchedulerFactory;
-
import org.quartz.SimpleScheduleBuilder;
-
import org.quartz.Trigger;
-
import org.quartz.TriggerBuilder;
-
import org.quartz.impl.StdSchedulerFactory;
-
-
public class SchedulerTest {
-
public static void main(String[] args) throws InterruptedException {
-
-
//通过schedulerFactory获取一个调度器
-
SchedulerFactory schedulerfactory = new StdSchedulerFactory();
-
Scheduler scheduler=null;
-
try{
-
// 通过schedulerFactory获取一个调度器
-
scheduler = schedulerfactory.getScheduler();
-
-
// 创建jobDetail实例，绑定Job实现类
-
// 指明job的名称，所在组的名称，以及绑定job类
-
JobDetail job = JobBuilder.newJob(HelloQuartz.class).withIdentity("JobName", "JobGroupName").build();
-
-
-
// 定义调度触发规则
-
-
// SimpleTrigger
-
// Trigger trigger=TriggerBuilder.newTrigger().withIdentity("SimpleTrigger", "SimpleTriggerGroup")
-
// .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(3).withRepeatCount(6))
-
// .startNow().build();
-
-
// corn表达式 每五秒执行一次
-
Trigger trigger=TriggerBuilder.newTrigger().withIdentity("CronTrigger1", "CronTriggerGroup")
-
.withSchedule(CronScheduleBuilder.cronSchedule("*/5 * * * * ?"))
-
.startNow().build();
-
-
// 把作业和触发器注册到任务调度中
-
scheduler.scheduleJob(job, trigger);
-
-
// 启动调度
-
scheduler.start();
-
-
Thread.sleep(10000);
-
-
// 停止调度
-
scheduler.shutdown();
-
-
}catch(SchedulerException e){
-
e.printStackTrace();
-
}
-
-
}
-
}
自己跑了一下代码 ：执行了两次
hello Quartz!16:50:30
hello Quartz!16:50:35
扫一扫
233
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
