定时器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

 注意：如果不想用默认的配置文件，我们也可以在资源目录下新建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();
	}

}