利用Spring動態對Quartz定時任務管理

在開發時我們會常常遇到定時任務可以由客戶進行管理在什么時候去執行或者甚至不再執行該定時任務。而Spring中所提供的定時任務組件卻只能夠通過修改trigger的配置才能夠控制定時的時間以及是否啟用定時任務，為此我搜索了網上的一些解決方法，發現還是不能夠很好的解決這個問題。所以干脆仔仔細細的研究了一把Quartz和Spring中相關的源碼，我們發現當我們在Spring通過如下聲明定時任務時：

 

 

Java代碼   

1. <bean id="yourJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">  
2.     <property name="targetObject" ref="yourJobBean"/>  
3.     <property name="targetMethod" value="yourJobMethod"/>  
4.     <property name="concurrent" value="false"/>  
5. </bean>  
6. <bean id="yourCronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean" >  
7.      <property name="jobDetail" ref="yourobDetail"/>  
8.      <property name="cronExpression">  
9.          <value>0 0 2 * * ?</value>  
10.      </property>  
11.  </bean>  
12. <bean id="schedulerFactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
13.     <property name="triggers">  
14.         <list>  
15.             <ref local="yourCronTrigger"/>  
16.         </list>  
17.     </property>  
18. bean>  

 所生成的Quartz的JobDetail並不是你定義的Bean，因為JobDetail並不能夠直接存放一個實例，具體可以參考JobDetail的構造函數：

 

Java代碼   

1. JobDetail(String name, String group, Class jobClass)   
2.            Create a JobDetail with the given name, group and class, and the default settings of all the other properties.  

 Spring將其轉換為MethodInvokingJob或者StatefulMethodInvokingJob類型，其實這兩個類都是從QuartzJobBean類繼承而來，那么我們來看看QuartzJobBean類的代碼：

Java代碼   

1. public abstract class QuartzJobBean implements Job {  
2.   
3.     /** 
4.      * This implementation applies the passed-in job data map as bean property 
5.      * values, and delegates to <code>executeInternal</code> afterwards. 
6.      * @see #executeInternal 
7.      */  
8.     public final void execute(JobExecutionContext context) throws JobExecutionException {  
9.         try {  
10.             BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);  
11.             MutablePropertyValues pvs = new MutablePropertyValues();  
12.             pvs.addPropertyValues(context.getScheduler().getContext());  
13.             pvs.addPropertyValues(context.getMergedJobDataMap());  
14.             bw.setPropertyValues(pvs, true);  
15.         }  
16.         catch (SchedulerException ex) {  
17.             throw new JobExecutionException(ex);  
18.         }  
19.         executeInternal(context);  
20.     }  
21.   
22.     /** 
23.      * Execute the actual job. The job data map will already have been 
24.      * applied as bean property values by execute. The contract is 
25.      * exactly the same as for the standard Quartz execute method. 
26.      * @see #execute 
27.      */  
28.     protected abstract void executeInternal(JobExecutionContext context) throws JobExecutionException;  
29.   
30. }  

 看到這個你或許已經明白了Spring對Quartz的封裝原理了。是的，Spring通過這種方式最后就可以在Job真正執行的時候可以反調用到我們所注入的類和方法，具體的代碼在MethodInvokingJobDetailFactoryBean類中，如下：

Java代碼   

1. public void afterPropertiesSet() throws ClassNotFoundException, NoSuchMethodException {  
2.         prepare();  
3.   
4.         // Use specific name if given, else fall back to bean name.  
5.         String name = (this.name != null ? this.name : this.beanName);  
6.   
7.         // Consider the concurrent flag to choose between stateful and stateless job.  
8.         Class jobClass = (this.concurrent ? (Class) MethodInvokingJob.class : StatefulMethodInvokingJob.class);  
9.   
10.         // Build JobDetail instance.  
11.         this.jobDetail = new JobDetail(name, this.group, jobClass);  
12.         this.jobDetail.getJobDataMap().put("methodInvoker", this);  
13.         this.jobDetail.setVolatility(true);  
14.         this.jobDetail.setDurability(true);  
15.   
16.         // Register job listener names.  
17.         if (this.jobListenerNames != null) {  
18.             for (int i = 0; i < this.jobListenerNames.length; i++) {  
19.                 this.jobDetail.addJobListener(this.jobListenerNames[i]);  
20.             }  
21.         }  
22.   
23.         postProcessJobDetail(this.jobDetail);  
24.     }  

 其實主要是這句：

Java代碼   

1. this.jobDetail.getJobDataMap().put("methodInvoker", this);  

 

這樣在調用的時候那就可以調用到我們所注入的類和方法了。

那好我們理解了Spring的原理后就可以動手修改成我們自己的了，所以在設計的時候我們考慮到以下兩個方面：

1. 精簡Spring的配置，添加一個定時任務至少有10幾行配置代碼，太麻煩了，最好只聲明一個Bean就可以了；
2. 客戶不但能夠控制執行的時間，還可以能夠啟用/禁用某個定時任務。

在上面的思路下，我們決定保留Spring的這個配置：

Xml代碼   

1. <bean id="schedulerFactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
2. </bean>  

 

只不過不需要注入trigger這個屬性了，我們僅僅利用Spring來幫我們構造一個Scheduler。

 

為了簡化后續的處理，我們決定定義一個自己Job的接口，方便進行控制及精簡代碼。

Java代碼   

