定时任务（如：定时发送短信信箱等）

前面整过一个任务调度，它是固定在每天几点等执行，对于要手动加入的时间的定时发送短信不适用。

学习quartz首先了解三个概念：

调度器：负责调度作业和触发器；

触发器：设置作业执行的时间、参数、条件等；（简单触发器和Cron触发器）

作业：定时任务内容，被执行的程序；

下载必要的jar包，将quartz-x.x.x.jar 和core 和/或 optional 文件夹中的 jar 文件放在项目的文件夹或项目的类路径中 Quartz的几个核心的接口和类为：

Job接口：自己写的“定时程序”实现此接口的void execute(JobExecutionContext arg0)方法,Job还有一类为有状态的StatefulJob接口，假如我们需要在上一个作业执行完后，根据其执行结果再进行下次作业的执行，则需要 实现此接口。

Trigger抽象类：调度类(Scheduler)在时间到时调用此类，再由trigger类调用指定的定时程序。

Quertz中提供了两类触发器为：SimpleTrigger,CronTrigger。前者用于实现比较简单的定时功能，例如几点开始，几点结束，隔 多长时间执行，共执行多少次等，后者提供了使用表达式来描述定时功能，因此适用于比较复杂的定时描述，例如每个月的最后一个周五，每周的周四等。

JobDetail类：具体某个定时程序的具体描述，包括Name,Group,JobDataMap等。

JobExecutionContext类：定时程序执行的run-time的上下文环境，用于得到当前执行的Job的名字，配置的参数等。

JobDataMap类：用于描述一个作业的参数，参数可以为任何基本类型例如String,float等，也可为某个对象的引用.

JobListener,TriggerListener接口：用于监听触发器状态和作业扫行状态，在特写状态执行相应操纵。

JobStore类：在哪里执行定进程序，可选的有在内存中，在数据库中。

开始：边看例题边学习，首先从简单触发器开始…… 1、作业通过实现org.quartz.job接口，可以使 Java 类变成可执行的。这个类用一条非常简单的输出语句覆盖了execute(JobExecutionContext context)方法。 import java.util.Date;

import org.quartz.Job;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

public class SimpleQuartzJob implements Job {

public SimpleQuartzJob() {

}

public void execute(JobExecutionContext context) throws JobExecutionException {

System.out.println("In SimpleQuartzJob - executing its JOB at "

+ new Date() + " by " + context.getTrigger().getName());

}

} 2、触发器和调度器

public void task() throws SchedulerException

{

//通过SchedulerFactory来获取一个调度器

SchedulerFactory schedulerFactory = new StdSchedulerFactory();

Scheduler scheduler = schedulerFactory.getScheduler();

//引进作业程序

JobDetail jobDetail =

new JobDetail("jobDetail-s1", "jobDetailGroup-s1", SimpleQuartzJob.class);

//new一个触发器

SimpleTrigger ***Trigger =

new SimpleTrigger("***Trigger", "triggerGroup-s1");

//设置作业启动时间

long ctime = System.currentTimeMillis();

***Trigger.setStartTime(new Date(ctime));

//设置作业执行间隔

***Trigger.setRepeatInterval();

//设置作业执行次数

***Trigger.setRepeatCount(10);

//设置作业执行优先级默以为5

//***Trigger.setPriority(10);

//作业和触发器设置到调度器中

scheduler.scheduleJob(jobDetail, ***Trigger);

//启动调度器

scheduler.start();

}

一个简单的quartz任务就完成了。

以下是我根据上边的介绍写的定时发送消息的代码：

PushJob.java

package cn.net.inch.mb.task;

import java.text.SimpleDateFormat;

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

import cn.net.inch.mb.domain.Message;
import cn.net.inch.mb.service.IMessageService;

public class PushJob implements Job {

	// private static IMessageService messageService = null;

