Quartz学习研究（四）：一个最基本的Quartz动态定时项目（附项目源代码）

1、前言：前几篇文章讨论的都是静态定时器，也就是一旦服务器启动了，定时规则便无法变动，除非重启服务器，但这在真正运营的时候是不可能的。所以对于客户自定义的定时任务之前的方式都是不可实现的，这就需要动态定时器，本篇文章中的例子是参考了网上某篇博客的，由于时间比较长，所以已经找不到原地址了，望原博主原谅。

2、封装了两个最基本的类：任务类（CustomJob）和任务管理器类（QuartzManager）。

[java]  view plain copy

1. package com.telek.framework.quartz;  
2.   
3. /** 
4.  * Description:任务封装类，需要进行添加的任务可以new这个类的一个对象设置好属性就行 
5.  * CustomJob.java Create on 2012-11-23 上午9:18:20  
6.  * @author 张景 
7.  * @version 1.0 
8.  * Copyright (c) 2012 telek. All Rights Reserved. 
9.  */  
10. public class CustomJob {  
11.     public static final int JS_ENABLED = 0; // 任务启用状态  
12.     public static final int JS_DISABLED = 1; // 任务禁用状态  
13.     public static final int JS_DELETE = 2; // 任务已删除状态  
14.   
15.     private String jobId; // 任务的Id，一般为所定义Bean的ID  
16.     private String jobName; // 任务的描述  
17.     private String jobGroup; // 任务所属组的名称  
18.     private int jobStatus; // 任务的状态：0：启用；1：禁用；2：已删除  
19.     private String cronExpression; // 定时任务运行时间表达式  
20.     private String memos; // 任务描述  
21.     private Class<?> stateFulljobExecuteClass;// 同步的执行类，需要从StatefulMethodInvokingJob继承  
22.     private Class<?> jobExecuteClass;// 异步的执行类，需要从MethodInvokingJob继承  
23.   
24.     public String getJobId() {  
25.         return jobId;  
26.     }  
27.   
28.     public void setJobId(String jobId) {  
29.         this.jobId = jobId;  
30.     }  
31.   
32.     public String getJobName() {  
33.         return jobName;  
34.     }  
35.   
36.     public void setJobName(String jobName) {  
37.         this.jobName = jobName;  
38.     }  
39.   
40.     public String getJobGroup() {  
41.         return jobGroup;  
42.     }  
43.   
44.     public void setJobGroup(String jobGroup) {  
45.         this.jobGroup = jobGroup;  
46.     }  
47.   
48.     public int getJobStatus() {  
49.         return jobStatus;  
50.     }  
51.   
52.     public void setJobStatus(int jobStatus) {  
53.         this.jobStatus = jobStatus;  
54.     }  
55.   
56.     public String getCronExpression() {  
57.         return cronExpression;  
58.     }  
59.   
60.     public void setCronExpression(String cronExpression) {  
61.         this.cronExpression = cronExpression;  
62.     }  
63.   
64.     public String getMemos() {  
65.         return memos;  
66.     }  
67.   
68.     public void setMemos(String memos) {  
69.         this.memos = memos;  
70.     }  
71.   
72.     public Class<?> getStateFulljobExecuteClass() {  
73.         return stateFulljobExecuteClass;  
74.     }  
75.   
76.     public void setStateFulljobExecuteClass(Class<?> stateFulljobExecuteClass) {  
77.         this.stateFulljobExecuteClass = stateFulljobExecuteClass;  
78.     }  
79.   
80.     public Class<?> getJobExecuteClass() {  
81.         return jobExecuteClass;  
82.     }  
83.   
84.     public void setJobExecuteClass(Class<?> jobExecuteClass) {  
85.         this.jobExecuteClass = jobExecuteClass;  
86.     }  
87.   
88.     public static int getJsEnabled() {  
89.         return JS_ENABLED;  
90.     }  
91.   
92.     public static int getJsDisabled() {  
93.         return JS_DISABLED;  
94.     }  
95.   
96.     public static int getJsDelete() {  
97.         return JS_DELETE;  
98.     }  
99.   
100.     /** 
101.      * Description:得到该job的Trigger名字 
102.      * Date:2012-11-23 
103.      * @author 张景 
104.      * @param @return 
105.      * @return String 
106.      */  
107.     public String getTriggerName() {  
108.         return this.getJobId() + "Trigger";  
109.     }  
110.       
111. }  

[java]  view plain copy

