Spring + Quartz任务调度实战之动态作业调度

本文地址：http://blog.csdn.net/kongxx/article/details/6860732

前面写了几个文章是关于spring中集成作业调度功能的东西，可以参考

Spring任务调度实战之Timer

Spring任务调度实战之Quartz Simple Trigger

Spring任务调度实战之Quartz Cron Trigger

但那些例子都是对静态作业做调度的例子，这里所谓静态作业都是指作业信息和调度信息是写死在spring的配置文件中的，但是真实很多应用的情况都是需要动态的对作业进行调度，比如动态添加或者删除作业，动态的设置作业的trigger等。下面就来看看在spring中怎样实现对动态作业进行调度。

1. 首先是一个任务类，这个类没有实现任何接口，其中包含一个run方法用来运行这个task，代码如下：

[java]  view plain copy print ?

1. package org.garbagecan.springstudy.schedule.quartz;  
2.   
3. public class MyTask {  
4.     private String name;  
5.       
6.     public void run() {  
7.         System.out.println("Run task: " + name + ".");  
8.     }  
9.   
10.     public String getName() {  
11.         return name;  
12.     }  
13.   
14.     public void setName(String name) {  
15.         this.name = name;  
16.     }  
17. }  

2. 一个Job类，这个类需要继承spring的QuartzJobBean类，来说明当前类是一个Quartz的Job类，类包含了一个Task类的对象实例，在每次Job被调度的时候，将会运行其中的executeInternal方法，代码如下：

[java]  view plain copy print ?

1. package org.garbagecan.springstudy.schedule.quartz;  
2.   
3. import org.quartz.JobExecutionContext;  
4. import org.quartz.JobExecutionException;  
5. import org.springframework.scheduling.quartz.QuartzJobBean;  
6.   
7. public class MyJob extends QuartzJobBean {  
8.       
9.     private MyTask myTask;  
10.   
11.     protected void executeInternal(JobExecutionContext context)  
12.             throws JobExecutionException {  
13.           
14.         myTask.run();  
15.     }  
16.   
17.     public MyTask getMyTask() {  
18.         return myTask;  
19.     }  
20.   
21.     public void setMyTask(MyTask myTask) {  
22.         this.myTask = myTask;  
23.     }  
24. }  

3. Spring配置文件，内容如下

[html]  view plain copy print ?

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"  
4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd"  
5.        default-lazy-init="true">  
6.   
7.     <bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean" lazy-init="false">  
8.         <property name="triggers">  
9.             <list>  
10.             </list>  
11.         </property>  
12.     </bean>  
13.   
14. </beans>  

配置中仅仅配置了一个schedule类的实例，其中的triggers的列表为空。这样在这个schedule启动的时候就不会schedule任何作业。

4. 最后，写一个测试类来测试上面的代码和配置

[java]  view plain copy print ?

1. package org.garbagecan.springstudy.schedule.dynamic;  
2.   
3. import org.quartz.CronTrigger;  
4. import org.quartz.JobDetail;  
5. import org.quartz.Scheduler;  
6. import org.quartz.SchedulerException;  
7. import org.springframework.context.ApplicationContext;  
8. import org.springframework.context.support.ClassPathXmlApplicationContext;  
9.   
10. import java.text.ParseException;  
11.   
12. public class Test {  
13.     public static void main(String[] args) {  
14.         ApplicationContext ctx = new ClassPathXmlApplicationContext("/org/garbagecan/springstudy/schedule/dynamic/spring.xml");  
15.         Scheduler scheduler = (Scheduler)ctx.getBean("scheduler");  
16.   
17.         System.out.println("Scheduling to run tasks.");  
18.         for (int i = 0; i < 5; i++) {  
19.             try {  
20.                 JobDetail jobDetail = new JobDetail();  
21.                 jobDetail.setName("job_" + i);  
22.                 MyTask myTask = new MyTask();  
23.                 myTask.setName("task_" + i);  
24.                 jobDetail.getJobDataMap().put("myTask", myTask);  
25.                 jobDetail.setJobClass(MyJob.class);  
26.                 scheduler.addJob(jobDetail, true);  
27.   
28.                 CronTrigger cronTrigger =new CronTrigger("cron_" + i, Scheduler.DEFAULT_GROUP, jobDetail.getName(), Scheduler.DEFAULT_GROUP);  
29.                 cronTrigger.setCronExpression("0/10 * * * * ?");  
30.   
31.                 scheduler.scheduleJob(cronTrigger);  
32.             } catch (ParseException e) {  
33.                 e.printStackTrace();  
34.             } catch (SchedulerException e) {  
35.                 e.printStackTrace();  
36.             }  
37.         }  
38.   
39.         try {  
40.             Thread.sleep(60 * 1000);  
41.         } catch (InterruptedException e) {  
42.             e.printStackTrace();  
43.         }  
44.   
45.         System.out.println("Un-scheduling to run tasks.");  
46.         for (int i = 0; i < 5; i++) {  
47.             try {  
48.                 scheduler.unscheduleJob("cron_" + i, Scheduler.DEFAULT_GROUP);  
49.             } catch (SchedulerException e) {  
50.                 e.printStackTrace();  
51.             }  
52.         }  
53.     }  
54. }  

4.1 测试类首先创建了5个JobDetail和CronTrigger，每个JobDetail对应一个我们的MyJob和MyTask类实例，每个CronTrigger都是10秒钟运行一次的cron表达式。具体的API可以参考Quartz的官方文档；
4.2 对于每个创建的JobDetail和CronTrigger，都使用Quartz的Scheduler去做调度；
4.3 等待60秒，让上面创建的那些作业运行几次，此时在后台可以看到有message输出；
4.4 Un-schedule上面创建的JobDetail和CronTrigger，此段代码之后，所有的作业都被停止了。