Spring框架中的Quartz使用（详解）

Spring框架中的Quartz使用:
首先简单介绍下Quartz,它是一个完全由Java编写的开源作业调度框架，为在Java应用程序中进行作业调度提供了简单却强大的机制,相当于java.util.Timer，但是比Timer多了很多的功能:
1.持久性作业，就是保持调度定时的状态;
2.作业管理，对调度作业进行有效的管理；
3.类Corn的定时支持，可以用Corn的方式来执行作业；
4.线程处理模型 Timer是单线程作业的，但是Quartz支持线程缓冲池。


在Spring中可以很方便的使用Quartz来实现定时任务等功能，我先介绍一下不使用Spring的Quartz实现，主要就是讲解Schedule（任务调度器），Job（作业任务）和Trigger（触发器）三者的关系。具体的体系结构从网上copy过来，讲的比较详细：
●Job：是一个接口，只有一个方法void execute(JobExecutionContext context)，开发者实现该接口定义运行任务，JobExecutionContext类提供了调度上下文的各种信息。


●JobDetail：Quartz在每次执行Job时，都重新创建一个Job实例，所以它不直接接受一个Job的实例，相反它接收一个Job实现类，以便运行时通过newInstance()的反射机制实例化Job。因此需要通过一个类来描述Job的实现类及其它相关的静态信息，如Job名字、描述、关联监听器等信息，JobDetail承担了这一角色。


●Trigger：是一个类，描述触发Job执行的时间触发规则。主要有SimpleTrigger和CronTrigger这两个子类。当仅需触发一次或者以固定时间间隔周期执行，SimpleTrigger是最适合的选择；而CronTrigger则可以通过Cron表达式定义出各种复杂时间规则的调度方案：如每早晨9:00执行，周一、周三、周五下午5:00执行等。


●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实例。

下面简单的helloword代码感受一下Quartz的工作流程：

[java]  view plain  copy

1. package quartz;  
2.   
3. import java.util.Date;  
4.   
5. import org.quartz.Job;  
6. import org.quartz.JobExecutionContext;  
7. import org.quartz.JobExecutionException;  
8.   
9. public class HelloWord implements Job{  
10.   
11.     //实现自己的定时方法  
12.     public void execute(JobExecutionContext arg0) throws JobExecutionException {  
13.         System.out.println("hello world " + new Date());  
14.     }  
15.       
16. }  

[java]  view plain  copy

1. package quartz;  
2.   
3. import java.util.Date;  
4.   
5. import org.quartz.JobBuilder;  
6. import org.quartz.JobDetail;  
7. import org.quartz.Scheduler;  
8. import org.quartz.SchedulerException;  
9. import org.quartz.Trigger;  
10. import org.quartz.TriggerBuilder;  
11. import org.quartz.impl.StdSchedulerFactory;  
12.   
13.   
14. public class SimpleExample {  
15.       
16.     public static void main(String[] args) throws SchedulerException{  
17.           
18.         SimpleExample example=new SimpleExample();  
19.         example.run();  
20.     }  
21.   
22.     public  void run() throws SchedulerException {  
23.           
24.         //获取scheduler实例  
25.         Scheduler scheduler=StdSchedulerFactory.getDefaultScheduler();  
26.         scheduler.start();  
27.           
28.         //当前时间  
29.         Date runTime=new Date();  
30.           
31.         //定义一个 job 对象并绑定我们写的  HelloWord 类     
32.         // 真正执行的任务并不是Job接口的实例，而是用反射的方式实例化的一个JobDetail实例   
33.         JobDetail job=JobBuilder.newJob(HelloWord.class).withIdentity("job1","group1").build();  
34.           
35.         // 定义一个触发器，startAt方法定义了任务应当开始的时间 .即下一个整数分钟执行  
36.         Trigger trigger=TriggerBuilder.newTrigger().withIdentity("trigger1","group1").startAt(runTime).build();  
37.           
38.         // 将job和Trigger放入scheduler  
39.         scheduler.scheduleJob(job, trigger);  
40.           
41.         //启动  
42.         scheduler.start();  
43.           
44.         try {  
45.             Thread.sleep(100);  
46.         } catch (InterruptedException e) {  
47.             e.printStackTrace();  
48.             scheduler.shutdown();  
49.         }  
50.           
51.     }  
52. }  

在实际web应用中，我们可用通过使用spring框架来使用Quartz实现定时任务，而且很方便，一共有三种方式：
(在Srping3.0版本后,使用Quartz需要加入依赖:

[html]  view plain  copy

1. <dependency>  
2. <span style="white-space:pre">    </span><groupId>org.springframework</groupId>  
3.     <artifactId>spring-context-support</artifactId>  
4.     <version>3.2.8.RELEASE</version>  
5. </dependency>  

否则会报错)
1.第一种方式，需要继承JobBean，并重写executeInternal(JobExecutionContext context)，然后配置spring-quratz.xml文件，里配置三部分：1.任务调用类；2.任务调用方式；3.任务调用工厂：

[java]  view plain  copy

