Quartz的简单使用，基于1.X入门及CronTrigger

Posted 2020-07-17 恒奇恒毅

 什么是Quartz

 

 

Quartz是一个完全由Java编写的开源作业调度框架，为在Java应用程序中进行作业调度提供了简单却强大的机制。Quartz允许开发人员根据时间间隔来调度作业。它实现了作业和触发器的多对多的关系，还能把多个作业与不同的触发器关联。简单地创建一个org.quarz.Job接口的Java类，Job接口包含唯一的方法：

 

    public void execute(JobExecutionContext context) throws JobExecutionException;

 

在Job接口实现类里面，添加需要的逻辑到execute()方法中。配置好Job实现类并设定好调度时间表，Quartz就会自动在设定的时间调度作业执行execute()。

 

整合了Quartz的应用程序可以重用不同事件的作业，还可以为一个事件组合多个作业。Quartz通过属性文件来配置JDBC事务的数据源、全局作业、触发器侦听器、插件、线程池等等。

 

Quartz是由James House创建并最初于2001年春天被加入sourceforge工程。接下来的几年里，有很多的新特性和版本出现，但是直到项目迁移到新的站点并成为OpenSymphony项目家族的一员，才开始真正启动并受到也有的关注。

 

目前的版本已经是2.0以上，v2.x相对于v1.x有很多新特性出现，并有很多的改动，具体参见Quartz官网上说明。

Job接口包含唯一方法execute()，将任务逻辑添加到该方法中。StdSchedulerFactory.getScheduler()返回一个可运行的实例，然后创建调度任务的JobDetail实例，并传递3个参数给构造方法。第一个参数是任务名，用于引用该任务。第二个参数是任务组名，这里使用默认名，任务组名用于引用集合起来的一组任务，如可以使用Scheduler.pauseJobGroup()来暂停一组任务，每个组中的任务名是唯一的。第三个参数是实现特定任务的类。创建JobDetail实例后，需要创建一个Trigger，这里使用的是SimpleTrigger类，它提供了JDK Timer风格的触发器行为。传递给SimpleTrigger构造方法的两个参数分别是触发器名和任务组名，触发器名在它所在的任务组中必须是唯一的。接下来是设置触发器的一些属性，setStartTime()是设置启动时间，setRepeatInterval()是设置重复间隔，setRepeatCount()是设置重复次数。最后，scheduler.start()启动调度，终止调度可以用stop()方法。

 

 

 

 

1 、JobDetail ： JobDetail 是一个具体的类。

   2、Trigger ：触发器，它用于定义 Job 何时执行。最常用的是 SimpleTrigger 和 CronTrigger 。一般来说，如果你需要在一个固定的时间和重复次数或者一个固定的间隔时间，那么 SimpleTrigger 比较合适；如果你有许多复杂的作业调度，那么 CronTrigger 比较合适。 CronTrigger 和 Unix 的 cron 机制基本一样，我们需要的只是一个 cron 表达式。比如“ 0 0 12 * * ? ”会在每天中午 12 点触发 执行；“0 15 10 ? * 6L ”会在每个月的最后一个星期五的早上 10:15 触发 Job 执行。

   3、 Scheduler 和 SchedulerFactory ： Scheduler 负责管理 Trigger 、调度 Job ， SchedulerFactory 则是 Scheduler 工厂，负责生成Scheduler 。

 "Hello, Quartz"

1. import java.text.SimpleDateFormat;  
2. import java.util.Date;  
3.   
4. public class QuartzTest {  
5.   
6.     /** *//** 
7.      * @param args 
8.      */  
9.     public static void main(String[] args) {  
10.         // TODO Auto-generated method stub  
11.         SimpleDateFormat DateFormat = new SimpleDateFormat("yyyyMMddHHmmss");  
12.         Date d = new Date();  
13.         String returnstr = DateFormat.format(d);          
14.           
15.         TestJob job = new TestJob();  
16.         String job_name ="11";  
17.         try {  
18.             System.out.println(returnstr+ "【系统启动】");  
19.             QuartzManager.addJob(job_name,job,"0/2 * * * * ?"); //每2秒钟执行一次  
20.               
21. //            Thread.sleep(10000);  
22. //            System.out.println("【修改时间】");  
23. //            QuartzManager.modifyJobTime(job_name,"0/10 * * * * ?");  
24. //            Thread.sleep(20000);  
25. //            System.out.println("【移除定时】");  
26. //            QuartzManager.removeJob(job_name);  
27. //            Thread.sleep(10000);  
28. //              
29. //            System.out.println("/n【添加定时任务】");  
30. //            QuartzManager.addJob(job_name,job,"0/5 * * * * ?");  
31.               
32.         }  catch (Exception e) {  
33.             e.printStackTrace();  
34.         }  
35.     }  
36. }  

 

