定时器3——定时框架Quartz2

1. 资源SchedulerFactory

1.1 介绍

        Quartz以模块方式架构,因此,要使它运行,几个组件必须很好的咬合在一起,幸运的是,已经有了一些现存的助手可以完成这些工作,所有的Scheduler实例由SchedulerFactory创建。

        Quartz的三个核心概念:调度器、任务、触发器,三者之间的关系

SchedulerFactory ——> Scheduler ——> Trigger/job

        SchedulerFactory 接口,有两个子类,一个是StdSchedulerFactory,另一个是DirectSchedulerFactory,我们之前用的都是StdSchedulerFactory。

        一个作业,比较重要的三要素是Scheduler、JobDetail、Trigger,而Trigger对于Job而言就好比一个驱动器,没有触发器来定时驱动作业,作业就无法运行,对于Job而言,一个Job可以对应多个Trigger,单对于Trigger而言,一个Trigger只能对应一个Job,所以一个Trigger只能被指派给一个job,所以如果我们需要一个复杂的触发计划,可以创建多个Trigger并指派他们给同一个job。

1.2 Scheduler的创建方式

1.2.1 StdSchedulerFactory

        Quartz默认的SchedulerFactory。

1. 使用一组参数(java.util.Properties)来创建和初始化Quartz调度器。

2. 配置参数一般存储在quartz.properties文件中。

3. 调用getScheduler方法就能创建和初始化调度器对象。例如:

// Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
SchedulerFactory s = new StdSchedulerFactory();
Scheduler scheduler = s.getScheduler();

注意:看源码知道,StdSchedulerFactory.getDefaultScheduler();内部实现就是用的该方式。

1.2.2 Scheduler的API

1. 获取调度器开始时间

Date startDate = scheduler.scheduleJob(jobDetail, trigger);

2. 启动任务调度

scheduler.start();

3. 任务调度挂起、暂停

scheduler.standby();

4. 关闭任务调度

scheduler.shutdown();

scheduler.shutdown(true):表示等待所有正在执行的job执行完毕之后,再关闭Scheduler

scheduler.shutdown(false):表示直接关闭Scheduler

1.3 DirectSchedulerFactory

        DirectSchedulerFactory是对SchedulerFactory的直接实现,通过它可以直接构建Scheduler、Threadpool等。

DirectSchedulerFactory instance = DirectSchedulerFactory.getInstance();
Scheduler scheduler1 = instance.getScheduler();

2. Quartz.properties配置文件

默认路径:quartz-2.3.0中的org.quartz.properties

定时器3——定时框架Quartz2

 注意:如果不想用默认的配置文件,我们也可以在资源目录下新建quartz.properties配置文件,在该文件下写自己的配置信息

2.1 配置文件详解

# Default Properties file for use by StdSchedulerFactory
# to create a Quartz Scheduler Instance, if a different
# properties file is not explicitly specified.
#

org.quartz.scheduler.instanceName: DefaultQuartzScheduler
org.quartz.scheduler.rmi.export: false
org.quartz.scheduler.rmi.proxy: false
org.quartz.scheduler.wrapJobExecutionInUserTransaction: false

org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount: 10
org.quartz.threadPool.threadPriority: 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true

org.quartz.jobStore.misfireThreshold: 60000

org.quartz.jobStore.class: org.quartz.simpl.RAMJobStore

2.1.1 调度器属性

1. org.quartz.scheduler.instanceName:用来区分特定的调度器实例,可以按照功能用途给调度器起名字。

2. org.quartz.scheduler.instanceId:也是用来区分调度器实例的,允许是任何的字符串,但是这个值必须在所有的调度器实例中是唯一的,尤其在一个集群环境中,作为集群的唯一key。

注意:如果想Quartz自动生成该值,可以将其设置成AUTO。

例如: org.quartz.scheduler.instanceId:AUTO

2.1.2 线程池属性

1. threadCount:处理job的线程个数,至少为1,但是最多的话最好不要超过100个,在多数机器上超过100个就显得相当不实用,特别是在job执行时间较长的情况下。