1. package com.telek.framework.quartz;  
2.   
3. import org.quartz.CronTrigger;  
4. import org.quartz.JobDataMap;  
5. import org.quartz.JobDetail;  
6. import org.quartz.Scheduler;  
7. import org.quartz.SchedulerException;  
8. import org.quartz.Trigger;  
9. import org.quartz.impl.StdScheduler;  
10. import org.springframework.context.ApplicationContext;  
11. import org.springframework.context.support.ClassPathXmlApplicationContext;  
12.   
13. /** 
14.  * Description:任务管理器封装类，对任务的统一管理功能，有增，删，查 
15.  * QuartzManager.java Create on 2012-11-23 上午9:19:15  
16.  * @author 张景 
17.  * @version 1.0 
18.  * Copyright (c) 2012 telek. All Rights Reserved. 
19.  */  
20. public class QuartzManager {  
21.   
22.     private static Scheduler scheduler;  
23.   
24.     static {  
25.         ApplicationContext context = new ClassPathXmlApplicationContext(  
26.                 "applicationContext-quartz.xml");  
27.         scheduler = (StdScheduler) context.getBean("schedulerFactory");  
28.     }  
29.   
30.     /** 
31.      * Description:启动一个自定义的job 
32.      * Date:2012-11-23 
33.      * @author 张景 
34.      * @param @param schedulingJob 
35.      * @param @param paramsMap 
36.      * @param @param isStateFull 
37.      * @param @return 
38.      * @return boolean 
39.      */  
40.     public static boolean enableCronSchedule(CustomJob schedulingJob,  
41.             JobDataMap paramsMap, boolean isStateFull) {  
42.         if (schedulingJob == null) {  
43.             return false;  
44.         }  
45.         try {  
46.             CronTrigger trigger = (CronTrigger) scheduler  
47.                     .getTrigger(schedulingJob.getTriggerName(),  
48.                             schedulingJob.getJobGroup());  
49.             if (null == trigger) {// 如果不存在该trigger则创建一个  
50.                 JobDetail jobDetail = null;  
51.                 if (isStateFull) {  
52.                     jobDetail = new JobDetail(schedulingJob.getJobId(),  
53.                             schedulingJob.getJobGroup(),  
54.                             schedulingJob.getStateFulljobExecuteClass());  
55.                 } else {  
56.                     jobDetail = new JobDetail(schedulingJob.getJobId(),  
57.                             schedulingJob.getJobGroup(),  
58.                             schedulingJob.getJobExecuteClass());  
59.                 }  
60.                 jobDetail.setJobDataMap(paramsMap);  
61.                 trigger = new CronTrigger(schedulingJob.getTriggerName(),  
62.                         schedulingJob.getJobGroup(),  
63.                         schedulingJob.getCronExpression());  
64.                 scheduler.scheduleJob(jobDetail, trigger);  
65.             } else {// Trigger已存在，那么更新相应的定时设置  
66.                 trigger.setCronExpression(schedulingJob.getCronExpression());  
67.                 scheduler.rescheduleJob(trigger.getName(), trigger.getGroup(),  
68.                         trigger);  
69.             }  
70.         } catch (Exception e) {  
71.             e.printStackTrace();  
72.             return false;  
73.         }  
74.         return true;  
75.     }  
76.   
77.     /** 
78.      * Description:禁用一个job 
79.      * Date:2012-11-23 
80.      * @author 张景 
81.      * @param @param jobId 
82.      * @param @param jobGroupId 
83.      * @param @return 
84.      * @return boolean 
85.      */  
86.     public static boolean disableSchedule(String jobId, String jobGroupId) {  
87.         if (jobId.equals("") || jobGroupId.equals("")) {  
88.             return false;  
89.         }  
90.         try {  
91.             Trigger trigger = getJobTrigger(jobId, jobGroupId);  
92.             if (null != trigger) {  
93.                 scheduler.deleteJob(jobId, jobGroupId);  
94.             }  
95.         } catch (SchedulerException e) {  
96.             e.printStackTrace();  
97.             return false;  
98.         }  
99.         return true;  
100.     }  
101.   
102.     /** 
103.      * Description:得到job的详细信息 
104.      * Date:2012-11-23 
105.      * @author 张景 
106.      * @param @param jobId 
107.      * @param @param jobGroupId 
108.      * @param @return 
109.      * @return JobDetail 
110.      */  
111.     public static JobDetail getJobDetail(String jobId, String jobGroupId) {  
112.         if (jobId.equals("") || jobGroupId.equals("") || null == jobId  
113.                 || jobGroupId == null) {  
114.             return null;  
115.         }  
116.         try {  
117.             return scheduler.getJobDetail(jobId, jobGroupId);  
118.         } catch (SchedulerException e) {  
119.             e.printStackTrace();  
120.             return null;  
121.         }  
122.     }  
123.   
124.     /** 
125.      * Description:得到job对应的Trigger 
126.      * Date:2012-11-23 
127.      * @author 张景 
128.      * @param @param jobId 
129.      * @param @param jobGroupId 
130.      * @param @return 
131.      * @return Trigger 
132.      */  
133.     public static Trigger getJobTrigger(String jobId, String jobGroupId) {  
134.         if (jobId.equals("") || jobGroupId.equals("") || null == jobId  
135.                 || jobGroupId == null) {  
136.             return null;  
137.         }  
138.         try {  
139.             return scheduler.getTrigger(jobId + "Trigger", jobGroupId);  
140.         } catch (SchedulerException e) {  
141.             e.printStackTrace();  
142.             return null;  
143.         }  
144.     }  
145.   
146. }  

