Quartz的简单使用，基于1.X（一）【入门及CronTrigger】

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

简单的任务管理类

[java] view
plain copy

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

测试工作类

[java] view
plain copy

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

CronTrigger类

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

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

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

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秒触发任务

第三方包

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