2. threadPriority:线程的优先级, 优先级高的线程比优先级的线程先得到执行。最小为1,最大为10,默认为5

3. threadPool.class:一个实现了org.quartz.ThreadPool接口的类,Quartz自带的线程池实现类是org.quartz.smpl.SimpleThreadPool

2.1.3 作业存储设置

描述了在调度器实例的生命周期中,Job和Trigger信息是如何被存储的

org.quartz.jobStore.class: org.quartz.simpl.RAMJobStore

2.1.4 插件配置

满足特定需求用到的Quartz插件的配置

2. 监听器

        Quartz的监听器用于当任务调度中,你所关注事件发生时,能够及时获取这一事件通知。类似于任务执行过程中的邮件、短信提醒。

        Quartz监听器主要有JobListener、TriggerListener、SchedulerListener三种,分别表示任务、触发器、调度器对应的监听器三者使用方式类似。

2.1 全局监听器

全局监听器能接收到所有的Job/Trigger 的事件通知

// 创建一个全局的监听器
scheduler.getListenerManager().addJobListener(new MyJobListener(),EverythingMatcher.allJobs());

2.2 局部监听器

非全局的监听器只能接收到在其上注册的job或trigger的事件,不在其注册的job或trigger则 不会进行监听。

// 创建一个局部监听器
scheduler.getListenerManager().addJobListener(new MyJobListener(),KeyMatcher.keyEquals(JobKey.jobKey("job1", "group1")));

2.3 JobListener

        任务调度过程中,与任务Job相关的事件包括:job开始要执行的提示,job执行完成的提示灯

2.3.1 JobListener接口中的方法与作用

1. getName():用于获取JobListener的名称

2. jobToBeExecuted(JobExecutionContext context):Scheduler在jobDetail将要被执行时调用这个方法

3. jobExecutionVetoed(JobExecutionContext context):Scheduler在jobDetail即将被执行,但又被TriggerListener否决时会调用该方法。

4. jobWasExecuted():Scheduler在JobDetail被执行之后调用该方法。

2.3.2 自定义一个Job监听器

1. 创建监听器类

package cn.bjc.quartz.listener;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobListener;

public class MyJobListener implements JobListener{

	@Override
	public String getName() {
		String name = this.getClass().getSimpleName();
		System.out.println("name = " + name);
		return name;
	}

	@Override
	public void jobToBeExecuted(JobExecutionContext context) {
		String name = context.getJobDetail().getKey().getName();
		System.out.println("Job的名称是:" + name + "   Scheduler在jobDetail将要被执行时调用的方法。");
	}

	@Override
	public void jobExecutionVetoed(JobExecutionContext context) {
		System.out.println("xxx");
	}

	@Override
	public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) {
		System.out.println("yyy");
	}

}

2. 添加监听器

2.1 添加一个全局的监听器

在scheduler.start();之前加上如下代码,EverythingMatcher.allJobs()表示所有的job

scheduler.getListenerManager().addJobListener(new MyJobListener(),EverythingMatcher.allJobs());

2.2 添加一个局部监听器,监听指定的job

scheduler.getListenerManager().addJobListener(new MyJobListener(),KeyMatcher.keyEquals(JobKey.jobKey("job1", "group1")));

完整的调用代码:

package cn.bjc.quartz.main;

import java.util.Date;

import org.quartz.CronScheduleBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.matchers.EverythingMatcher;
import org.quartz.impl.matchers.KeyMatcher;

import cn.bjc.quartz.job.HelloJobListener;
import cn.bjc.quartz.listener.MyJobListener;

public class JobListenerDemo {

