spring动态定时器

2019独角兽企业重金招聘Python工程师标准>>>

首先spring的配置还是要得，不过只需要一个bean,配置如下：

[html] view plain copy print ?

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

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

然后任务封装类，需要进行添加的任务可以new这个类的一个对象设置好属性就好了：

[java] view plain copy print ?

1. public class CustomJob {  
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.     private Class<?> stateFulljobExecuteClass;//同步的执行类，需要从StatefulMethodInvokingJob继承   
13.     private Class<?> jobExecuteClass;//异步的执行类，需要从MethodInvokingJob继承   
14.         /** 
15.      * 得到该job的Trigger名字 
16.      * @return  
17.      */  
18.     public String getTriggerName() {  
19.         return this.getJobId() + "Trigger";  
20.     }  
21.         /*私有字段的get，set省略*/  
22. }  

public class CustomJob {
	public static final int JS_ENABLED = 0; // 任务启用状态
	public static final int JS_DISABLED = 1; // 任务禁用状态
	public static final int JS_DELETE = 2; // 任务已删除状态

	private String jobId; // 任务的Id，一般为所定义Bean的ID
	private String jobName; // 任务的描述
	private String jobGroup; // 任务所属组的名称
	private int jobStatus; // 任务的状态，0：启用；1：禁用；2：已删除
	private String cronExpression; // 定时任务运行时间表达式
	private String memos; // 任务描述
	private Class<?> stateFulljobExecuteClass;//同步的执行类，需要从StatefulMethodInvokingJob继承
	private Class<?> jobExecuteClass;//异步的执行类，需要从MethodInvokingJob继承
        /**
	 * 得到该job的Trigger名字
	 * @return
	 */
	public String getTriggerName() {
		return this.getJobId() + "Trigger";
	}
        /*私有字段的get，set省略*/
}

然后任务管理器封装类，这个类是对任务的统一管理功能，有增，删，查，改

[java] view plain copy print ?