1. <pre name="code" class="java">package spring.demo.pojo;  
2.   
3. import org.quartz.JobExecutionContext;  
4. import org.quartz.JobExecutionException;  
5. import org.springframework.scheduling.quartz.QuartzJobBean;  
6.   
7.   
8. //继承QuartzJobBean,并重写executeInternal方法  
9. public class QuartzTask extends QuartzJobBean{  
10.       
11.     private int timeout;  
12.     private static int i = 0;  
13.       
14.     //调度工厂实例化后，经过timeout时间开始执行调度  
15.     public void setTimeout(int timeout) {  
16.         this.timeout = timeout;  
17.     }  
18.       
19.     @Override  
20.     protected void executeInternal(JobExecutionContext context)  
21.             throws JobExecutionException {  
22.         System.out.println("task running..."+ ++i + "进行中...");  
23.     }  
24.       
25. }  

[html]  view plain  copy

1. <!-- 配置任务类 -->  
2.     <bean id="quartzTask" class="org.springframework.scheduling.quartz.JobDetailBean">  
3.         <property name="name" value="exampleJob"></property>  
4.         <property name="quartzClass" value="spring.demo.pojo.QuartzTask"></property>  
5.         <property name="jobDataAsMap">  
6.             <map>  
7.                 <entry key="timeout" value="0" />  
8.             </map>  
9.         </property>  
10.     </bean>  

[html]  view plain  copy

1. <!-- 调度触发器方式 -->  
2. <bean id="cronTriggerBean"  
3.     class="org.springframework.scheduling.quartz.CronTriggerBean">  
4.     <property name="jobDetail">  
5.         <ref bean="quartzTask" />  
6.     </property>  
7.     <!-- cron表达式 -->  
8.     <property name="cronExpression">  
9.         <value>10,15,20,25,30,35,40,45,50,55 * * * * ?</value>  
10.     </property>  
11. </bean>  

[html]  view plain  copy

1. <!-- 调度工厂 -->  
2.     <bean id="SpringJobSchedulerFactoryBean"  
3.         class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
4.         <property name="triggers">  
5.             <list>  
6.                 <ref bean="cronTriggerBean" />  
7.             </list>  
8.         </property>  
9.     </bean>  

2.第二种方式，不需要继承基类，这样仍然是pojo，而是在spring-quratz.xml配置文件中，配置包装类，其他两个配置与上述一样：

[java]  view plain  copy

1. package spring.demo.pojo;  
2.   
3. public class QuartzJob {  
4.       
5.     public void work(){  
6.         System.out.println("work running...");  
7.     }  
8. }  

[java]  view plain  copy

1. <pre name="code" class="html"><!-- 包装工作类 -->  
2.     <bean id="quartzJob" class="spring.demo.pojo.QuartzJob"></bean>  
3.     <bean id="jobTask"  
4.         class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">  
5.         <!-- 需要包装的类,即调度类 -->  
6.         <property name="targetObject">  
7.             <ref bean="quartzJob" />  
8.         </property>  
9.         <!-- 调用类中的方法 -->  
10.         <property name="targetMethod">  
11.             <!-- 具体的方法 -->  
12.             <value>work</value>  
13.         </property>  
14.     </bean>  

[html]  view plain  copy

1. <!-- 调度触发器方式 -->  
2.     <bean id="cronTriggerBean"  
3.         class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">  
4.         <property name="jobDetail">  
5.             <ref bean="jobTask"/>   
6.         </property>  
7.         <!-- cron表达式 -->  
8.         <property name="cronExpression">  
9.             <value>10,15,20,25,30,35,40,45,50,55 * * * * ?</value>  
10.         </property>  
11.     </bean>  

[html]  view plain  copy

1. <!-- 调度工厂 -->  
2.     <bean id="SpringJobSchedulerFactoryBean"  
3.         class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
4.         <property name="triggers">  
5.             <list>  
6.                 <ref bean="cronTriggerBean" />  
7.             </list>  
8.         </property>  
9.     </bean>  

3.第三种方式，通过@Scheduled注解的方式实现，需要修改applicationContext.xml三个部分内容：

1.xmlns添加：

[java]  view plain  copy

1. xmlns:task="http://www.springframework.org/schema/task"  

2.xsi:schemaLocation添加：

[java]  view plain  copy

1. http://www.springframework.org/schema/task  http://www.springframework.org/schema/task/spring-task-3.1.xsd   

3.applicationContext.xml中添加:

[java]  view plain  copy

1. <task:annotation-driven/>  

最后在我们的定时任务上添加上@Scheduled注解即可，一般都采用cronTrigger方式，即@Scheduled（cron=“相应的定时表达式”）

[java]  view plain  copy

1. package spring.demo.service;  
2.   
3. import org.springframework.context.support.ClassPathXmlApplicationContext;  
4. import org.springframework.scheduling.annotation.Scheduled;  
5. import org.springframework.stereotype.Service;  
6.   
7. @Service  
8. public class QuartzService {  
9.   
10.     @Scheduled(cron = "0/2 * * * * *")  
11.     public void process() {  
12.         System.out.println("job run...");  
13.     }  
14.   
15.     public static void main(String[] args) throws InterruptedException {  
16.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");  
17.         while (true) {  
18.             System.out.println("main running...");  
19.             Thread.sleep(10000);  
20.         }  
21.     }  
22. }  

个人建议采用第二种和第三种的方式实现Quartz比较简洁方便,下面顺便在网上查阅关于cron表达式的资料,不过我记得好像有一些工具可以方便生成这些表达式(Visual Cron Editor)目前没有具体的研究过,当然有些表达式也可以百度查阅到：

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