简单的任务管理类

 

 

[java] view plain copy

1. //简单的任务管理类  
2. //QuartzManager.java  
3.   
4. package quartzPackage;  
5.   
6. import java.text.ParseException;  
7. import org.quartz.CronTrigger;  
8. import org.quartz.Job;  
9. import org.quartz.JobDetail;  
10. import org.quartz.Scheduler;  
11. import org.quartz.SchedulerException;  
12. import org.quartz.SchedulerFactory;  
13. import org.quartz.Trigger;  
14. import org.quartz.impl.StdSchedulerFactory;  
15.   
16. /** *//** 
17.  * @Title:Quartz管理类 
18.  *  
19.  * @Description: 
20.  *  
21.  * @Copyright:  
22.  * @author zz  2008-10-8 14:19:01 
23.  * @version 1.00.000 
24.  * 
25.  */  
26. public class QuartzManager {  
27.    private static SchedulerFactory sf = new StdSchedulerFactory();  
28.    private static String JOB_GROUP_NAME = "group1";  
29.    private static String TRIGGER_GROUP_NAME = "trigger1";  
30.     
31.      
32.    /** *//** 
33.     *  添加一个定时任务，使用默认的任务组名，触发器名，触发器组名 
34.     * @param jobName 任务名 
35.     * @param job     任务 
36.     * @param time    时间设置，参考quartz说明文档 
37.     * @throws SchedulerException 
38.     * @throws ParseException 
39.     */  
40.    public static void addJob(String jobName,Job job,String time)   
41.                                throws SchedulerException, ParseException{  
42.        Scheduler sched = sf.getScheduler();  
43.        JobDetail jobDetail = new JobDetail(jobName, JOB_GROUP_NAME, job.getClass());//任务名，任务组，任务执行类  
44.        //触发器  
45.        CronTrigger  trigger =   
46.             new CronTrigger(jobName, TRIGGER_GROUP_NAME);//触发器名,触发器组  
47.        trigger.setCronExpression(time);//触发器时间设定  
48.        sched.scheduleJob(jobDetail,trigger);  
49.        //启动  
50.        if(!sched.isShutdown())  
51.           sched.start();  
52.    }  
53.      
54.    /** *//** 
55.     * 添加一个定时任务 
56.     * @param jobName 任务名 
57.     * @param jobGroupName 任务组名 
58.     * @param triggerName  触发器名 
59.     * @param triggerGroupName 触发器组名 
60.     * @param job     任务 
61.     * @param time    时间设置，参考quartz说明文档 
62.     * @throws SchedulerException 
63.     * @throws ParseException 
64.     */  
65.    public static void addJob(String jobName,String jobGroupName,  
66.                              String triggerName,String triggerGroupName,  
67.                              Job job,String time)   
68.                                throws SchedulerException, ParseException{  
69.        Scheduler sched = sf.getScheduler();  
70.        JobDetail jobDetail = new JobDetail(jobName, jobGroupName, job.getClass());//任务名，任务组，任务执行类  
71.        //触发器  
72.        CronTrigger  trigger =   
73.             new CronTrigger(triggerName, triggerGroupName);//触发器名,触发器组  
74.        trigger.setCronExpression(time);//触发器时间设定  
75.        sched.scheduleJob(jobDetail,trigger);  
76.        if(!sched.isShutdown())  
77.           sched.start();  
78.    }  
79.      
80.    /** *//** 
81.     * 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名) 
82.     * @param jobName 
83.     * @param time 
84.     * @throws SchedulerException 
85.     * @throws ParseException 
86.     */  
87.    public static void modifyJobTime(String jobName,String time)   
88.                                   throws SchedulerException, ParseException{  
89.        Scheduler sched = sf.getScheduler();  
90.        Trigger trigger =  sched.getTrigger(jobName,TRIGGER_GROUP_NAME);  
91.        if(trigger != null){  
92.            CronTrigger  ct = (CronTrigger)trigger;  
93.            ct.setCronExpression(time);  
94.            sched.resumeTrigger(jobName,TRIGGER_GROUP_NAME);  
95.        }  
96.    }  
97.      
98.    /** *//** 
99.     * 修改一个任务的触发时间 
100.     * @param triggerName 
101.     * @param triggerGroupName 
102.     * @param time 
103.     * @throws SchedulerException 
104.     * @throws ParseException 
105.     */  
106.    public static void modifyJobTime(String triggerName,String triggerGroupName,  
107.                                     String time)   
108.                                   throws SchedulerException, ParseException{  
109.        Scheduler sched = sf.getScheduler();  
110.        Trigger trigger =  sched.getTrigger(triggerName,triggerGroupName);  
111.        if(trigger != null){  
112.            CronTrigger  ct = (CronTrigger)trigger;  
113.            //修改时间  
114.            ct.setCronExpression(time);  
115.            //重启触发器  
116.            sched.resumeTrigger(triggerName,triggerGroupName);  
117.        }  
118.    }  
119.      
120.    /** *//** 
121.     * 移除一个任务(使用默认的任务组名，触发器名，触发器组名) 
122.     * @param jobName 
123.     * @throws SchedulerException 
124.     */  
125.    public static void removeJob(String jobName)   
126.                                throws SchedulerException{  
127.        Scheduler sched = sf.getScheduler();  
128.        sched.pauseTrigger(jobName,TRIGGER_GROUP_NAME);//停止触发器  
129.        sched.unscheduleJob(jobName,TRIGGER_GROUP_NAME);//移除触发器  
130.        sched.deleteJob(jobName,JOB_GROUP_NAME);//删除任务  
131.    }  
132.      
133.    /** *//** 
134.     * 移除一个任务 
135.     * @param jobName 
136.     * @param jobGroupName 
137.     * @param triggerName 
138.     * @param triggerGroupName 
139.     * @throws SchedulerException 
140.     */  
141.    public static void removeJob(String jobName,String jobGroupName,  
142.                                 String triggerName,String triggerGroupName)   
143.                                throws SchedulerException{  
144.        Scheduler sched = sf.getScheduler();  
145.        sched.pauseTrigger(triggerName,triggerGroupName);//停止触发器  
146.        sched.unscheduleJob(triggerName,triggerGroupName);//移除触发器  
147.        sched.deleteJob(jobName,jobGroupName);//删除任务  
148.    }  
149. }  

 

 

