使用 Quartz 实现任务的动态管理

原文地址：http://blog.csdn.net/shawearn1027/article/details/51457495

【写在前面】

　　1. 本文中使用的 Quartz 版本为 1.8.6；

　　2. 本文不会对 Quartz 做太多介绍；

　　3. 本文不会对代码做过多解释，因为大部分已经在代码的注释中说明过了；

　　4. 目前官网上最新的 Quartz 版本为 2.2.3，最新版的接口与本文所采用的 1.8.6 接口并不相同，使用本例代码请注意 Quartz 版本问题；

　　5. Quartz 官网地址：http://www.quartz-scheduler.org/

　　6. 本文为作者原创，转载请注明文章出处：http://blog.csdn.net/shawearn1027

【正文】

1. 定义对任务的管理的接口：

package com.shawearn.quartz.util;

import java.text.ParseException;

import org.quartz.SchedulerException;

/**
 * 定时任务工具类，用于管理定时任务；
 * 
 * @author Shawearn
 *
 */
public interface QuartzUtil {

	/**
	 * 添加一个定时任务，使用传入的任务名、任务群组名、触发器名、触发器群组名；
	 * 
	 * @param jobName 任务名；
	 * @param jobGroupName 任务的群组名；
	 * @param triggerName 触发器名；
	 * @param triggerGroupName 触发器群组名；
	 * @param jobClass 任务类；
	 * @param cronExpression cron表达式，用于指定任务的执行时间，参考 Quartz 说明文档；
	 * @throws SchedulerException 
	 * @throws ParseException 
	 */
	public void addJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName, Class jobClass, String cronExpression) throws SchedulerException, ParseException;
	
	/**
	 * 修改任务的执行时间；
	 * 
	 * @param jobName 任务名；
	 * @param jobGroupName 任务的群组名；
	 * @param triggerName 触发器名；
	 * @param triggerGroupName 触发器群组名；
	 * @param cronExpression cron表达式，用于指定任务的执行时间，参考 Quartz 说明文档；
	 * @throws SchedulerException 
	 * @throws ParseException 
	 */
	public void modifyJobTime(String jobName, String jobGroupName, String triggerName, String triggerGroupName, String cronExpression) throws SchedulerException, ParseException;
	
	/**
	 * 移除指定任务；
	 * 
	 * @param jobName 任务名；
	 * @param jobGroupName 任务的群组名；
	 * @param triggerName 触发器名；
	 * @param triggerGroupName 触发器群组名；
	 * @throws SchedulerException 
	 */
	public void removeJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName) throws SchedulerException;

	/**
	 * 启动所有定时任务；
	 * @throws SchedulerException 
	 */
	public void startAllJobs() throws SchedulerException;

	/**
	 * 关闭所有定时任务；
	 * @throws SchedulerException 
	 */
	public void shutdownAllJobs() throws SchedulerException;
	
	/**
	 * 暂停指定任务；
	 * 
	 * @param jobName 任务名；
	 * @param jobGroupName 任务的群组名；
	 * @throws SchedulerException 
	 */
	public void pauseJob(String jobName, String jobGroupName) throws SchedulerException;
	
	/**
	 * 恢复指定任务；
	 * 
	 * @param jobName 任务名；
	 * @param jobGroupName 任务的群组名；
	 * @throws SchedulerException 
	 */
	public void resumeJob(String jobName, String jobGroupName) throws SchedulerException;
}

2. 实现对任务进行动态管理的接口方法：

package com.shawearn.quartz.util;

import java.text.ParseException;

import javax.annotation.Resource;

import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.springframework.stereotype.Service;

@Service("quartzUtil")
public class QuartzUtilImpl implements QuartzUtil {

	@Resource
	SchedulerFactory schedulerFactory;
	
	@Override
	public void addJob(String jobName, String jobGroupName, String triggerName,
			String triggerGroupName, Class jobClass, String cronExpression) throws SchedulerException, ParseException {
		// 获得 Quartz 的调度器实例 scheduler；
		Scheduler scheduler = schedulerFactory.getScheduler();
		// 获取 Quartz 任务类实例 jobDetail；
		JobDetail jobDetail = new JobDetail(jobName, jobGroupName, jobClass);
		// 获取 Quartz 触发器实例 trigger；
		CronTrigger trigger = new CronTrigger(triggerName, triggerGroupName, cronExpression);
		// 调度任务；
		scheduler.scheduleJob(jobDetail, trigger);
		// 如果调度器未被关闭，则启动调度器；
		if (!scheduler.isShutdown()) {
			scheduler.start();
		}
	}
	