1. public interface MyJob {  
2.     /** 
3.      * 執行具體的任務處理 
4.      * @throws JobException 
5.      */  
6.     public void execute() throws JobException;  
7. }  

 

接下來我們還是需要一個類似QuartzJobBean類，因此參考Spring的更改如下：

Java代碼   

1. public class QuartzJobBean implements Job {  
2.     public void execute(JobExecutionContext context) throws JobExecutionException {  
3.         String targetBeanId = (String)context.getMergedJobDataMap().get("targetObjectId");  
4.         if(StringUtils.isNullString(targetBeanId))  
5.             return;  
6.         Object targetBean = SpringUtils.getBean(targetBeanId);  
7.         if(null == targetBean)  
8.             return;  
9.           
10.         // 判斷是否是實現了MyJob接口  
11.         if(!(targetBean instanceof MyJob))  
12.             return;  
13.           
14.         // 執行相應的任務  
15.         ((MyJob)targetBean).execute();  
16.     }  
17. }  

 這個類處理邏輯就是通過獲取我在創建JobDetail任務是設定的目標任務Bean的，即targetObjectId的值，然后通過SpringUtils獲取該Bean，最后轉換成MyJob接口執行。

 

如何創建JobDetail呢，因為我們前面已經說明不需要在Spring配置那么麻煩而且客戶還可以進行配置，因此我們將任務的定時信息存放在數據庫中，相應的Domain定義如下：

Java代碼   

1. public class SchedulingJob extends Entry {  
2.     public static final int JS_ENABLED  = 0;    // 任務啟用狀態  
3.     public static final int JS_DISABLED = 1;    // 任務禁用狀態  
4.     public static final int JS_DELETE   = 2;    // 任務已刪除狀態  
5.       
6.     private String jobId;                       // 任務的Id，一般為所定義Bean的ID  
7.     private String jobName;                     // 任務的描述  
8.     private String jobGroup;                    // 任務所屬組的名稱  
9.     private int jobStatus;                      // 任務的狀態，0：啟用；1：禁用；2：已刪除  
10.     private String cronExpression;              // 定時任務運行時間表達式     
11.     private String memos;                       // 任務描述  
12.       
13.     // 省略getter和setter... ...  
14.     public String getTriggerName(){  
15.         return this.getJobId() + "Trigger";  
16.     }  
17. }  

 這時候我們就可以對定時任務進行控制了，具體控制代碼如下：

Java代碼   

1. /** 
2.      * 啟用指定的定時任務 
3.      * @param context 
4.      * @param <a href="mailto:schedulingJob@throws">schedulingJob</a> 
5.      */  
6.     protected void enabled(Context context, SchedulingJob schedulingJob) {  
7.         try {  
8.             CronTrigger trigger = (CronTrigger)this.scheduler.getTrigger(schedulingJob.getTriggerName(), schedulingJob.getJobGroup());  
9.             if (null == trigger) {  
10.                 // Trigger不存在，那么創建一個  
11.                 JobDetail jobDetail = new JobDetail(schedulingJob.getJobId(), schedulingJob.getJobGroup(), QuartzJobBean.class);  
12.                 jobDetail.getJobDataMap().put("targetObjectId", schedulingJob.getJobId());  
13.                   
14.                 trigger = new CronTrigger(schedulingJob.getTriggerName(), schedulingJob.getJobGroup(), schedulingJob.getCronExpression());  
15.                 this.scheduler.scheduleJob(jobDetail, trigger);  
16.             }else{  
17.                 // Trigger已存在，那么更新相應的定時設置  
18.                 trigger.setCronExpression(schedulingJob.getCronExpression());  
19.                 this.scheduler.rescheduleJob(trigger.getName(), trigger.getGroup(), trigger);  
20.             }  
21.         } catch (SchedulerException e) {  
22.             e.printStackTrace();  
23.             // TODO   
24.         } catch (ParseException e) {  
25.             e.printStackTrace();  
26.             // TODO   
27.         }  
28.     }  
29.   
30.     /** 
31.      * 禁用指定的定時任務 
32.      * @param context 
33.      * @param <a href="mailto:schedulingJob@throws">schedulingJob</a> 
34.      */  
35.     protected void disabled(Context context, SchedulingJob schedulingJob) {  
36.         try {  
37.             Trigger trigger = this.scheduler.getTrigger(schedulingJob.getTriggerName(), schedulingJob.getJobGroup());  
38.             if (null != trigger) {  
39.                 this.scheduler.deleteJob(schedulingJob.getJobId(), schedulingJob.getJobGroup());  
40.             }  
41.         } catch (SchedulerException e) {  
42.             e.printStackTrace();  
43.             // TODO   
44.         }  
45.     }  

再加上前台處理頁面（這個俺就不寫了，估計大家都會） 這樣我們就可以在控制定時任務的定時時間及啟用和禁用了。

最后我們的配置代碼如下：

 

 

Xml代碼   

1. <bean id="taskScheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"/>  
2.       
3. <bean id="tempDirClearTask" class="com.my.module.attachment.util.TempDirClearTask"/>  

 

 

P.S.

     這個定時任務組件是有局限性的，比如所設置的SchedulingJob.jobID必須是和Spring中定時任務Bean的id一致，否則這個定時任務不會被運行。還有這個現在僅支持CronTrigger。而且也不支持分組，不過你可以通過擴展。

      再一個要記得寫一個加載類在系統初始化時從數據庫的配置中加載所有啟用的定時任務哦，不然所有定時任務都不能夠運行