测试工作类

 

[java] view plain copy

1. //测试工作类  
2. //TestJob.java  
3.   
4. package quartzPackage;  
5.   
6. import java.text.SimpleDateFormat;  
7. import java.util.Date;  
8.   
9. import org.quartz.Job;  
10. import org.quartz.JobExecutionContext;  
11. import org.quartz.JobExecutionException;  
12.   
13. public class TestJob implements Job {  
14.     SimpleDateFormat DateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
15.     Date d = new Date();  
16.     String returnstr = DateFormat.format(d);    
17.   
18.     public void execute(JobExecutionContext arg0) throws JobExecutionException {  
19.         // TODO Auto-generated method stub  
20.         System.out.println(returnstr+"★★★★★★★★★★★");  
21.     }  
22.   
23. }  

 

 

CronTrigger类

---

 

Quartz有两大触发器，除了上面使用的SimpleTrigger外，就是CronTrigger。CronTrigger能够提供复杂的触发器表达式的支持。CronTrigger是基于Unix Cron守护进程，它是一个调度程序，支持简单而强大的触发器语法。

 

使用CronTrigger主要的是要掌握Cron表达式。Cron表达式包含6个必要组件和一个可选组件，如下表所示。

 

位置	含义	允许的特殊字符
1	秒（0~59）	, -  *  /
2	分（0~59）	, -  *  /
3	小时（0~24）	, -  *  /
4	日期（1~31）	, -  *  /  ?  L  W  C
5	月（JAN~DEC或1~12）	, -  *  /
6	星期（SUN~SAT或1~7）	, -  *  /  ?  L  C  #
7	年（可选，1970~2099），若为空，表示全部时间范围	, -  *  /

 

特殊字符的含义，见下表。

 