	public static void main(String[] args) throws Exception {
		Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
		// 2. 任务实例(JobDetail),通过JobBuilder创建
		JobDetail jobDetail = JobBuilder.newJob(HelloJobListener.class)
							.withIdentity("job1", "group1")
							.usingJobData("msg", "日志打印")
							.usingJobData("count", 0)
							.build();
		// 3. 触发器(Trigger)
		Trigger trigger = TriggerBuilder.newTrigger()
							.withIdentity("trigger1", "group1")
							.startNow()
							.withSchedule(CronScheduleBuilder.cronSchedule("* * * * * ?"))	// 日历每秒执行
							.build();
		
		Date startDate = scheduler.scheduleJob(jobDetail, trigger);
		
		// 创建一个全局的监听器
		// scheduler.getListenerManager().addJobListener(new MyJobListener(),EverythingMatcher.allJobs());
		
		// 创建一个局部监听器
		scheduler.getListenerManager().addJobListener(new MyJobListener(),KeyMatcher.keyEquals(JobKey.jobKey("job1", "group1")));
		
		// 启动
		scheduler.start();
	}

}

2.4 TriggerListener

        任务调度过程中,与触发器Trigger相关的事件包括:触发器触发、触发器未正常触发、触发器完成等。

2.4.1 TriggerListener接口定义的方法

1. getName():用于获取触发器名称

2. triggerField(Trigger trigger,JobExecutionContext context):当与监听器相关联的Trigger被触发,Job上的execute方法将被执行时,Scheduler就调用该方法。

3. vetoJobExecution(Trigger trigger,JobExecutionContext context):在Trigger触发后,job将要被执行时由Scheduler调用这个方法,TriggerListener给了一个选择去否决Job的执行。假如这个方法返回true,这个Job将不会为此次Trigger触发而得到执行。

4. triggerMisfired(Trigger trigger):Scheduler调用这个方法是在Trigger错过触发时,你应该关注此方法中持续时间长的逻辑;在出现许多错过触发的Trigger时,长逻辑会导致骨牌效应,所以,你应当尽量的保持这上方法尽量的小。

5. triggerComplete(Trigger trigger):Trigger被触发并且完成了Job的执行时,Scheduler调用这个方法。

2.4.2 自定义一个TriggerListener监听器

1. 创建监听器

MyTriggerListener.java

package cn.bjc.quartz.listener;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobListener;
import org.quartz.Trigger;
import org.quartz.Trigger.CompletedExecutionInstruction;
import org.quartz.TriggerListener;

public class MyTriggerListener implements TriggerListener{

	@Override
	public String getName() {
		String name = this.getClass().getSimpleName();
		System.out.println("触发器的名称是:" + name);
		return name;
	}

	@Override
	public void triggerFired(Trigger trigger, JobExecutionContext context) {
		String name = trigger.getKey().getName();
		System.out.println(name + "被触发了!");
	}

	@Override
	public boolean vetoJobExecution(Trigger trigger, JobExecutionContext context) {
		String name = trigger.getKey().getName();
		System.out.println(name + "没有被触发!");
		return true;  // true:表示不会执行job的方法。
	}

	@Override
	public void triggerMisfired(Trigger trigger) {
		String name = trigger.getKey().getName();
		System.out.println(name + "错过触发!");
	}

	@Override
	public void triggerComplete(Trigger trigger, JobExecutionContext context,
			CompletedExecutionInstruction triggerInstructionCode) {
		String name = trigger.getKey().getName();
		System.out.println(name + "完成之后触发!");
	}

}

2. 添加监听器

2.1 添加一个全局监听器

// 创建并注册一个全局TriggerListener
scheduler.getListenerManager().addTriggerListener(new MyTriggerListener(),EverythingMatcher.allTriggers());

2.2 添加一个局部监听器

// 创建并注册一个局部TriggerListener
scheduler.getListenerManager().addTriggerListener(new MyTriggerListener(), KeyMatcher.keyEquals(TriggerKey.triggerKey("trigger1")));

完整的调用:

package cn.bjc.quartz.main;

import java.util.Date;
import java.util.concurrent.ScheduledFuture;

import org.quartz.CronScheduleBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.matchers.EverythingMatcher;
import org.quartz.impl.matchers.KeyMatcher;

