Spring 3整合Quartz 2实现定时任务二：动态添加任务

转：http://www.meiriyouke.net/?p=131

前面，我们已经对Spring 3和Quartz 2用配置文件的方式进行了整合，如果需求比较简单的话应该已经可以满足了。但是很多时候，我们常常会遇到需要动态的添加或修改任务，而spring中所提供的定时任务组件却只能够通过修改xml中trigger的配置才能控制定时任务的时间以及任务的启用或停止，这在带给我们方便的同时也失去了动态配置任务的灵活性。我搜索了一些网上的解决方法，都没有很好的解决这个问题，而且大多数提到的解决方案都停留在Quartz 1.x系列版本上，所用到的代码和API已经不能适用于新版本的Spring和Quartz。没办法只能靠自己了，花了点时间好好研究了一下Spring和Quartz中相关的代码。

首先我们来回顾一下spring中使用quartz的配置代码：

1. <!-- 使用MethodInvokingJobDetailFactoryBean，任务类可以不实现Job接口，通过targetMethod指定调用方法-->
2. <beanid="taskJob"class="com.tyyd.dw.task.DataConversionTask"/>
3. <beanid="jobDetail"class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
4. <propertyname="group"value="job_work"/>
5. <propertyname="name"value="job_work_name"/>
6. <!--false表示等上一个任务执行完后再开启新的任务-->
7. <propertyname="concurrent"value="false"/>
8. <propertyname="targetObject">
9. <refbean="taskJob"/>
10. </property>
11. <propertyname="targetMethod">
12. <value>execute</value>
13. </property>
14. </bean>
15.  
16. <!-- 调度触发器 -->
17. <beanid="myTrigger"
18. class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
19. <propertyname="name"value="work_default_name"/>
20. <propertyname="group"value="work_default"/>
21. <propertyname="jobDetail">
22. <refbean="jobDetail"/>
23. </property>
24. <propertyname="cronExpression">
25. <value>0/5 * * * * ?</value>
26. </property>
27. </bean>
28.  
29. <!-- 调度工厂 -->
30. <beanid="scheduler"class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
31. <propertyname="triggers">
32. <list>
33. <refbean="myTrigger"/>
34. </list>
35. </property>
36. </bean>

所有的配置都在xml中完成，包括cronExpression表达式，十分的方便。但是如果我的任务信息是保存在数据库的，想要动态的初始化，而且任务较多的时候不是得有一大堆的xml配置？或者说我要修改一下trigger的表达式，使原来5秒运行一次的任务变成10秒运行一次，这时问题就来了，试过在配置文件中不传入cronExpression等参数，但是启动时就报错了，难道我每次都修改xml文件然后重启应用吗，这显然不合适的。最理想的是在与spring整合的同时又能实现动态任务的添加、删除及修改配置。

我们来看一下spring实现quartz的方式，先看一下上面配置文件中定义的jobDetail。其实上面生成的jobDetail并不是我们定义的Bean，因为在Quartz 2.x版本中JobDetail已经是一个接口（当然以前的版本也并非直接生成JobDetail）：

