利用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。而且也不支持分组，不过你可以通过扩展。

      再一个要记得写一个加载类在系统初始化时从数据库的配置中加载所有启用的定时任务哦，不然所有定时任务都不能够运行