特殊字符	说明
*	通配符，任意值。'*' 字符可以用于所有字段，在“分”字段中设为"*"表示"每一分钟"的含义。
?	无特定值。通常和其他指定的值一起使用，表示必须显示该值但不能检查。'?' 字符可以用在“日”和“周几”字段. 它用来指定 '不明确的值'. 这在你需要指定这两个字段中的某一个值而不是另外一个的时候会被用到。在后面的例子中可以看到其含义。
-	范围。e.g.小时部分10-12表示10:00，11:00， 12:00。'-' 字符被用来指定一个值的范围，比如在“小时”字段中设为"10-12"表示"10点到12点".
,	列分隔符。可以让你指定一系列的值。e.g.在星期域中指定MON、TUE和WED。',' 字符指定数个值。比如在“周几”字段中设为"MON,WED,FRI"表示"the days Monday, Wednesday, and Friday".
/	增量。表示一个值的增量，e.g.分钟域中0/1表示从0开始，每次增加1min。'/' 字符用来指定一个值的的增加幅度. 比如在“秒”字段中设置为"0/15"表示"第0, 15, 30, 和 45秒"。而 "5/15"则表示"第5, 20, 35, 和 50". 在'/'前加"*"字符相当于指定从0秒开始. 每个字段都有一系列可以开始或结束的数值。对于“秒”和“分”字段来说，其数值范围为0到59，对于“小时”字段来说其为0到23, 对于“日”字段来说为0到31, 而对于“月”字段来说为1到12。"/"字段仅仅只是帮助你在允许的数值范围内从开始"第n"的值。 因此对于“月”字段来说"7/6"只是表示7月被开启而不是“每六个月”, 请注意其中微妙的差别。
L	表示Last。它在日期和星期域中表示有所不同。在日期域中，表示这个月的最后一天，而在星期域中，它永远是7（星期六）。当你希望使用星期中某一天时，L字符非常有用。e.g.星期域中6L表示每一个月的最后一个星期五。'L'字符可用在“日”和“周几”这两个字段。它是"last"的缩写, 但是在这两个字段中有不同的含义。例如,“日”字段中的"L"表示"一个月中的最后一天" —— 对于一月就是31号对于二月来说就是28号（非闰年）。而在“周几”字段中, 它简单的表示"7" or "SAT"，但是如果在“周几”字段中使用时跟在某个数字之后, 它表示"该月最后一个星期×" —— 比如"6L"表示"该月最后一个周五"。当使用'L'选项时,指定确定的列表或者范围非常重要，否则你会被结果搞糊涂的。
W	在本月内离当天最近的工作日触发，所谓的最近工作日，即当天到工作日的前后最短距离，如果当天即为工作日，则距离是0；所谓本月内指的是不能跨月取到最近工作日，即使前/后月份的最后一天/第一天确实满足最近工作日。e.g. LW表示本月的最后一个工作日触发，W强烈依赖月份。'W' 可用于“日”字段。用来指定历给定日期最近的工作日(周一到周五) 。比如你将“日”字段设为"15W"，意为: "离该月15号最近的工作日"。因此如果15号为周六，触发器会在14号即周五调用。如果15号为周日, 触发器会在16号也就是周一触发。如果15号为周二,那么当天就会触发。然而如果你将“日”字段设为"1W", 而一号又是周六, 触发器会于下周一也就是当月的3号触发,因为它不会越过当月的值的范围边界。'W'字符只能用于“日”字段的值为单独的一天而不是一系列值的时候。'L'和'W'可以组合用于“日”字段表示为'LW'，意为"该月最后一个工作日"。
#	表示该月的第几个星期，e.g. 1#2表示每一个月的第一个星期一。'#' 字符可用于“周几”字段。该字符表示“该月第几个周×”，比如"6#3"表示该月第三个周五( 6表示周五而"#3"该月第三个)。再比如: "2#1" = 表示该月第一个周一而 "4#5" = 该月第五个周三。注意如果你指定"#5"该月没有第五个“周×”，该月是不会触发的。
C	日历值。日期值是根据一个给定的日历计算出来的。在日期域中给定一个20C将在20日（日历包括20日）或20日后日历中包含的第一天（不包括20日）激活触发器。例如在一个星期域中使用6C表示日历中星期五（日历包括星期五）或者第一天（日历不包括星期五）。'C' 字符可用于“日”和“周几”字段，它是"calendar"的缩写。它表示为基于相关的日历所计算出的值（如果有的话）。如果没有关联的日历, 那它等同于包含全部日历。“日”字段值为"5C"表示"日历中的第一天或者5号以后"，“周几”字段值为"1C"则表示"日历中的第一天或者周日以后"。 对于“月份”字段和“周几”字段来说合法的字符都不是大小写敏感的。

 

 

