Java Quartz 手工操作

在基于J2EE的应用系统中，quartz作为定时器得到了广泛的使用，通常的使用方式是采用配置的形式，或者与Spring集成使用，下面介绍一种更为灵活的手工操作方式，此方法比较适合需要人工控制定时任务停止、启动以及修改执行周期等，直接上代码：

import org.quartz.CronTrigger;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.tshark.core.exception.TSharkException;

/**
 * 定时任务调试引擎，负责完成定时任务的执行、启动、停止。。。
 */
public class ScheduleJobEngine {
	protected static Logger log = LoggerFactory.getLogger(ScheduleJobEngine.class);

	private static SchedulerFactory schedulerFactory = new StdSchedulerFactory();
	private static String JOB_GROUP_NAME = "JOBGROUP_NAME";
	private static String TRIGGER_GROUP_NAME = "TRIGGERGROUP_NAME";

	static {
		try {
			log.debug("addGlobalJobListener:" + SimpleJobListener.class.getName());
			//加入监听器，监听或记录任务的执行情况
			schedulerFactory.getScheduler().addGlobalJobListener(new SimpleJobListener());
		} catch (SchedulerException e) {
			log.error(e.getMessage(), e);
			throw new TSharkException(e);
		}
	}

	/**
	 * 增加任务
	 * @param jobName
	 * @param jobClass
	 * @param expression
	 */
	public static void addJob(String jobName, String jobClass, String expression) {
		addJob(jobName, JOB_GROUP_NAME, jobName, TRIGGER_GROUP_NAME, jobClass, expression);
	}