1. /** 
2.  *  
3.  */  
4. package org.liyaojin.quartz.dynamic;  
5.   
6. import org.quartz.CronTrigger;  
7. import org.quartz.JobDataMap;  
8. import org.quartz.JobDetail;  
9. import org.quartz.Scheduler;  
10. import org.quartz.SchedulerException;  
11. import org.quartz.Trigger;  
12. import org.quartz.impl.StdScheduler;  
13. import org.springframework.context.ApplicationContext;  
14. import org.springframework.context.support.ClassPathXmlApplicationContext;  
15.   
16. /** 
17.  * @author jl_love 
18.  *  
19.  *         2011-10-14 豁达，坚强，勤奋 
20.  */  
21. public class QuartzManager {  
22.     private static Scheduler scheduler;  
23.   
24.     static {  
25.         ApplicationContext context = new ClassPathXmlApplicationContext(  
26.                 "quartzDynamic.xml");  
27.         scheduler = (StdScheduler) context.getBean("schedulerFactory");  
28.     }  
29.   
30.     /** 
31.      * 启动一个自定义的job 
32.      *  
33.      * @param schedulingJob 
34.      *            自定义的job 
35.      * @param paramsMap 
36.      *            传递给job执行的数据 
37.      * @param isStateFull 
38.      *            是否是一个同步定时任务，true：同步，false：异步 
39.      * @return 成功则返回true，否则返回false 
40.      */  
41.     public static boolean enableCronSchedule(CustomJob schedulingJob,  
42.             JobDataMap paramsMap, boolean isStateFull) {  
43.         if (schedulingJob == null) {  
44.             return false;  
45.         }  
46.         try {  
47.             CronTrigger trigger = (CronTrigger) scheduler  
48.                     .getTrigger(schedulingJob.getTriggerName(),  
49.                             schedulingJob.getJobGroup());  
50.             if (null == trigger) {// 如果不存在该trigger则创建一个   
51.                 JobDetail jobDetail = null;  
52.                 if (isStateFull) {  
53.                     jobDetail = new JobDetail(schedulingJob.getJobId(),  
54.                             schedulingJob.getJobGroup(),  
55.                             schedulingJob.getStateFulljobExecuteClass());  
56.                 } else {  
57.                     jobDetail = new JobDetail(schedulingJob.getJobId(),  
58.                             schedulingJob.getJobGroup(),  
59.                             schedulingJob.getJobExecuteClass());  
60.                 }  
61.                 jobDetail.setJobDataMap(paramsMap);  
62.                 trigger = new CronTrigger(schedulingJob.getTriggerName(),  
63.                         schedulingJob.getJobGroup(),  
64.                         schedulingJob.getCronExpression());  
65.                 scheduler.scheduleJob(jobDetail, trigger);  
66.             } else {  
67.                 // Trigger已存在，那么更新相应的定时设置   
68.                 trigger.setCronExpression(schedulingJob.getCronExpression());  
69.                 scheduler.rescheduleJob(trigger.getName(), trigger.getGroup(),  
70.                         trigger);  
71.             }  
72.         } catch (Exception e) {  
73.             e.printStackTrace();  
74.             return false;  
75.         }  
76.         return true;  
77.     }  
78.   
79.     /** 
80.      * 禁用一个job 
81.      *  
82.      * @param jobId 
83.      *            需要被禁用的job的ID 
84.      * @param jobGroupId 
85.      *            需要被警用的jobGroupId 
86.      * @return 成功则返回true，否则返回false 
87.      */  
88.     public static boolean disableSchedule(String jobId, String jobGroupId) {  
89.         if (jobId.equals("") || jobGroupId.equals("")) {  
90.             return false;  
91.         }  
92.         try {  
93.             Trigger trigger = getJobTrigger(jobId, jobGroupId);  
94.             if (null != trigger) {  
95.                 scheduler.deleteJob(jobId, jobGroupId);  
96.             }  
97.         } catch (SchedulerException e) {  
98.             e.printStackTrace();  
99.             return false;  
100.         }  
101.         return true;  
102.     }  
103.   
104.     /** 
105.      * 得到job的详细信息 
106.      *  
107.      * @param jobId 
108.      *            job的ID 
109.      * @param jobGroupId 
110.      *            job的组ID 
111.      * @return job的详细信息,如果job不存在则返回null 
112.      */  
113.     public static JobDetail getJobDetail(String jobId, String jobGroupId) {  
114.         if (jobId.equals("") || jobGroupId.equals("") || null == jobId  
115.                 || jobGroupId == null) {  
116.             return null;  
117.         }  
118.         try {  
119.             return scheduler.getJobDetail(jobId, jobGroupId);  
120.         } catch (SchedulerException e) {  
121.             e.printStackTrace();  
122.             return null;  
123.         }  
124.     }  
125.   
126.     /** 
127.      * 得到job对应的Trigger 
128.      *  
129.      * @param jobId 
130.      *            job的ID 
131.      * @param jobGroupId 
132.      *            job的组ID 
133.      * @return job的Trigger,如果Trigger不存在则返回null 
134.      */  
135.     public static Trigger getJobTrigger(String jobId, String jobGroupId) {  
136.         if (jobId.equals("") || jobGroupId.equals("") || null == jobId  
137.                 || jobGroupId == null) {  
138.             return null;  
139.         }  
140.         try {  
141.             return scheduler.getTrigger(jobId + "Trigger", jobGroupId);  
142.         } catch (SchedulerException e) {  
143.             e.printStackTrace();  
144.             return null;  
145.         }  
146.     }  
147.   
148. }  

/**
 * 
 */
package org.liyaojin.quartz.dynamic;

import org.quartz.CronTrigger;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.impl.StdScheduler;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author jl_love
 * 
 *         2011-10-14 豁达，坚强，勤奋
 */
public class QuartzManager {
	private static Scheduler scheduler;

	static {
		ApplicationContext context = new ClassPathXmlApplicationContext(
				"quartzDynamic.xml");
		scheduler = (StdScheduler) context.getBean("schedulerFactory");
	}