import cn.bjc.quartz.job.HelloJobListener;
import cn.bjc.quartz.listener.MyJobListener;
import cn.bjc.quartz.listener.MyTriggerListener;

public class TriggerListenerDemo {

	public static void main(String[] args) throws Exception {
		Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
		// 2. 任务实例(JobDetail),通过JobBuilder创建
		JobDetail jobDetail = JobBuilder.newJob(HelloJobListener.class)
							.withIdentity("job1", "group1")
							.usingJobData("msg", "日志打印")
							.usingJobData("count", 0)
							.build();
		// 3. 触发器(Trigger)
		Trigger trigger = TriggerBuilder.newTrigger()
							.withIdentity("trigger1", "group1")
							.startNow()
							.withSchedule(CronScheduleBuilder.cronSchedule("* * * * * ?"))	// 日历每秒执行
							.build();
		
		Date startDate = scheduler.scheduleJob(jobDetail, trigger);
		
		// 创建并注册一个全局TriggerListener
		//scheduler.getListenerManager().addTriggerListener(new MyTriggerListener(),EverythingMatcher.allTriggers());
		
		// 创建并注册一个局部TriggerListener
		scheduler.getListenerManager().addTriggerListener(new MyTriggerListener(), KeyMatcher.keyEquals(TriggerKey.triggerKey("trigger1","group1")));
		
		// 启动
		scheduler.start();
	}

}

2.5 SchedulerListener监听器

        SchedulerListener会在Scheduler的生命周期中关键事件发生时被调用,与Scheduler有关的事件包括:增加一个job/trigger,删除一个job/trigger,scheduler发生严重错误的时候,关闭scheduler。

2.5.1 SchedulerListener接口的方法

1. jobScheduler(Trigger trigger):用于部署JobDetail时调用

2. jobUnscheduled(String triggerName,String triggerGroup):用于卸载JobDetail时调用

3. triggerFinalized(Trigger trigger):当一个trigger来到了再也不会触发的状态的时候调用这个方法。除非这个job已设置成了持久性,否则它就会从Scheduler中移除。

4. triggersPaused(String triggerName,String triggerGroup):Scheduler调用这个方法是发生在一个Trigger或trigger组被暂停的时候。假如Trigger组的话,triggerName参数将为null。

5. triggersResumed(String triggerName,String triggerGroup):Scheduler调用这个方法是发生在一个trigger或trigger组被暂停时。加入是trigger组的话,triggerName参数将为null

6. jobsPaused(String triggerName,String triggerGroup):当一个或一组job被暂停的时候调用

7. jobsResumed(String triggerName,String triggerGroup):当一个或一个组job从暂停上恢复时调用。加入是job组,jobName参数将为null。

8. schedulerError(String msg,SchedulerException cause):在Scheduler正常运行期间,产生一个严重错误的时候调用

9. schedulerStarted():当scheduler开启的时候调用

10. schedulerInStandbyMode():当scheduler处于StandBy模式时,调用该方法。

11. schedulerShutdown():当scheduler停止时调用

12. schedulingDataCleared():当scheduler中的数据被清除的时候调用

2.5.2 Scheduler监听器的使用

1. 自定义Scheduler监听器

package cn.bjc.quartz.listener;

import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.SchedulerException;
import org.quartz.SchedulerListener;
import org.quartz.Trigger;
import org.quartz.TriggerKey;

public class MySchedulerListener implements SchedulerListener{

	@Override
	public void jobScheduled(Trigger trigger) {
		String name = trigger.getKey().getName();
		System.out.println(name + "部署的时候调用!");
	}

	@Override
	public void jobUnscheduled(TriggerKey triggerKey) {
		String name = triggerKey.getName();
		System.out.println(name + "卸载JobDetail时调用!");
	}

	@Override
	public void triggerFinalized(Trigger trigger) {
		String name = trigger.getKey().getName();
		System.out.println(name + "被移除调用!");
	}

	@Override
	public void triggerPaused(TriggerKey triggerKey) {
		String name = triggerKey.getName();
		System.out.println(name + "正在被暂停!");
	}