	public static void addJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName, String jobClass,
			String expression) {
		log.debug("addJob:" + jobName);
		try {
			Scheduler scheduler = schedulerFactory.getScheduler();
			JobDetail jobDetail = new JobDetail(jobName, jobGroupName, Class.forName(jobClass));// 任务名，任务组，任务执行类
			// 触发器
			CronTrigger trigger = new CronTrigger(triggerName, triggerGroupName);// 触发器名,触发器组
			trigger.setCronExpression(expression);// 触发器时间设定
			scheduler.scheduleJob(jobDetail, trigger);
			// 启动
			if (!scheduler.isShutdown()) {
				scheduler.start();
			}
		} catch (Exception e) {
			log.error(e.getMessage(), e);
			throw new TSharkException(e);
		}
	}

	/**
	 * 修改任务执行时间
	 * @param triggerName
	 * @param expression
	 */
	public static void modifyJobTime(String triggerName, String expression) {
		modifyJobTime(triggerName, TRIGGER_GROUP_NAME, expression);
	}

	public static void modifyJobTime(String triggerName, String triggerGroupName, String expression) {
		log.debug("modifyJobTime:" + triggerName);
		try {
			Scheduler scheduler = schedulerFactory.getScheduler();
			CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerName, triggerGroupName);
			if (trigger == null) {
				return;
			}
			String oldTime = trigger.getCronExpression();
			if (!oldTime.equalsIgnoreCase(expression)) {
				CronTrigger ct = (CronTrigger) trigger;
				// 修改时间
				ct.setCronExpression(expression);
				// 重启触发器
				scheduler.resumeTrigger(triggerName, triggerGroupName);
			}
		} catch (Exception e) {
			log.error(e.getMessage(), e);
			throw new TSharkException(e);
		}
	}

	/**
	 * 移除任务
	 * @param jobName
	 */
	public static void removeJob(String jobName) {
		removeJob(jobName, JOB_GROUP_NAME, jobName, TRIGGER_GROUP_NAME);
	}

	public static void removeJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName) {
		log.debug("removeJob:" + jobName);
		try {
			Scheduler scheduler = schedulerFactory.getScheduler();
			scheduler.pauseTrigger(triggerName, triggerGroupName);// 停止触发器
			scheduler.unscheduleJob(triggerName, triggerGroupName);// 移除触发器
			scheduler.deleteJob(jobName, jobGroupName);// 删除任务
		} catch (Exception e) {
			log.error(e.getMessage(), e);
			throw new TSharkException(e);
		}
	}

	/**
	 * 停止任务
	 * @param jobName
	 */
	public static void pauseJob(String jobName) {
		pauseJob(jobName, JOB_GROUP_NAME);
	}

	public static void pauseJob(String jobName, String jobGroupName) {
		log.debug("pauseJob:" + jobName);
		try {
			Scheduler scheduler = schedulerFactory.getScheduler();
			scheduler.pauseJob(jobName, jobGroupName);
		} catch (Exception e) {
			log.error(e.getMessage(), e);
			throw new TSharkException(e);
		}
	}

	/**
	 * 立即执行任务
	 * @param jobName
	 * @param dataMap
	 */
	public static void execJob(String jobName,JobDataMap dataMap) {
		execJob(jobName, JOB_GROUP_NAME,dataMap);
	}

	public static void execJob(String jobName) {
		execJob(jobName, JOB_GROUP_NAME,new JobDataMap());
	}

	public static void execJob(String jobName, String jobGroupName,JobDataMap dataMap) {
		log.debug("execJob:" + jobName);
		try {
			Scheduler scheduler = schedulerFactory.getScheduler();
			scheduler.triggerJob(jobName, jobGroupName,dataMap);
		} catch (Exception e) {
			log.error(e.getMessage(), e);
			throw new TSharkException(e);
		}
	}

	/**
	 * 恢复任务
	 * @param jobName
	 */
	public static void resumeJob(String jobName) {
		resumeJob(jobName, JOB_GROUP_NAME);
	}

	public static void resumeJob(String jobName, String jobGroupName) {
		log.debug("resumeJob:" + jobName);
		try {
			Scheduler scheduler = schedulerFactory.getScheduler();
			scheduler.resumeJob(jobName, jobGroupName);
		} catch (Exception e) {
			log.error(e.getMessage(), e);
			throw new TSharkException(e);
		}
	}

	/**
	 * 启动所有定时任务
	 */
	public static void startJobs() {
		log.debug("startJobs");
		try {
			Scheduler scheduler = schedulerFactory.getScheduler();
			scheduler.start();
		} catch (Exception e) {
			log.error(e.getMessage(), e);
			throw new TSharkException(e);
		}
	}

	/**
	 * 关闭所有定时任务
	 */
	public static void shutdownJobs() {
		log.debug("shutdownJobs");
		try {
			Scheduler scheduler = schedulerFactory.getScheduler();
			if (!scheduler.isShutdown()) {
				scheduler.shutdown();
			}
		} catch (Exception e) {
			log.error(e.getMessage(), e);
			throw new TSharkException(e);
		}
	}
}

任务监听器

/**
 * 定时任务全局监听器，负责监听和更新任务执行状态及结果
 */
public class SimpleJobListener implements JobListener {
	protected Logger log = LoggerFactory.getLogger(ScheduleJobEngine.class);


	public SimpleJobListener() {
		
	}

	@Override
	public String getName() {
		return "SimpleJobListener";
	}

	@Override
	public void jobExecutionVetoed(JobExecutionContext jobCtx) {
	}

	@Override
	public void jobToBeExecuted(JobExecutionContext jobCtx) {
		String jobId = jobCtx.getJobDetail().getName();
		log.debug("jobToBeExecuted:" + jobId);
	}

	@Override
	public void jobWasExecuted(JobExecutionContext jobCtx, JobExecutionException jobExp) {
		try {
			doJobWasExecuted(jobCtx, jobExp);
		} catch (Exception e) {
			log.error(e.getMessage(), e);
		}
	}

	protected void doJobWasExecuted(JobExecutionContext jobCtx, JobExecutionException jobExp) throws Exception {
		//记录任务执行结果
	}


}