java定时器_iphone如何定时发送短信

定时任务(如：定时发送短信邮箱等)

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

学习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();