	@Override
	public void modifyJobTime(String jobName, String jobGroupName,
			String triggerName, String triggerGroupName, String cronExpression) throws SchedulerException, ParseException {
		// 获得 Quartz 的调度器实例 scheduler；
		Scheduler scheduler = schedulerFactory.getScheduler();
		// 从调度器中获取指定群组的指定名称的触发器实例；
		CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerName, triggerGroupName);
		// 对获取的触发器进行判空操作；
		if (trigger == null) {
			return;
		}
		String oldCronExpression = trigger.getCronExpression();
		// 如果新的执行时间与旧的执行时间相同，则返回，不继续下一步的操作；
		if (oldCronExpression.equalsIgnoreCase(cronExpression)) {
			return;
		}
		// 获取任务信息；
		JobDetail jobDetail = scheduler.getJobDetail(jobName, jobGroupName);
		// 获取到任务类；
		Class jobClass = jobDetail.getJobClass();
		// 移除旧的任务；
		this.removeJob(jobName, jobGroupName, triggerName, triggerGroupName);
		// 添加新任务；
		this.addJob(jobName, jobGroupName, triggerName, triggerGroupName, jobClass, cronExpression);
	}
	
	@Override
	public void removeJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName) throws SchedulerException {
		// 获得 Quartz 的调度器实例 scheduler；
		Scheduler scheduler = schedulerFactory.getScheduler();
		// 暂停定时器；
		scheduler.pauseTrigger(triggerName, triggerGroupName);
		// 取消任务调度；
		scheduler.unscheduleJob(jobName, jobGroupName);
		// 删除任务；
		scheduler.deleteJob(jobName, jobGroupName);
	}
	
	@Override
	public void startAllJobs() throws SchedulerException {
		// 获得 Quartz 的调度器实例 scheduler；
		Scheduler scheduler = schedulerFactory.getScheduler();
		// 如果调度器未被关闭，则启动调度器；
		if (!scheduler.isShutdown()) {
			scheduler.start();
		}
	}
	
	@Override
	public void shutdownAllJobs() throws SchedulerException {
		// 获得 Quartz 的调度器实例 scheduler；
		Scheduler scheduler = schedulerFactory.getScheduler();
		// 如果调度器未被关闭，关闭调度器；
		if (!scheduler.isShutdown()) {
			scheduler.shutdown();
		}
	}
	
	@Override
	public void pauseJob(String jobName, String jobGroupName) throws SchedulerException {
		// 获得 Quartz 的调度器实例 scheduler；
		Scheduler scheduler = schedulerFactory.getScheduler();
		// 暂停调度器中的指定任务；
		scheduler.pauseJob(jobName, jobGroupName);
	}
	
	@Override
	public void resumeJob(String jobName, String jobGroupName) throws SchedulerException {
		// 获得 Quartz 的调度器实例 scheduler；
		Scheduler scheduler = schedulerFactory.getScheduler();
		// 恢复调度器中的指定任务；
		scheduler.resumeJob(jobName, jobGroupName);
	}

}

3. 实现作业类，作业类需要实现 org.quartz.Job 类，处于篇幅考虑，此处只贴出 MyJob1 类的代码，其他作业类与 MyJob1 类似；

package com.shawearn.quartz.util;

import java.util.Date;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
 * 作业类；
 * 
 * @author Shawearn
 * 
 */
public class MyJob1 implements Job {

	@Override
	public void execute(JobExecutionContext context) throws JobExecutionException {
		// 在此处定义任务所要执行的操作，本例中为在控制台输出一串字符串；
		System.out.println("MyJob1.execute() : " + new Date());
	}

}

4. JUnit 测试类

package com.shawearn.test;

import java.text.ParseException;
import org.junit.BeforeClass;
import org.junit.Test;
import org.quartz.SchedulerException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.shawearn.quartz.util.MyJob1;
import com.shawearn.quartz.util.MyJob2;
import com.shawearn.quartz.util.MyJob3;
import com.shawearn.quartz.util.QuartzUtil;

public class TestService {
	public static BeanFactory beanFactory = null;
	public static QuartzUtil quartzUtil = null;
	
	@BeforeClass
	public static void init() {
		beanFactory = new ClassPathXmlApplicationContext("applicationContext.xml");
		quartzUtil = (QuartzUtil) beanFactory.getBean("quartzUtil");
	}
	
	@Test
	public void test() {
		String jobName1 = "MyJob1";
		String jobName2 = "MyJob2";
		String jobName3 = "MyJob3";
		
		try {
			System.out.println("开启定时任务 " + jobName1 + "，每秒执行一次！");
			quartzUtil.addJob(jobName1, "1", "1", "1", MyJob1.class, "0/1 * * * * ?");
			Thread.sleep(5000);
			
			System.out.println("修改定时任务 " + jobName1 + "，每两秒执行一次！");
			quartzUtil.modifyJobTime(jobName1, "1", "1", "1", "0/2 * * * * ?");
			Thread.sleep(5000);
			
			System.out.println("开启定时任务 MyJob2，每秒执行一次！");
			quartzUtil.addJob(jobName2, "1", "2", "1", MyJob2.class, "0/1 * * * * ?");
			Thread.sleep(5000);
			
			System.out.println("移除定时任务 " + jobName1);
			quartzUtil.removeJob(jobName1, "1", "1", "1");
			Thread.sleep(5000);
			
			System.out.println("开启定时任务 MyJob3，每三秒执行一次！");
			quartzUtil.addJob(jobName3, "1", "3", "1", MyJob3.class, "0/3 * * * * ?");
			Thread.sleep(5000);
			
			
			Thread.sleep(1000000000);
			
		} catch (SchedulerException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}