	@Override
	public void execute(JobExecutionContext context)
			throws JobExecutionException {
		System.out
				.println("-----------------------定时发送----------------------------------------------");
		Object object = context.getJobDetail().getJobDataMap().get("message");
		Object msgService = context.getJobDetail().getJobDataMap().get(
				"msgService");
		Message msgMessage = (Message) object;
		IMessageService messageService = (IMessageService) msgService;
		String title = msgMessage.getTitle();
		System.out.println("定时消息启动，消息标题为:" + title + "消息ID"
				+ msgMessage.getId());
		String content = msgMessage.getContent();
		SimpleDateFormat tempDate = new SimpleDateFormat("yyyy-MM-dd" + " "
				+ "HH:mm:ss");
		String pushTime = tempDate.format(new java.util.Date());

		System.out.println(" ad msgMessage:" + (msgMessage == null));

		try {
			System.out.println("进入推送");
			messageService.pushMsg(title, content, pushTime);
			msgMessage.setStatus("1");
			messageService.saveOrUpdateMessage(msgMessage);
		} catch (Exception e) {
			msgMessage.setStatus("3");
			messageService.saveOrUpdateMessage(msgMessage);
			e.printStackTrace();
		}

		System.out
				.println("-----------------------定时发送结束----------------------------------------------");
	}

}

?2.SimpleScheduler.java

package cn.net.inch.common.push;

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

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SimpleTrigger;
import org.quartz.impl.StdSchedulerFactory;

import cn.net.inch.mb.service.IMessageService;
import cn.net.inch.mb.task.PushJob;

public class SimpleScheduler {

	private Scheduler scheduler = null;

	private SimpleScheduler() throws SchedulerException {
		scheduler = createScheduler();
	}

	private static SimpleScheduler instance;

	public static synchronized SimpleScheduler getSimpleScheduler()
			throws SchedulerException {
		if (instance == null) {
			instance = new SimpleScheduler();
		}
		return instance;
	}

	static Log logger = LogFactory.getLog(SimpleScheduler.class);

	public static void main(String[] args) throws SchedulerException,
			ParseException {
		SimpleScheduler simple = new SimpleScheduler();
		try {
			// Create a Scheduler and schedule the Job
			Scheduler scheduler = simple.createScheduler();

			String ddd = "2012-01-13 15:56:30";
			Date d = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(ddd);

			// simple.scheduleJob(d, PushJob.class);
			scheduler.start();
			logger.info("Scheduler started at " + new Date());
		} catch (SchedulerException ex) {
			logger.error(ex);
		}

	}

	public Scheduler createScheduler() throws SchedulerException {// 创建调度器
		return StdSchedulerFactory.getDefaultScheduler();
	}

	public void scheduleJob(Date date, Object object, Long id,
			IMessageService messageService) throws SchedulerException,
			ParseException {
		String dateStr = new SimpleDateFormat().format(date);
		dateStr = id + dateStr;
		System.out.println("调度类名称为：" + dateStr);

		JobDetail jobDetail = new JobDetail(dateStr, Scheduler.DEFAULT_GROUP,
				PushJob.class);
		// jobDetail.getJobDataMap().put("SCAN_DIR", "D:\\Tomcat\\conf");
		jobDetail.getJobDataMap().put("message", object);
		jobDetail.getJobDataMap().put("msgService", messageService);

		SimpleTrigger trigger = new SimpleTrigger(dateStr, "triggerGroup-s1");
		// TriggerUtils.makeSecondlyTrigger(3);// 每10秒触发一次
		// trigger.setName("scanTrigger");
		/*
		 * String ddd = "2012-01-05 19:22:00"; Date d = new
		 * SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(ddd);
		 * trigger.setStartTime(d);// 设置第一次触发时间
		 */
		/*
		 * String ddd = "2012-01-06 19:00:00"; Date d = new
		 * SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(ddd);
		 */
		trigger.setStartTime(date);
		scheduler.scheduleJob(jobDetail, trigger);
		System.out.println("创建scheduler");

		// removeJob("ScanDirectory", Scheduler.DEFAULT_GROUP);
	}
	/*
	 * public boolean removeJob(String jobName, String group) throws
	 * SchedulerException { scheduler.pauseJob(jobName, group); return
	 * scheduler.deleteJob(jobName, group); }
	 */
}

? Action触发：

jobName = new SimpleDateFormat().format(messageList.get(i)
							.getSendTime());
					jobName = messageList.get(i).getId() + jobName;
					Scheduler sched = gSchedulerFactory.getScheduler();
					sched.deleteJob(jobName, Scheduler.DEFAULT_GROUP);
					Scheduler scheduler = simple.createScheduler();
					simple.scheduleJob(messageList.get(i).getSendTime(),
							messageList.get(i), messageList.get(i).getId(),
							messageService);
					scheduler.start();

?