3、上述类已经封装好，在运用的时候我们不需要去修改。接下来初始化一个任务Job，也就是具体要做的业务（本次是在控制台打印出HelloWorld和当前时间）。注意：这里的HelloWorld类必须继承StatefulMethodInvokingJob，并且重写里面的executeInternal(JobExecutionContext context)方法。

[java]  view plain copy

1. package com.telek.quartz;  
2.   
3. import java.util.Date;  
4.   
5. import org.quartz.JobExecutionContext;  
6. import org.quartz.JobExecutionException;  
7. import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean.StatefulMethodInvokingJob;  
8.   
9. /** 
10.  * Description:具体业务代码，此处输出:HelloWorld+打印时间 
11.  * HelloWorld.java Create on 2012-11-23 上午9:21:29  
12.  * @author 张景 
13.  * @version 1.0 
14.  * Copyright (c) 2012 telek. All Rights Reserved. 
15.  */  
16. public class HelloWorld extends StatefulMethodInvokingJob {  
17.   
18.     @Override  
19.     public void executeInternal(JobExecutionContext context)  
20.             throws JobExecutionException {  
21.         System.out.println("HelloWorld : " + new Date());  
22.     }  
23.   
24. }  

4、配置applicationContext-quartz.xml文件，其中只有一句话，只是为了方便scheduler的实例化。

[java]  view plain copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">  
3.   
4. <beans>  
5.     <bean name="schedulerFactory"  
6.         class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
7.     </bean>  
8. </beans>  

5、写一个测试类StartQuartz
new一个任务封装类，然后set你自己的任务属性，最后调用任务管理类QuartManager的enableCronSchedule方法启动调度器，当然里面还有一些其他方法是提供用户调用的，比如删除等。

[java]  view plain copy

1. package com.telek.test;  
2.   
3. import com.telek.framework.quartz.CustomJob;  
4. import com.telek.framework.quartz.QuartzManager;  
5. import com.telek.quartz.HelloWorld;  
6.   
7. public class StartQuartz {  
8.   
9.     /** 
10.      * Description:测试一个自定义的定时器 
11.      * Date:2012-11-23 
12.      * @author 张景 
13.      * @param @param args 
14.      * @return void 
15.      */  
16.     public static void main(String[] args) {  
17.   
18.         CustomJob helloWorld = new CustomJob();  
19.         helloWorld.setJobId("helloWorld");  
20.         helloWorld.setJobGroup("helloWorldGroup");  
21.         helloWorld.setJobName("HelloWorldName");  
22.         helloWorld.setMemos("HelloWorld测试定时器的描述");  
23.         helloWorld.setCronExpression("0/6 * * * * ?");  
24.         helloWorld.setStateFulljobExecuteClass(HelloWorld.class);  
25.   
26.         QuartzManager.enableCronSchedule(helloWorld, null, true);  
27.   
28.     }  
29.   
30. }  

6、其实上面看上去内容多，需要我们去做的也就是第二步和第四步，只要配好这两步，你就可以随心地动态定时自己的任务了。
7、最后运行StartQuartz里面的main方法进行测试。
8、观察结果：在控制台上在每分钟6秒的倍数会打印出helloWorld和当前时间。