1. publicinterfaceJobDetailextendsSerializable,Cloneable{...｝

Spring是通过将其转换为MethodInvokingJob或StatefulMethodInvokingJob类型来实现的，这两个都是静态的内部类，MethodInvokingJob类继承于QuartzJobBean，而StatefulMethodInvokingJob则直接继承于MethodInvokingJob。 这两个类的实现区别在于有状态和无状态，对应于quartz的Job和StatefulJob，具体可以查看quartz文档，这里不再赘述。先来看一下它们实现的QuartzJobBean的主要代码：

1. /**
2. * This implementation applies the passed-in job data map as bean property
3. * values, and delegates to <code>executeInternal</code> afterwards.
4. * @see #executeInternal
5. */
6. publicfinalvoid execute(JobExecutionContext context)throwsJobExecutionException{
7. try{
8. // Reflectively adapting to differences between Quartz 1.x and Quartz 2.0...
9. Scheduler scheduler =(Scheduler)ReflectionUtils.invokeMethod(getSchedulerMethod, context);
10. Map mergedJobDataMap =(Map)ReflectionUtils.invokeMethod(getMergedJobDataMapMethod, context);
11.  
12. BeanWrapper bw =PropertyAccessorFactory.forBeanPropertyAccess(this);
13. MutablePropertyValues pvs =newMutablePropertyValues();
14. pvs.addPropertyValues(scheduler.getContext());
15. pvs.addPropertyValues(mergedJobDataMap);
16. bw.setPropertyValues(pvs,true);
17. }
18. catch(SchedulerException ex){
19. thrownewJobExecutionException(ex);
20. }
21. executeInternal(context);
22. }
23.  
24. /**
25. * Execute the actual job. The job data map will already have been
26. * applied as bean property values by execute. The contract is
27. * exactly the same as for the standard Quartz execute method.
28. * @see #execute
29. */
30. protectedabstractvoid executeInternal(JobExecutionContext context)throwsJobExecutionException;

还有MethodInvokingJobDetailFactoryBean中的代码：

1. publicvoid afterPropertiesSet()throwsClassNotFoundException,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 ?MethodInvokingJob.class:StatefulMethodInvokingJob.class);
9.  
10. // Build JobDetail instance.
11. if(jobDetailImplClass !=null){
12. // Using Quartz 2.0 JobDetailImpl class...
13. this.jobDetail =(JobDetail)BeanUtils.instantiate(jobDetailImplClass);
14. BeanWrapper bw =PropertyAccessorFactory.forBeanPropertyAccess(this.jobDetail);
15. bw.setPropertyValue("name", name);
16. bw.setPropertyValue("group",this.group);
17. bw.setPropertyValue("jobClass", jobClass);
18. bw.setPropertyValue("durability",true);
19. ((JobDataMap) bw.getPropertyValue("jobDataMap")).put("methodInvoker",this);
20. }
21. else{
22. // Using Quartz 1.x JobDetail class...
23. this.jobDetail =newJobDetail(name,this.group, jobClass);
24. this.jobDetail.setVolatility(true);
25. this.jobDetail.setDurability(true);
26. this.jobDetail.getJobDataMap().put("methodInvoker",this);
27. }
28.  
29. // Register job listener names.
30. if(this.jobListenerNames !=null){
31. for(String jobListenerName :this.jobListenerNames){
32. if(jobDetailImplClass !=null){
33. thrownewIllegalStateException("Non-global JobListeners not supported on Quartz 2 - "+
34. "manually register a Matcher against the Quartz ListenerManager instead");
35. }
36. this.jobDetail.addJobListener(jobListenerName);
37. }
38. }
39.  
40. postProcessJobDetail(this.jobDetail);
41. }

上面主要看我们目前用的Quartz 2.0版本的实现部分，到这里或许你已经明白Spring对Quartz的封装原理了。Spring就是通过这种方式在最后Job真正执行时反调用到我们所注入的类和方法。

现在，理解了Spring的实现原理后，我们就可以来设计我们自己的了。在设计时我想到以下几点：

1、减少spring的配置文件，为了实现一个定时任务，spring的配置代码太多了。

2、用户可以通过页面等方式添加、启用、禁用某个任务。

3、用户可以修改某个已经在运行任务的运行时间表达式，CronExpression。

4、为方便维护，简化任务的运行调用处理，任务的运行入口即Job实现类最好只有一个，该Job运行类相当于工厂类，在实际调用时把任务的相关信息通过参数方式传入，由该工厂类根据任务信息来具体执行需要的操作。

在上面的思路下来进行我们的开发吧。

一、spring配置文件

通过研究，发现要实现我们的功能，只需要以下配置：

1. <beanid="schedulerFactoryBean"class="org.springframework.scheduling.quartz.SchedulerFactoryBean"/>

二、任务运行入口，即Job实现类，在这里我把它看作工厂类：

1. /**
2. * 定时任务运行工厂类
3. *
4. * User: liyd
5. * Date: 14-1-3
6. * Time: 上午10:11
7. */
8. publicclassQuartzJobFactoryimplementsJob{
9.  
10. @Override
11. publicvoid execute(JobExecutionContext context)throwsJobExecutionException{
12. System.out.println("任务成功运行");
13. ScheduleJob scheduleJob =(ScheduleJob)context.getMergedJobDataMap().get("scheduleJob");
14. System.out.println("任务名称 = ["+ scheduleJob.getJobName()+"]");
15. }
16. }

这里我们实现的是无状态的Job，如果要实现有状态的Job在以前是实现StatefulJob接口，在我使用的quartz 2.2.1中，StatefulJob接口已经不推荐使用了，换成了注解的方式，只需要给你实现的Job类加上注解@DisallowConcurrentExecution即可实现有状态：

1. /**
2. * 定时任务运行工厂类
3. * <p/>
4. * User: liyd
5. * Date: 14-1-3
6. * Time: 上午10:11
7. */
8. @DisallowConcurrentExecution
9. publicclassQuartzJobFactoryimplementsJob{...}

三、创建任务

既然要动态的创建任务，我们的任务信息当然要保存在某个地方了，这里我们新建一个保存任务信息对应的实体类：

1. /**
2. * 计划任务信息
3. *
4. * User: liyd
5. * Date: 14-1-3
6. * Time: 上午10:24
7. */
8. publicclassScheduleJob{
9.  
10. /** 任务id */
11. privateString jobId;
12.  
13. /** 任务名称 */
14. privateString jobName;
15.  
16. /** 任务分组 */
17. privateString jobGroup;
18.  
19. /** 任务状态 0禁用 1启用 2删除*/
20. privateString jobStatus;
21.  
22. /** 任务运行时间表达式 */
23. privateString cronExpression;
24.  
25. /** 任务描述 */
26. privateString desc;
27.  
28. getter and setter ....
29. }