	/**
	 * 启动一个自定义的job
	 * 
	 * @param schedulingJob
	 *            自定义的job
	 * @param paramsMap
	 *            传递给job执行的数据
	 * @param isStateFull
	 *            是否是一个同步定时任务，true：同步，false：异步
	 * @return 成功则返回true，否则返回false
	 */
	public static boolean enableCronSchedule(CustomJob schedulingJob,
			JobDataMap paramsMap, boolean isStateFull) {
		if (schedulingJob == null) {
			return false;
		}
		try {
			CronTrigger trigger = (CronTrigger) scheduler
					.getTrigger(schedulingJob.getTriggerName(),
							schedulingJob.getJobGroup());
			if (null == trigger) {// 如果不存在该trigger则创建一个
				JobDetail jobDetail = null;
				if (isStateFull) {
					jobDetail = new JobDetail(schedulingJob.getJobId(),
							schedulingJob.getJobGroup(),
							schedulingJob.getStateFulljobExecuteClass());
				} else {
					jobDetail = new JobDetail(schedulingJob.getJobId(),
							schedulingJob.getJobGroup(),
							schedulingJob.getJobExecuteClass());
				}
				jobDetail.setJobDataMap(paramsMap);
				trigger = new CronTrigger(schedulingJob.getTriggerName(),
						schedulingJob.getJobGroup(),
						schedulingJob.getCronExpression());
				scheduler.scheduleJob(jobDetail, trigger);
			} else {
				// Trigger已存在，那么更新相应的定时设置
				trigger.setCronExpression(schedulingJob.getCronExpression());
				scheduler.rescheduleJob(trigger.getName(), trigger.getGroup(),
						trigger);
			}
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		return true;
	}

	/**
	 * 禁用一个job
	 * 
	 * @param jobId
	 *            需要被禁用的job的ID
	 * @param jobGroupId
	 *            需要被警用的jobGroupId
	 * @return 成功则返回true，否则返回false
	 */
	public static boolean disableSchedule(String jobId, String jobGroupId) {
		if (jobId.equals("") || jobGroupId.equals("")) {
			return false;
		}
		try {
			Trigger trigger = getJobTrigger(jobId, jobGroupId);
			if (null != trigger) {
				scheduler.deleteJob(jobId, jobGroupId);
			}
		} catch (SchedulerException e) {
			e.printStackTrace();
			return false;
		}
		return true;
	}

	/**
	 * 得到job的详细信息
	 * 
	 * @param jobId
	 *            job的ID
	 * @param jobGroupId
	 *            job的组ID
	 * @return job的详细信息,如果job不存在则返回null
	 */
	public static JobDetail getJobDetail(String jobId, String jobGroupId) {
		if (jobId.equals("") || jobGroupId.equals("") || null == jobId
				|| jobGroupId == null) {
			return null;
		}
		try {
			return scheduler.getJobDetail(jobId, jobGroupId);
		} catch (SchedulerException e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 得到job对应的Trigger
	 * 
	 * @param jobId
	 *            job的ID
	 * @param jobGroupId
	 *            job的组ID
	 * @return job的Trigger,如果Trigger不存在则返回null
	 */
	public static Trigger getJobTrigger(String jobId, String jobGroupId) {
		if (jobId.equals("") || jobGroupId.equals("") || null == jobId
				|| jobGroupId == null) {
			return null;
		}
		try {
			return scheduler.getTrigger(jobId + "Trigger", jobGroupId);
		} catch (SchedulerException e) {
			e.printStackTrace();
			return null;
		}
	}

}

最后给出测试代码：
1：任务类

[java] view plain copy print ?

1.    /** 
2.  *  
3.  */  
4. package org.liyaojin.quartz.dynamic;  
5.   
6. import org.quartz.JobExecutionContext;  
7. import org.quartz.JobExecutionException;  
8. import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean.StatefulMethodInvokingJob;  
9. import org.springframework.scheduling.quartz.QuartzJobBean;  
10.   
11. /** 
12.  * @author jl_love 
13.  * 
14.  * 2011-10-14 
15.  * 豁达，坚强，勤奋 
16.  */  
17. public class QuartzJobOne extends StatefulMethodInvokingJob {  
18.     private static int i = 0;  
19.     private int j = 0; /*说明每次执行都是new了一个新的执行类，具有线程安全性*/  
20.     /* (non-Javadoc) 
21.      * @see org.springframework.scheduling.quartz.QuartzJobBean#executeInternal(org.quartz.JobExecutionContext) 
22.      */  
23.     @Override  
24.     protected void executeInternal(JobExecutionContext context)  
25.             throws JobExecutionException {  
26.         j++;/*说明每次执行都是new了一个新的执行类，具有线程安全性*/  
27.         i++;  
28.         System.out.println("j====>" + j);/*说明每次执行都是new了一个新的执行类，具有线程安全性*/  
29.         System.out.println("这是我得第" + i + "次执行");  
30.         System.out.println("my name is QuartzJobOne");  
31.         System.out.println(context.getJobDetail().getJobDataMap().get("p2"));/*拿到传入的数据*/  
32.         if(i == 3){  
33.             System.out.println("我只执行三次.....");  
34.             QuartzManager.disableSchedule("job1","job1_group");  
35.         }  
36.     }  
37. }  

/**
 * 
 */
package org.liyaojin.quartz.dynamic;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean.StatefulMethodInvokingJob;
import org.springframework.scheduling.quartz.QuartzJobBean;

/**
 * @author jl_love
 *
 * 2011-10-14
 * 豁达，坚强，勤奋
 */
public class QuartzJobOne extends StatefulMethodInvokingJob {
	private static int i = 0;
	private int j = 0; /*说明每次执行都是new了一个新的执行类，具有线程安全性*/
	/* (non-Javadoc)
	 * @see org.springframework.scheduling.quartz.QuartzJobBean#executeInternal(org.quartz.JobExecutionContext)
	 */
	@Override
	protected void executeInternal(JobExecutionContext context)
			throws JobExecutionException {
		j++;/*说明每次执行都是new了一个新的执行类，具有线程安全性*/
		i++;
		System.out.println("j====>" + j);/*说明每次执行都是new了一个新的执行类，具有线程安全性*/
		System.out.println("这是我得第" + i + "次执行");
		System.out.println("my name is QuartzJobOne");
		System.out.println(context.getJobDetail().getJobDataMap().get("p2"));/*拿到传入的数据*/
		if(i == 3){
			System.out.println("我只执行三次.....");
			QuartzManager.disableSchedule("job1","job1_group");
		}
	}
}

测试main方法：

[java] view plain copy print ?

1. /** 
2.  *  
3.  */  
4. package org.liyaojin.quartz.dynamic;  
5.   
6. import java.util.ArrayList;  
7.   
8. import org.quartz.JobDataMap;  
9.   
10. /** 
11.  * @author jl_love 
12.  * 
13.  * 2011-10-14 
14.  * 豁达，坚强，勤奋 
15.  */  
16. public class QuartzManagerTest {  
17.   
18.     /** 
19.      * @param args 
20.      */  
21.     public static void main(String[] args) {  
22.         CustomJob job = new CustomJob();  
23.         job.setJobId("job1");  
24.         job.setJobGroup("job1_group");  
25.         job.setJobName("第一个测试定时器");  
26.         job.setMemos("我是第一个测试定时器的描述");  
27.         job.setCronExpression("0/5 * * * * ?");//每五秒执行一次   
28.         job.setStateFulljobExecuteClass(QuartzJobOne.class);  
29.           
30.         JobDataMap paramsMap = new JobDataMap();  
31.         ArrayList<String> paramList = new ArrayList<String>();  
32.         paramList.add("one");  
33.         paramList.add("two");  
34.         paramList.add("three");  
35.           
36.         paramsMap.put("p1","p1");  
37.         paramsMap.put("p2",paramList);  
38.         QuartzManager.enableCronSchedule(job, paramsMap, true);  
39.     }  
40.   
41. }  

/**
 * 
 */
package org.liyaojin.quartz.dynamic;

import java.util.ArrayList;

import org.quartz.JobDataMap;

/**
 * @author jl_love
 *
 * 2011-10-14
 * 豁达，坚强，勤奋
 */
public class QuartzManagerTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		CustomJob job = new CustomJob();
		job.setJobId("job1");
		job.setJobGroup("job1_group");
		job.setJobName("第一个测试定时器");
		job.setMemos("我是第一个测试定时器的描述");
		job.setCronExpression("0/5 * * * * ?");//每五秒执行一次
		job.setStateFulljobExecuteClass(QuartzJobOne.class);
		
		JobDataMap paramsMap = new JobDataMap();
		ArrayList<String> paramList = new ArrayList<String>();
		paramList.add("one");
		paramList.add("two");
		paramList.add("three");
		
		paramsMap.put("p1","p1");
		paramsMap.put("p2",paramList);
		QuartzManager.enableCronSchedule(job, paramsMap, true);
	}

}

具体原理我就不多说了，重在实用。其实也没什么技术含量，主要就是调用quartz的api同时利用了spring对quartz的封装。只是为了方便自己，也为了方便大家。

我会附上该测试工程的源码，我使用的是spring 3.0.2中dist下所有的jar包，以及spring依赖包中的apacheCommons底下所有的jar包，还有quartz的jar包，我会附上jar包得截图放在源码的压缩包里面。

源代码下载地址：http://dl.iteye.com/topics/download/7a2de849-d08b-32ac-a6cf-844b35ef848f

转载于:https://my.oschina.net/victorHomePage/blog/95657