Cron表达式举例：

 

"30 * * * * ?" 每半分钟触发任务

"30 10 * * * ?" 每小时的10分30秒触发任务

"30 10 1 * * ?" 每天1点10分30秒触发任务

"30 10 1 20 * ?" 每月20号1点10分30秒触发任务

"30 10 1 20 10 ? *" 每年10月20号1点10分30秒触发任务

"30 10 1 20 10 ? 2011" 2011年10月20号1点10分30秒触发任务

"30 10 1 ? 10 * 2011" 2011年10月每天1点10分30秒触发任务

"30 10 1 ? 10 SUN 2011" 2011年10月每周日1点10分30秒触发任务

"15,30,45 * * * * ?" 每15秒，30秒，45秒时触发任务

"15-45 * * * * ?" 15到45秒内，每秒都触发任务

"15/5 * * * * ?" 每分钟的每15秒开始触发，每隔5秒触发一次

"15-30/5 * * * * ?" 每分钟的15秒到30秒之间开始触发，每隔5秒触发一次

"0 0/3 * * * ?" 每小时的第0分0秒开始，每三分钟触发一次

"0 15 10 ? * MON-FRI" 星期一到星期五的10点15分0秒触发任务

"0 15 10 L * ?" 每个月最后一天的10点15分0秒触发任务

"0 15 10 LW * ?" 每个月最后一个工作日的10点15分0秒触发任务

"0 15 10 ? * 5L" 每个月最后一个星期四的10点15分0秒触发任务

"0 15 10 ? * 5#3" 每个月第三周的星期四的10点15分0秒触发任务

 

"0 0 12 * * ?"		每天中午十二点触发
"0 15 10 ? * *"		每天早上10：15触发
"0 15 10 * * ?"		每天早上10：15触发
"0 15 10 * * ? *"		每天早上10：15触发
"0 15 10 * * ? 2005"		2005年的每天早上10：15触发
"0 * 14 * * ?"		每天从下午2点开始到2点59分每分钟一次触发
"0 0/5 14 * * ?"		每天从下午2点开始到2：55分结束每5分钟一次触发
"0 0/5 14,18 * * ?"		每天的下午2点至2：55和6点至6点55分两个时间段内每5分钟一次触发
"0 0-5 14 * * ?"		每天14:00至14:05每分钟一次触发
"0 10,44 14 ? 3 WED"		三月的每周三的14：10和14：44触发
"0 15 10 ? * MON-FRI"		每个周一、周二、周三、周四、周五的10：15触发
"0 15 10 15 * ?"		每月15号的10：15触发
"0 15 10 L * ?"		每月的最后一天的10：15触发
"0 15 10 ? * 6L"		每月最后一个周五的10：15触发
"0 15 10 ? * 6L"		每月最后一个周五的10：15触发
"0 15 10 ? * 6L 2002-2005"		2002年至2005年的每月最后一个周五的10：15触发
"0 15 10 ? * 6#3"		每月的第三个周五的10：15触发

 

第三方包

通过测试。一个简单任务只需要以下几个包：commons-beanutils.jar、commons-collections.jar、commons-logging.jar、commons-digester.jar、quartz.jar即可

 

名称	必须/备注	网址
activation.jar	主要是 JavaMail 要用到	http://java.sun.com/products/javabeans/glasgow/jaf.html
commons-beanutils.jar	是	http://jakarta.apache.org/commons/beanutils
commons-collections.jar	是	http://jakarta.apache.org/commons/collections
commons-dbcp-1.1.jar	是，假如用到数据库作为作业存储	http://jakarta.apache.org/commons/dbcp
commons-digester.jar	是	假如你使用了某些插件，就需要它
commons-logging.jar	是	http://jakarta.apache.org/commons/logging/
commons-pool-1.1.jar		http://jakarta.apache.org/commons/pool/
javamail.jar	发送 e-mail 用	http://java.sun.com/products/javamail/
jdbc2_0-stdext.jar	是，假如用到数据库作为作业存储	http://java.sun.com/products/jdbc/
jta.jar	是，假如用到数据库作为作业存储	http://java.sun.com/products/jta/database
quartz.jar	是	Quart 框架核心包
servlet.jar	假如使用了Servlet 容器，但容器中应该存在	http://java.sun.com/products/servlet/
log4j.jar	是，日志	http://logging.apache.org/