接下来我们创建测试数据，实际应用中该数据可以保存在数据库等地方，我们把任务的分组名+任务名作为任务的唯一key，和quartz中的实现方式一致：

1. /** 计划任务map */
2. privatestaticMap<String,ScheduleJob> jobMap =newHashMap<String,ScheduleJob>();
3.  
4. static{
5. for(int i =0; i <5; i++){
6. ScheduleJob job =newScheduleJob();
7. job.setJobId("10001"+ i);
8. job.setJobName("data_import"+ i);
9. job.setJobGroup("dataWork");
10. job.setJobStatus("1");
11. job.setCronExpression("0/5 * * * * ?");
12. job.setDesc("数据导入任务");
13. addJob(job);
14. }
15. }
16.  
17. /**
18. * 添加任务
19. * @param scheduleJob
20. */
21. publicstaticvoid addJob(ScheduleJob scheduleJob){
22. jobMap.put(scheduleJob.getJobGroup()+"_"+ scheduleJob.getJobName(), scheduleJob);
23. }

有了调度工厂，有了任务运行入口实现类，有了任务信息，接下来就是创建我们的定时任务了，在这里我把它设计成一个Job对应一个trigger，两者的分组及名称相同，方便管理，条理也比较清晰，在创建任务时如果不存在新建一个，如果已经存在则更新任务，主要代码如下：

1. //schedulerFactoryBean 由spring创建注入
2. Scheduler scheduler = schedulerFactoryBean.getScheduler();
3.  
4. //这里获取任务信息数据
5. List<ScheduleJob> jobList =DataWorkContext.getAllJob();
6.  
7. for(ScheduleJob job : jobList){
8.  
9. TriggerKey triggerKey =TriggerKey.triggerKey(job.getJobName(), job.getJobGroup());
10.  
11. //获取trigger，即在spring配置文件中定义的 bean id="myTrigger"
12. CronTrigger trigger =(CronTrigger) scheduler.getTrigger(triggerKey);
13.  
14. //不存在，创建一个
15. if(null== trigger){
16. JobDetail jobDetail =JobBuilder.newJob(QuartzJobFactory.class)
17. .withIdentity(job.getJobName(), job.getJobGroup()).build();
18. jobDetail.getJobDataMap().put("scheduleJob", job);
19.  
20. //表达式调度构建器
21. CronScheduleBuilder scheduleBuilder =CronScheduleBuilder.cronSchedule(job
22. .getCronExpression());
23.  
24. //按新的cronExpression表达式构建一个新的trigger
25. trigger =TriggerBuilder.newTrigger().withIdentity(job.getJobName(), job.getJobGroup()).withSchedule(scheduleBuilder).build();
26.  
27. scheduler.scheduleJob(jobDetail, trigger);
28. }else{
29. // Trigger已存在，那么更新相应的定时设置
30. //表达式调度构建器
31. CronScheduleBuilder scheduleBuilder =CronScheduleBuilder.cronSchedule(job
32. .getCronExpression());
33.  
34. //按新的cronExpression表达式重新构建trigger
35. trigger = trigger.getTriggerBuilder().withIdentity(triggerKey)
36. .withSchedule(scheduleBuilder).build();
37.  
38. //按新的trigger重新设置job执行
39. scheduler.rescheduleJob(triggerKey, trigger);
40. }
41. }

如此，可以说已经完成了我们的动态任务创建，大功告成了。有了上面的代码，添加和修改任务是不是也会了，顺道解决了？

上面我们创建的5个测试任务，都是5秒执行一次，都将调用QuartzJobFactory的execute方法，但是传入的任务信息参数不同，execute方法中的如下代码就是得到具体的任务信息，包括任务分组和任务名：

1. ScheduleJob scheduleJob =(ScheduleJob)context.getMergedJobDataMap().get("scheduleJob");

有了任务分组和任务名即确定了该任务的唯一性，接下来需要什么操作实现起来是不是就很容易了？

以后需要添加新的定时任务只需要在任务信息列表中加入记录即可，然后在execute方法中通过判断任务分组和任务名来实现你具体的操作。

以上已经初始实现了我们需要的功能，增加和修改也已经可以通过源代码举一反三出来，但是我们在实际开发的时候需要进行测试，如果一个任务是1个小时运行一次的，测试起来是不是很不方便？当然你可以修改任务的运行时间表达式，但相信这不是最好的方法，接下来我们就要实现在不对当前任务信息做任何修改的情况下触发任务，并且该触发只会运行一次作测试用。待续，，，