quartz实现定时任务

在项目中我们经常会用到定时任务去处理某件事情，会在恰当的时机去终止定时任务等一系列东西。、

算是一个公共方法吧

1. 导入jar包

<dependency>
	<groupId>org.quartz-scheduler</groupId>
	<artifactId>quartz</artifactId>
	<version>2.2.1</version>
</dependency>

2. 工具类

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.triggers.SimpleTriggerImpl;

import com.ts.entity.JobDes;

/**
 * 定时任务管理类
 * 
 * @author 郭鹏飞
 *
 */
public class JobUtil {

	private static SchedulerFactory schedulerFactory = new StdSchedulerFactory();
	private static String JOB_GROUP_NAME = "EXTJWEB_JOBGROUP_NAME"; // 任务组名
	private static String TRIGGER_GROUP_NAME = "EXTJWEB_TRIGGERGROUP_NAME"; // 触发器组名
	private static String TRIGGER_NAME = "EXTJWEB_TRIGGE_NAME"; // 触发器名

	/**
	 * @Description: 添加一个定时任务
	 * 
	 * @param jobName
	 *            任务名
	 * @param jobClass
	 *            任务
	 * @param second
	 *            时间设置(秒数)
	 */
	public static int addJob(String jobName, Class<? extends Job> jobClass, Object jobDes, int seconds, Date date) {
		try {
			Scheduler sched = schedulerFactory.getScheduler();
			JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
			if (sched.checkExists(jobKey)) {
				return 0;
			}
			// 任务名，任务组，任务执行类
			JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, JOB_GROUP_NAME).build();
			jobDetail.getJobDataMap().put("jobDes", jobDes);
			SimpleTriggerImpl simpleTrigger = new SimpleTriggerImpl();
			simpleTrigger.setName(jobName);
			simpleTrigger.setGroup(JOB_GROUP_NAME);
			// 什么时候开始执行
			simpleTrigger.setStartTime(new Date(date.getTime() + 1000 * seconds));
			// 间隔时间
			simpleTrigger.setRepeatInterval(1000 * seconds);
			// 最多执行次数 默认执行一次
			simpleTrigger.setRepeatCount(0);
			// 调度容器设置JobDetail和Trigger
			sched.scheduleJob(jobDetail, simpleTrigger);

			// 启动
			if (!sched.isShutdown()) {
				sched.start();
			}
			return 1;
		} catch (Exception e) {
			return 2;
		}
	}

	/**
	 * @Description: 修改一个任务的触发时间
	 * 
	 * @param jobName
	 *            任务名
	 * @param corn
	 *            时间设置
	 */
	public static void modifyJobTime(String jobName, String corn) {
		try {
			Scheduler sched = schedulerFactory.getScheduler();
			TriggerKey triggerKey = TriggerKey.triggerKey(TRIGGER_NAME + jobName, TRIGGER_GROUP_NAME);
			CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);
			if (trigger == null) {
				return;
			}

			String oldTime = trigger.getCronExpression();
			if (!oldTime.equalsIgnoreCase(corn)) {
				/** 方式一 ：调用 rescheduleJob 开始 */
				// 触发器
				TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
				// 触发器名,触发器组
				triggerBuilder.withIdentity(TRIGGER_NAME + jobName, TRIGGER_GROUP_NAME);
				triggerBuilder.startNow();
				// 触发器时间设定
				triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(corn));
				// 创建Trigger对象
				trigger = (CronTrigger) triggerBuilder.build();
				// 方式一 ：修改一个任务的触发时间
				sched.rescheduleJob(triggerKey, trigger);
				/** 方式一 ：调用 rescheduleJob 结束 */
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * @Description: 移除一个任务
	 * 
	 * @param jobName
	 *            任务名
	 */
	public static void removeJob(String jobName) {
		try {
			Scheduler sched = schedulerFactory.getScheduler();

			TriggerKey triggerKey = TriggerKey.triggerKey(TRIGGER_NAME + jobName, TRIGGER_GROUP_NAME);

			sched.pauseTrigger(triggerKey);// 停止触发器
			sched.unscheduleJob(triggerKey);// 移除触发器
			sched.deleteJob(JobKey.jobKey(jobName, JOB_GROUP_NAME));// 删除任务
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * @Description:启动所有定时任务
	 */
	public static void startJobs() {
		try {
			Scheduler sched = schedulerFactory.getScheduler();
			sched.start();
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * @Description:关闭所有定时任务
	 */
	public static void shutdownJobs() {
		try {
			Scheduler sched = schedulerFactory.getScheduler();
			if (!sched.isShutdown()) {
				sched.shutdown();
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	public static void main(String[] args) throws Exception {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String eqNo ="3243242341236547";
		JobDes jobDes = new JobDes();
		jobDes.setJobDescription("SBOX_CLOSE_TIMEOUT");
		jobDes.setSboxNo(eqNo);
		jobDes.setCloseTime(sdf.format(new Date()));
		JobUtil.addJob(eqNo, JobBack.class, jobDes, 10, new Date());
	}
}

3. 回调任务

回调任务的执行方法，需要实现Job接口

package com.ts.util;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.nutz.ioc.loader.annotation.Inject;
import org.nutz.ioc.loader.annotation.IocBean;
import org.nutz.mvc.Mvcs;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import com.ts.entity.JobDes;
import com.ts.service.WarnService;

/**
 * 任务回调方法
 * 
 * @author 郭鹏飞
 *
 */
public class JobBack implements Job {

	private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");

	@Override
	public void execute(JobExecutionContext context) throws JobExecutionException {
		// 得到添加任务中的参数
		JobDes jobDes = (JobDes) context.getMergedJobDataMap().get("jobDes");
		System.out.println("回调的参数为："+jobDes);
		try {
			backHandle(jobDes);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 任务回调处理
	 * 
	 * @param jobDescription
	 */
	public void backHandle(JobDes jobDes) throws Exception{
		System.out.println(sdf.format(new Date())+"执行回调任务");
		if (jobDes == null)
			return;
		String jobDescription = jobDes.getJobDescription();
		if (jobDescription == null || jobDescription.equals(""))
			return;
		// sbox掉线超时
		if (jobDescription.equals("SBOX_CLOSE_TIMEOUT")) {
			//又是一个执行方法
		}
		System.out.println(sdf.format(new Date())+"回调任务执行结束");
	}

}

4. 一个传参的实体类

package com.ts.entity;

/**
 * 任务调度参数类
 * @author 郭鹏飞
 *
 */
public class JobDes {
	private String jobDescription; //任务描述
	private String camip; //相机ip
	private String sboxNo; //sbox编号
	private String closeTime; //掉线时间
	private String beginTime; //开始重连时间
	private Integer times; //重连次数
	private String recMail; //接收邮件邮箱
	private String topic; //邮件主题
	private String msg; //邮件内容
	
	public String getJobDescription() {
		return jobDescription;
	}
	public void setJobDescription(String jobDescription) {
		this.jobDescription = jobDescription;
	}
	public String getCamip() {
		return camip;
	}
	public void setCamip(String camip) {
		this.camip = camip;
	}
	public String getSboxNo() {
		return sboxNo;
	}
	public void setSboxNo(String sboxNo) {
		this.sboxNo = sboxNo;
	}
	public String getCloseTime() {
		return closeTime;
	}
	public void setCloseTime(String closeTime) {
		this.closeTime = closeTime;
	}
	public String getBeginTime() {
		return beginTime;
	}
	public void setBeginTime(String beginTime) {
		this.beginTime = beginTime;
	}
	public Integer getTimes() {
		return times;
	}
	public void setTimes(Integer times) {
		this.times = times;
	}
	public String getRecMail() {
		return recMail;
	}
	public void setRecMail(String recMail) {
		this.recMail = recMail;
	}
	public String getTopic() {
		return topic;
	}
	public void setTopic(String topic) {
		this.topic = topic;
	}
	public String getMsg() {
		return msg;
	}
	public void setMsg(String msg) {
		this.msg = msg;
	}
}