基于Spring实现定时调度

比较常用的是，Spring对Quartz的支持，可以非常容易地进行定时任务的调度。一般，具有两种方式实现定时调度：

一种是通过继承Spring的org.springframework.scheduling.quartz.QuartzJobBean来定义定时任务，这种情况下与Spring代码有一定耦合。下面，通过例子来说明：

实现一个定时任务类，代码如下所示：

1. package org.shirdrn.spring.scheduler.quartz;  
2.   
3. import org.apache.log4j.Logger;  
4. import org.quartz.JobExecutionContext;  
5. import org.quartz.JobExecutionException;  
6. import org.springframework.scheduling.quartz.QuartzJobBean;  
7.   
8. public class MyQuartzJob extends QuartzJobBean {  
9.   
10.     private static final Logger LOG = Logger.getLogger(MyQuartzJob.class);  
11.     private static int counter = 0;  
12.   
13.     @Override  
14.     protected void executeInternal(JobExecutionContext context)  
15.             throws JobExecutionException {  
16.         JobControlInfo job = (JobControlInfo) context.getMergedJobDataMap().get("jobControlInfo");  
17.         String manager = (String) context.getMergedJobDataMap().get("manager");  
18.         int length = Integer.parseInt((String) context.getMergedJobDataMap().get("length"));  
19.         LOG.info("context: job=" + job + ", manager=" + manager + ", length=" + length);  
20.         LOG.info("Execute quartz job /"" + (++counter) + "/".");  
21.     }  
22. }  

上面的JobExecutionContext context是一个任务执行上下文，可以通过配置，将需要的数据传递给executeInternal方法，然后在该方法中定义任务的处理逻辑。

这里，假设有一个类包含了对定时任务的控制信息，实现类为JobControlInfo，形式化定义如下所示：

1. package org.shirdrn.spring.scheduler.quartz;  
2.   
3. public class JobControlInfo {  
4.   
5. }  

通过Spring配置传递给JobExecutionContext context。

Spring配置文件quartz.xml的内容，如下所示：

1. xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"  
4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">  
5.       
6.     <bean id="myScheduler" lazy-init="false" autowire="no"  
7.         class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
8.         <property name="triggers">  
9.             <list>  
10.                 <ref bean="myQuartzJobTrigger" />  
11.             list>  
12.         property>  
13.     bean>  
14.     <bean id="myQuartzJobTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">  
15.         <property name="jobDetail" ref="myQuartzJobDetail" />  
16.         <property name="startDelay" value="5000"/>  
17.         <property name="repeatInterval" value="2000" />  
18.     bean>  
19.     <bean id="myQuartzJobDetail" class="org.springframework.scheduling.quartz.JobDetailBean">  
20.         <property name="jobClass">  
21.             <value>org.shirdrn.spring.scheduler.quartz.MyQuartzJobvalue>  
22.         property>  
23.         <property name="jobDataAsMap">  
24.             <map>  
25.                 <entry key="jobControlInfo" value-ref="jobControlInfo" />  
26.                 <entry key="length" value="100000" />  
27.                 <entry key="manager" value="Jack" />  
28.             map>  
29.         property>  
30.     bean>  
31.     <bean id="jobControlInfo" class="org.shirdrn.spring.scheduler.quartz.JobControlInfo" scope="prototype"/>  
32.   
33. beans>  

下面可以启动定时任务了，代码如下所示：

1. package org.shirdrn.spring.scheduler.quartz;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.IOException;  
5. import java.io.InputStreamReader;  
6.   
7. import org.quartz.impl.StdScheduler;  
8. import org.springframework.context.ApplicationContext;  
9. import org.springframework.context.support.ClassPathXmlApplicationContext;  
10.   
11. public class ContextInitializer {  
12.     public static void main(String[] args) {  
13.         ApplicationContext ctx = new ClassPathXmlApplicationContext(  
14.                 "org/shirdrn/spring/scheduler/quartz/quartz.xml");  
15.         StdScheduler myScheduler = (StdScheduler)ctx.getBean("myScheduler");  
16.         BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));  
17.         try {  
18.             while(true) {  
19.                 String line = reader.readLine();  
20.                 if(line!=null) {  
21.                     boolean quit = line.trim().equalsIgnoreCase("quit") || line.trim().equalsIgnoreCase("q");  
22.                     if(quit) {  
23.                         myScheduler.shutdown(true);  
24.                         break;  
25.                     }  
26.                 }  
27.             }  
28.         } catch (IOException e) {  
29.             e.printStackTrace();  
30.         }  
31.     }  
32. }  

我们定义这个定时任务，执行时间间隔为2s。 

另一种是完全与Spring代码解耦合，而只是通过Spring配置就能进行定时任务的配置，一个定时任务可以是任意的Java处理类。而对于定时的配置，是基于Unix系统的crontab命令来实现的，更加灵活地配置定时任务。

下面说明实现方法：

定义一个普通的Java类，里面的一个方法里面包含了定时任务的处理逻辑，如下所示：

1. package org.shirdrn.spring.scheduler.quartz.cron;  
2.   
3. import org.apache.log4j.Logger;  
4.   
5.   
6. public class MyQuartzJob {  
7.   
8.     private static final Logger LOG = Logger.getLogger(MyQuartzJob.class);  
9.     private static int counter = 0;  
10.       
11.     public void scan() {  
12.         LOG.info("Execute quartz job /"" + (++counter) + "/".");  
13.     }  
14. }