如何动态的改变Quartz的调度作业的时间

如何动态的改变Quartz的调度作业的时间

近日碰到一位友人提出的一个问题，如何动态的改变Quartz的调度作业的时间。比如，由每10分钟执行一次改为每5分钟执行一次。个人认为这种需求应该通过某种方式来规避，或者选用其他的技术框架，因为动态改变Quartz的调度时间完全失去了使用Quartz的意义。本人在使用Quartz是基于Spring来配置的，而朋友的项目中不能使用SPring框架，这就需要直接基于Quartz编程。工作之余，写了个例子：
Quartz的管理类

Java代码

1. public class QuartzManage {
2. private static SchedulerFactory sf = new StdSchedulerFactory();
3. private static String JOB_GROUP_NAME = "group";
4. private static String TRIGGER_GROUP_NAME = "trigger";
5. public static void startJob(String jobName, Job job, String time)
6. throws SchedulerException, ParseException {
7. Scheduler sched = sf.getScheduler();
8. JobDetail jobDetail = new JobDetail();
9. jobDetail.setName(jobName);
10. jobDetail.setGroup(JOB_GROUP_NAME);
11. jobDetail.setJobClass(job.getClass());
12. CronTrigger trigger = new CronTrigger(jobName, TRIGGER_GROUP_NAME);
13. trigger.setCronExpression(time);
14. sched.scheduleJob(jobDetail, trigger);
15. if (!sched.isShutdown()) {
16. sched.start();
17. }
18. }
19. /**
20. * 从Scheduler 移除当前的Job,修改Trigger
21. *
22. * @param jobDetail
23. * @param time
24. * @throws SchedulerException
25. * @throws ParseException
26. */
27. public static void modifyJobTime(JobDetail jobDetail, String time)
28. throws SchedulerException, ParseException {
29. Scheduler sched = sf.getScheduler();
30. Trigger trigger = sched.getTrigger(jobDetail.getName(),
31. TRIGGER_GROUP_NAME);
32. if (trigger != null) {
33. CronTrigger ct = (CronTrigger) trigger;
34. // 移除当前进程的Job
35. sched.deleteJob(jobDetail.getName(), jobDetail.getGroup());
36. // 修改Trigger
37. ct.setCronExpression(time);
38. System.out.println("CronTrigger getName " + ct.getJobName());
39. // 重新调度jobDetail
40. sched.scheduleJob(jobDetail, ct);
41. }
42. }
43. }

public class QuartzManage {
	private static SchedulerFactory sf = new StdSchedulerFactory();
	private static String JOB_GROUP_NAME = "group";
	private static String TRIGGER_GROUP_NAME = "trigger";

	public static void startJob(String jobName, Job job, String time)
			throws SchedulerException, ParseException {
		Scheduler sched = sf.getScheduler();

		JobDetail jobDetail = new JobDetail();
		jobDetail.setName(jobName);
		jobDetail.setGroup(JOB_GROUP_NAME);
		jobDetail.setJobClass(job.getClass());

		CronTrigger trigger = new CronTrigger(jobName, TRIGGER_GROUP_NAME);
		trigger.setCronExpression(time);
		sched.scheduleJob(jobDetail, trigger);

		if (!sched.isShutdown()) {
			sched.start();
		}
	}

	/**
	 * 从Scheduler 移除当前的Job,修改Trigger
	 * 
	 * @param jobDetail
	 * @param time
	 * @throws SchedulerException
	 * @throws ParseException
	 */
	public static void modifyJobTime(JobDetail jobDetail, String time)
			throws SchedulerException, ParseException {
		Scheduler sched = sf.getScheduler();
		Trigger trigger = sched.getTrigger(jobDetail.getName(),
				TRIGGER_GROUP_NAME);
		if (trigger != null) {
			CronTrigger ct = (CronTrigger) trigger;
			// 移除当前进程的Job
			sched.deleteJob(jobDetail.getName(), jobDetail.getGroup());
			// 修改Trigger
			ct.setCronExpression(time);
			System.out.println("CronTrigger getName " + ct.getJobName());
			// 重新调度jobDetail
			sched.scheduleJob(jobDetail, ct);
		}
	}

}

Job任务：

Java代码

1. public class JobTest implements Job {
2. static int a = 0;
3. @Override
4. public void execute(JobExecutionContext context)
5. throws JobExecutionException {
6. a += 1;
7. System.out.println("test ++++++++++++++++++++++a=" + a);
8. if (a == 4) {
9. try {
10. QuartzManage.modifyJobTime(context.getJobDetail(),
11. "0/10 * * * * ?");
12. } catch (SchedulerException e) {
13. e.printStackTrace();
14. } catch (ParseException e) {
15. e.printStackTrace();
16. }
17. }
18. }
19. }

public class JobTest implements Job {
	static int a = 0;

	@Override
	public void execute(JobExecutionContext context)
			throws JobExecutionException {
		a += 1;
		System.out.println("test ++++++++++++++++++++++a=" + a);

		if (a == 4) {
			try {
				QuartzManage.modifyJobTime(context.getJobDetail(),
						"0/10 * * * * ?");
			} catch (SchedulerException e) {
				e.printStackTrace();
			} catch (ParseException e) {
				e.printStackTrace();
			}
		}
	}

}

启动线程执行调度：

Java代码

1. public class QuartzTest {
2. public static void main(String[] args) throws SchedulerException,
3. ParseException {
4. /*
5. * 此进程为主进程，触发了quartz对Job的调度 因此启动Job之后，在该进程修改调度，是没有效果的
6. */
7. JobTest job = new JobTest();
8. QuartzManage.startJob("ming", job, "0/2 * * * * ?");
9. }
10. }

public class QuartzTest {
	public static void main(String[] args) throws SchedulerException,
			ParseException {
		/*
		 * 此进程为主进程，触发了quartz对Job的调度 因此启动Job之后，在该进程修改调度，是没有效果的
		 */
		JobTest job = new JobTest();
		QuartzManage.startJob("ming", job, "0/2 * * * * ?");
	}
}

好多人的思路是在启动的主线程内去改变调度的时间，简单的分析就可发现，主线程启动之后就会按照调度时间去运行Job，不会返回主线程再去加载调度时间，只是起到了触发调度的操作。因此要进行动态的修改调度时间，需要在Job任务里，动态改变当前线程的调度计划。

测试代码，开始时按每2秒执行一次打印a，当a打印4次以后，按照每10秒一次执行。虽然代码测试成功，本人还有疑惑。

Java代码

1. // 移除当前进程的Job
2. sched.deleteJob(jobDetail.getName(), jobDetail.getGroup());