参考:http://blog.csdn.net/seven_3306/article/details/17098493
http://lavasoft.blog.51cto.com/62575/181907/
Quartz是Java版开源定时调度器,功能强大,使用方便。。
一、核心概念
1.Job:表示一个作业/任务,要执行的具体内容。此接口中只有一个方法void execute(JobExecutionContext context),自定义任务时需要实现此接口的execute方法。
2.JobDetail:JobDetail表示一个具体的可执行的调度程序,Job是这个可执行程调度程序所要执行的内容,另外JobDetail还包含了这个任务调度的方案和策略。
3.Trigger:作业执行的触发器,用于定义作业调度如何触发。比如每一小时定时触发一次。有SimpleTrigger和CronTrigger两种类型
4.Scheduler:代表一个调度容器,负责作业/任务调度,一个调度容器中可以注册多个JobDetail和Trigger。当Trigger与JobDetail组合,就可以被Scheduler容器调度了。
5.SchedulerListener:调度器的监听器。
6.Triggerlistener:触发器的监听器。
7.JobListener:job的监听器。
8.ListenerManager:监听器管理类,用于添加,移除,设置监听器等。比如scheduler.getListenerManager.addJobListener(JobListener joblistener,Matcher<JobKey> matcher);
9.Matcher:用于匹配监听器。
10.JobBuilder:Job生成的工具类,用于定义、构造JobDetail的实例。
11.TriggerBuilder:Trrigger构造的工具类,用于定义、构造Trigger的实例。
12.JobKey:Job的识别键,封装jobName和jobGruopName。
13.TriggerKey:类似JobKey,Trigger的识别键,封装triggerName和triggerGruopName。
二、示例:
http://lavasoft.blog.51cto.com/62575/181907/
Quartz是Java版开源定时调度器,功能强大,使用方便。。
一、核心概念
1.Job:表示一个作业/任务,要执行的具体内容。此接口中只有一个方法void execute(JobExecutionContext context),自定义任务时需要实现此接口的execute方法。
2.JobDetail:JobDetail表示一个具体的可执行的调度程序,Job是这个可执行程调度程序所要执行的内容,另外JobDetail还包含了这个任务调度的方案和策略。
3.Trigger:作业执行的触发器,用于定义作业调度如何触发。比如每一小时定时触发一次。有SimpleTrigger和CronTrigger两种类型
4.Scheduler:代表一个调度容器,负责作业/任务调度,一个调度容器中可以注册多个JobDetail和Trigger。当Trigger与JobDetail组合,就可以被Scheduler容器调度了。
5.SchedulerListener:调度器的监听器。
6.Triggerlistener:触发器的监听器。
7.JobListener:job的监听器。
8.ListenerManager:监听器管理类,用于添加,移除,设置监听器等。比如scheduler.getListenerManager.addJobListener(JobListener joblistener,Matcher<JobKey> matcher);
9.Matcher:用于匹配监听器。
10.JobBuilder:Job生成的工具类,用于定义、构造JobDetail的实例。
11.TriggerBuilder:Trrigger构造的工具类,用于定义、构造Trigger的实例。
12.JobKey:Job的识别键,封装jobName和jobGruopName。
13.TriggerKey:类似JobKey,Trigger的识别键,封装triggerName和triggerGruopName。
二、示例:
import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import java.time.LocalTime;
import java.util.concurrent.TimeUnit;
@DisallowConcurrentExecution
public class EasyJob implements Job {
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
System.out.println(LocalTime.now() + " Hello, easy job!");
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(LocalTime.now() + " end easy job!");
}
}
注意,这里的DisallowConcurrentExecution注解表示不允许EasyJob并行执行,即如果当前job还在运行,那么下一个job只能延时运行。
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.matchers.KeyMatcher;
import java.util.Date;
import java.util.Properties;
import static org.quartz.SimpleScheduleBuilder.simpleSchedule;
public class QuartzTest {
private Scheduler scheduler = null;
public Scheduler init() {
if (scheduler == null) {
try {
//通过SchedulerFactory获取一个调度器实例
scheduler = StdSchedulerFactory.getDefaultScheduler();
// 此处修改修改可以设置监听器,以下几个方法没有指定matcher,那么都是全局的,针对所有的
// scheduler.getListenerManager().addJobListener(new MonitorJobListener());
// scheduler.getListenerManager().addSchedulerListener(new MonitorSchedulerListener());
// scheduler.getListenerManager().addTriggerListener(new MonitorTriggerListener());
} catch (SchedulerException e) {
e.printStackTrace();
}
}
return scheduler;
}
/**
* 此方法可以设置quartz属性,比如misfire,threadCount等属性
* @return
*/
public Scheduler getScheduler(Properties props) {
if (scheduler == null) {
try {
/* props = new Properties();
props.put(StdSchedulerFactory.PROP_THREAD_POOL_CLASS,
"org.quartz.simpl.SimpleThreadPool");
// quartz的线程数,同时运行的线程数
props.put("org.quartz.threadPool.threadCount", "8");
// trigger过期1小时内还有效
props.put("org.quartz.jobStore.misfireThreshold", "60*60*1000");
*/
StdSchedulerFactory factory = new StdSchedulerFactory();
factory.initialize(props);
scheduler = factory.getScheduler();
} catch (SchedulerException e) {
e.printStackTrace();
}
}
return scheduler;
}
public void addJobListener(JobKey jobKey, JobListener jobListener) throws SchedulerException {
Matcher<JobKey> matcher = KeyMatcher.keyEquals(jobKey);
try {
this.scheduler.getListenerManager().addJobListener(jobListener, matcher);
} catch (SchedulerException e) {
e.printStackTrace();
throw e;
}
}
public void addTriggerListener(TriggerKey triggerkey, TriggerListener triggerListener)
throws SchedulerException {
Matcher<TriggerKey> matcher = KeyMatcher.keyEquals(triggerkey);
try {
this.scheduler.getListenerManager().addTriggerListener(triggerListener, matcher);
} catch (SchedulerException e) {
e.printStackTrace();
throw e;
}
}
/**
* cron任务
* @param jobKey
* @param triggerKey
* @param cronExpression
* @param jobClass
*/
public void scheduleCronJob(JobKey jobKey, TriggerKey triggerKey, String cronExpression,
Class<? extends Job> jobClass) {
//通过过JobDetail封装jobClass,同时指定Job在Scheduler中所属jobKey
JobDetail jobDetail = JobBuilder.newJob(jobClass)
.withIdentity(jobKey).build();//.withIdentity("myJob", "myJobGroup")
// // Build JobDetail instance.
// JobDetailImpl jdi = new JobDetailImpl();
// jdi.setName(jobKey.getName());
// jdi.setGroup(jobKey.getGroup());
// jdi.setJobClass(jobClass);
// jdi.setDurability(true);
// jdi.getJobDataMap().put("methodInvoker", this);
//创建一个CronTrigger实例
CronTrigger trigger = TriggerBuilder.newTrigger()
.withIdentity(triggerKey).forJob(jobDetail)
.withSchedule(CronScheduleBuilder.cronSchedule(cronExpression))
.build();
try {
//注册并进行调度
this.scheduler.scheduleJob(jobDetail, trigger);
} catch (SchedulerException e) {
e.printStackTrace();
}
// //修改时间
// trigger.setCronExpression(time);
// //重启触发器
// scheduler.resumeTrigger(triggerKey);
}
public void scheduleSimpleJob(JobKey jobKey, TriggerKey triggerKey, Class<? extends Job> jobClass) {
//通过过JobDetail封装jobClass,同时指定Job在Scheduler中所属jobKey
JobDetail jobDetail = JobBuilder.newJob(jobClass)
.withIdentity(jobKey).build();//.withIdentity("myJob", "myJobGroup")
//SimpleTrigger
SimpleTrigger trigger = TriggerBuilder.newTrigger()
.withIdentity(triggerKey)
.withSchedule(simpleSchedule()
.withIntervalInSeconds(2)//重复间隔
.withRepeatCount(3)//重复次数
)
.startAt(new Date()).build();
try {
//注册并进行调度
this.scheduler.scheduleJob(jobDetail, trigger);
} catch (SchedulerException e) {
e.printStackTrace();
}
}
/**
* 设置立刻生成
* @param jobKey
* @param jobClass
*/
public void triggerJobNow(JobKey jobKey, Class<? extends Job> jobClass) {
JobDetail jobDetail = null;
jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobKey)
.storeDurably(true).build();
try {
this.scheduler.addJob(jobDetail, true);
} catch (SchedulerException e) {
e.printStackTrace();
}
try {
this.scheduler.triggerJob(jobKey);
} catch (SchedulerException e) {
e.printStackTrace();
}
}
/**
* 启动调度器
*/
public void start() {
try {
this.scheduler.start();
} catch (SchedulerException e) {
e.printStackTrace();
}
}
public void stop() {
try {
//调度器停止运行
this.scheduler.shutdown(true);
} catch (SchedulerException e) {
e.printStackTrace();
}
}
public void removeJob(TriggerKey triggerKey, JobKey jobKey)
throws SchedulerException {
scheduler.pauseTrigger(triggerKey);//停止触发器
scheduler.unscheduleJob(triggerKey);//移除触发器
scheduler.deleteJob(jobKey);//删除任务
}
public static void main(String[] args) {
QuartzTest test = new QuartzTest();
JobKey jobKey = new JobKey("myJob", "myJobGroup");
test.init();
try {
test.addJobListener(jobKey, new JobListener() {
@Override
public String getName() {
return "jobListener";
}
@Override
public void jobToBeExecuted(JobExecutionContext context) {
System.out.println("jobToBeExecuted");
}
@Override
public void jobExecutionVetoed(JobExecutionContext context) {
System.out.println("jobExecutionVetoed");
}
@Override
public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) {
System.out.println("jobWasExecuted");
}
});
} catch (SchedulerException e) {
e.printStackTrace();
}
// test.triggerJobNow(jobKey, EasyJob.class);
test.scheduleSimpleJob(jobKey, new TriggerKey("myTrigger", "myTriggerGroup"), EasyJob.class);
test.start();
// TriggerKey triggerKey = new TriggerKey("myTrigger", "myTriggerGroup");
// //每隔10S执行一次
// String cronExpression = "0/10 * * * * ?";
// test.init();
// test.scheduleCronJob(jobKey, triggerKey, cronExpression, HelloJob.class);
// test.start();
}
}