	@Override
	public void triggersPaused(String triggerGroup) {
		System.out.println("触发器组" + triggerGroup + "正在被暂停!");
	}

	@Override
	public void triggerResumed(TriggerKey triggerKey) {
		String name = triggerKey.getName();
		System.out.println(name + "正在被恢复!");
	}

	@Override
	public void triggersResumed(String triggerGroup) {
		System.out.println("触发器组" + triggerGroup + "正在被恢复!");
	}

	@Override
	public void jobAdded(JobDetail jobDetail) {
		String name = jobDetail.getKey().getName();
		System.out.println(name + "添加工作任务的时候调用!");
	}

	@Override
	public void jobDeleted(JobKey jobKey) {
		String name = jobKey.getName();
		System.out.println(name + "删除工作任务的时候调用!");
	}

	@Override
	public void jobPaused(JobKey jobKey) {
		String name = jobKey.getName();
		System.out.println(name + "暂停工作任务的时候调用!");
	}

	@Override
	public void jobsPaused(String jobGroup) {
		System.out.println("job组" + jobGroup + "暂停的时候调用!");
	}

	@Override
	public void jobResumed(JobKey jobKey) {
		System.out.println("工作任务恢复!");
	}

	@Override
	public void jobsResumed(String jobGroup) {
		System.out.println("工作组任务恢复!");
	}

	@Override
	public void schedulerError(String msg, SchedulerException cause) {
		System.out.println("调用出错,错误信息是:" + msg + "   具体错误原因是:" + cause.getUnderlyingException());
	}

	@Override
	public void schedulerInStandbyMode() {
		System.out.println("调度器被挂起模式的时候调用!");
	}

	@Override
	public void schedulerStarted() {
		System.out.println("调度器开启的时候调用!");
	}

	@Override
	public void schedulerStarting() {
		System.out.println("调度器正在开启的时候调用!");
	}

	@Override
	public void schedulerShutdown() {
		System.out.println("调度器关闭的时候调用!");
	}

	@Override
	public void schedulerShuttingdown() {
		System.out.println("调度器正在关闭的时候调用!");
	}

	@Override
	public void schedulingDataCleared() {
		System.out.println("当scheduler中的数据被清除的时候调用!");
	}

}

2. 添加监听

scheduler.getListenerManager().addSchedulerListener(mySchedulerListener);

调用代码:

package cn.bjc.quartz.main;

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

import cn.bjc.quartz.job.HelloJobListener;
import cn.bjc.quartz.listener.MySchedulerListener;

public class SchedulerListenerDemo {

	public static void main(String[] args) throws Exception {
		Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
		// 2. 任务实例(JobDetail),通过JobBuilder创建
		JobDetail jobDetail = JobBuilder.newJob(HelloJobListener.class)
							.withIdentity("job1", "group1")
							.usingJobData("msg", "日志打印")
							.usingJobData("count", 0)
							.build();
		// 3. 触发器(Trigger)
		Trigger trigger = TriggerBuilder.newTrigger()
							.withIdentity("trigger1", "group1")
							.startNow()
							.withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(5)
									.withRepeatCount(2))	// 5秒后重复执行,只重复执行4次
							.build();
		
		scheduler.scheduleJob(jobDetail, trigger);
		MySchedulerListener mySchedulerListener = new MySchedulerListener();
		// 注册监听器
		scheduler.getListenerManager().addSchedulerListener(mySchedulerListener);
		// 移除监听
		// scheduler.getListenerManager().removeSchedulerListener(mySchedulerListener);
		
		// 启动
		scheduler.start();
		Thread.sleep(8000);
		scheduler.shutdown();
	}

}

 

定时器3——定时框架Quartz2定时器3——定时框架Quartz2 武汉小喽啰 发布了128 篇原创文章 · 获赞 6 · 访问量 3196 私信 关注
上一篇:Pytorch学习率更新


下一篇:定时任务框架Quartz详解-基础篇