1 SchedulerFactory

1.1 概述

Quartz是以模块的方式构建的，因为，要使它运行，几个组件必须很好的组合在一起。非常幸运的是，已经有了一些现存的助手可以完成这些工作。
所有Scheduler实例都是由SchedulerFactory创建的。
Quartz的三个核心概念：调度器（Scheduler）、任务（Job）和触发器（Trigger），三者之间的关系是：

Quartz（二）

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

1.2 Scheduler的创建方式

1.2.1 StdSchedulerFactory

Quartz默认使用的是StdSchedulerFactory。

使用一组参数（java.util.Properties）来创建和初始化Quartz调度器。
配置参数一般存储在quartz.properties文件中。
调用getScheduler方法就可以创建和初始化调度器对象。

StdSchedulerFactory fact = new StdSchedulerFactory();

Scheduler scheduler = fact.getScheduler();

1.2.1.1 输出调度器开始的时间：

    Date scheduleJob(JobDetail jobDetail, Trigger trigger)

        throws SchedulerException;

示例：
MailJob.java

package com.sunxiaping;

import org.quartz.Job;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

import java.util.Date;

public class MailJob implements Job {

    public void execute(JobExecutionContext context) throws JobExecutionException {

        System.out.println("当前时间是："+new Date());

    }

}

QuartzTest.java

package com.sunxiaping;

import org.quartz.*;

import org.quartz.impl.StdSchedulerFactory;

import java.util.Date;

/**

 * Quartz测试

 */

public class QuartzTest {

    public static void main(String[] args) throws SchedulerException {

        Date startDate = new Date();

        startDate.setTime(startDate.getTime() + 3000);

        Date endDate = new Date();

        endDate.setTime(endDate.getTime() + 10000);

        JobDetail jobDetail = JobBuilder.newJob(MailJob.class)

                .withIdentity("job1", "group1")

                .build();

        Trigger trigger = TriggerBuilder.newTrigger()

                .withIdentity("trigger1", "group1")

                .startNow() //立即开始，在Scheduler调度器开启之后

                .withSchedule(CronScheduleBuilder.cronSchedule("* * * * * ?"))

                .build();

        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

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

        System.out.println("调度器开始时间：" + date);

        scheduler.start();

    }

}

1.2.1.2 启动任务调度

void start() throws SchedulerException;

1.2.1.3 任务调度挂起，即暂停

void standby() throws SchedulerException;

示例：
MailJob.java

package com.sunxiaping;

import org.quartz.Job;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

import java.util.Date;

public class MailJob implements Job {

    public void execute(JobExecutionContext context) throws JobExecutionException {

        System.out.println("当前时间是："+new Date());

    }

}

QuartzTest.java

package com.sunxiaping;

import org.quartz.*;

import org.quartz.impl.StdSchedulerFactory;

import java.util.Date;

/**

 * Quartz测试

 */

public class QuartzTest {

    public static void main(String[] args) throws SchedulerException, InterruptedException {

        Date startDate = new Date();

        startDate.setTime(startDate.getTime() + 3000);

        Date endDate = new Date();

        endDate.setTime(endDate.getTime() + 10000);

        JobDetail jobDetail = JobBuilder.newJob(MailJob.class)

                .withIdentity("job1", "group1")

                .build();

        Trigger trigger = TriggerBuilder.newTrigger()

                .withIdentity("trigger1", "group1")

                .startNow() //立即开始，在Scheduler调度器开启之后

                .withSchedule(CronScheduleBuilder.cronSchedule("* * * * * ?"))

                .build();

        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        scheduler.scheduleJob(jobDetail, trigger);

        scheduler.start();

        //Scheduler执行2秒后自动挂起

        Thread.sleep(2000L);

        scheduler.standby();

        //Scheduler执行5秒后自动开启

        Thread.sleep(5000L);

        scheduler.start();

    }

}

1.2.1.4 关闭任务调度

void shutdown() throws SchedulerException;

void shutdown(boolean waitForJobsToComplete)

        throws SchedulerException;

如果shutdown中的参数是true：表示等待所有正在执行的Job执行完毕之后，再关闭Scheduler。
如果shutdown中的参数是false：表示直接关闭Scheduler。

示例：
MailJob.java

package com.sunxiaping;

import org.quartz.Job;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

import java.util.Date;

public class MailJob implements Job {

    public void execute(JobExecutionContext context) throws JobExecutionException {

        System.out.println("当前时间是："+new Date());

    }

}

QuartzTest.java

package com.sunxiaping;

import org.quartz.*;

import org.quartz.impl.StdSchedulerFactory;

import java.util.Date;

/**

 * Quartz测试

 */

public class QuartzTest {

    public static void main(String[] args) throws SchedulerException, InterruptedException {

        Date startDate = new Date();

        startDate.setTime(startDate.getTime() + 3000);

        Date endDate = new Date();

        endDate.setTime(endDate.getTime() + 10000);

        JobDetail jobDetail = JobBuilder.newJob(MailJob.class)

                .withIdentity("job1", "group1")

                .build();

        Trigger trigger = TriggerBuilder.newTrigger()

                .withIdentity("trigger1", "group1")

                .startNow() //立即开始，在Scheduler调度器开启之后

                .withSchedule(CronScheduleBuilder.cronSchedule("* * * * * ?"))

                .build();

        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        scheduler.scheduleJob(jobDetail, trigger);

        scheduler.start();

        Thread.sleep(2000L);

        scheduler.shutdown(true);

    }

}

1.2.2 DirectSchedulerFactory（了解）

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

DirectSchedulerFactory directSchedulerFactory = DirectSchedulerFactory.getInstance();

Scheduler scheduler = directSchedulerFactory.getScheduler();

2 Quartz.properties

默认路径是:quartzjar包中org.quartz中的quartz.properties。

# 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

Quartz（二）

我们也可以自己新建一个quartz.properties文件覆盖掉原来的quartz.properties文件。

调度器属性：
org.quartz.scheduler.instanceName属性用来区分特定的调度器实例，可以按照功能用途来给调度器命名。
org.quartz.scheduler.instanceId属性和前者一样，也允许任何字符串，但是这个值必须在所有调度器实例中是唯一的，尤其是一个集群环境中，作为集群中的唯一key。如果你想Quartz帮你生成这个值的话，可以设置为AUTO。

线程池属性：
org.quartz.threadPool.threadCount：处理Job的线程个数，至少为1，但是最多的话不要超过100，在多数机器上设置该值超过100的话就会显得相当不实用了，特别是在你的Job执行时间较长的情况下。
org.quartz.threadPool.threadPriority：线程的优先级，优先级级别高的线程比优先级级别低的线程优先得到执行。最小为1，最大为10，默认为5。
org.quartz.threadPool.class：一个实现了org.quartz.spi.ThreadPool接口的类，Quartz自带的线程池的实现类是org.quartz.simpl.SimpleThreadPool。

作业存储设置：
描述了调度器实例的生命周期中，Job和Trigger信息是如何存储的。

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

3 Quartz监听器

3.1 概述

Quartz的监听器用于当任务调度中你所关注的事件发生的时候，能够及时获取这一事件的通知。
类似于任务执行过程中的邮件、短信类的提醒。
Quartz的监听器主要有TriggerListener、JobListener、SchedulerListener三种，顾名思义，分别表示任务、触发器、调度器对应的监听器。
三者的使用方法类似，在开始介绍三种监听器之前，需要明确两个概念：全局监听器和非全局监听器，二者的区别在于：全局监听器能够接收到所有的Job/Trigger的事件通知，而非全局监听器只能接收到在其上注册的Job或Trigger的事件。

3.2 JobListener

任务调度的过程中，和任务Job相关的事件包括：Job开始要执行的提示。Job执行完成的提示。

package org.quartz;

public interface JobListener {

    String getName();

    void jobToBeExecuted(JobExecutionContext context);

    void jobExecutionVetoed(JobExecutionContext context);

    void jobWasExecuted(JobExecutionContext context,

            JobExecutionException jobException);

}

其中：
getName方法：用于获取该JobListener的名称。
jobToBeExecuted方法：Scheduler在JobDetail将要被执行的时候调用这个方法。
jobExecutionVetoed方法：Scheduler在JobDetail即将被执行，但又被TriggerListener否决时会调用该方法。
jobWasExecuted方法：Scheduler在JobDetail被执行之后调用此方法。

示例：全局JobListener
MailJob.java

package com.sunxiaping;

import org.quartz.Job;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

import java.util.Date;

public class MailJob implements Job {

    public void execute(JobExecutionContext context) throws JobExecutionException {

        System.out.println(this.getClass().getName() + "当前时间是：" + new Date());

    }

}

MyJobListener.java

package com.sunxiaping;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

import org.quartz.JobListener;

public class MyJobListener implements JobListener {

    @Override

    public String getName() {

        System.out.println("监听器的名称：" + this.getClass().getName());

        return getClass().getName();

    }

    @Override

    public void jobToBeExecuted(JobExecutionContext context) {

        System.out.println("Scheduler在JobDetail将要被执行的时候调用这个方法");

    }

    @Override

    public void jobExecutionVetoed(JobExecutionContext context) {

        System.out.println("Scheduler在JobDetail即将被执行，但又被TriggerListener否决时会调用该方法");

    }

    @Override

    public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) {

        System.out.println("Scheduler在JobDetail被执行之后调用此方法");

    }

}

QuartzTest.java

package com.sunxiaping;

import org.quartz.*;

import org.quartz.impl.StdSchedulerFactory;

import org.quartz.impl.matchers.EverythingMatcher;

/**

 * Quartz测试

 */

public class QuartzTest {

    public static void main(String[] args) throws SchedulerException, InterruptedException {

        JobDetail jobDetail = JobBuilder.newJob(MailJob.class)

                .withIdentity("job1", "group1")

                .build();

        Trigger trigger = TriggerBuilder.newTrigger()

                .withIdentity("trigger1", "group1")

                .startNow() //立即开始，在Scheduler调度器开启之后

                .withSchedule(CronScheduleBuilder.cronSchedule("* * * * * ?"))

                .build();

        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        scheduler.scheduleJob(jobDetail, trigger);

        //创建并创建一个全局的Job Listener

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

        scheduler.start();

    }

}

示例：局部Listener
MailJob.java

package com.sunxiaping;

import org.quartz.Job;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

import java.util.Date;

public class MailJob implements Job {

    public void execute(JobExecutionContext context) throws JobExecutionException {

        System.out.println(this.getClass().getName() + "当前时间是：" + new Date());

    }

}

MyJobListener.java

package com.sunxiaping;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

import org.quartz.JobListener;

public class MyJobListener implements JobListener {

    @Override

    public String getName() {

        System.out.println("监听器的名称：" + this.getClass().getName());

        return getClass().getName();

    }

    @Override

    public void jobToBeExecuted(JobExecutionContext context) {

        System.out.println("Scheduler在JobDetail将要被执行的时候调用这个方法");

    }

    @Override

    public void jobExecutionVetoed(JobExecutionContext context) {

        System.out.println("Scheduler在JobDetail即将被执行，但又被TriggerListener否决时会调用该方法");

    }

    @Override

    public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) {

        System.out.println("Scheduler在JobDetail被执行之后调用此方法");

    }

}

QuartzTest.java

package com.sunxiaping;

import org.quartz.*;

import org.quartz.impl.StdSchedulerFactory;

import org.quartz.impl.matchers.KeyMatcher;

/**

 * Quartz测试

 */

public class QuartzTest {

    public static void main(String[] args) throws SchedulerException, InterruptedException {

        JobDetail jobDetail = JobBuilder.newJob(MailJob.class)

                .withIdentity("job1", "group1")

                .build();

        Trigger trigger = TriggerBuilder.newTrigger()

                .withIdentity("trigger1", "group1")

                .startNow() //立即开始，在Scheduler调度器开启之后

                .withSchedule(CronScheduleBuilder.cronSchedule("* * * * * ?"))

                .build();

        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        scheduler.scheduleJob(jobDetail, trigger);

        //创建并创建一个局部的Job Listener

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

        scheduler.start();

    }

}

3.3 TriggerListener

任务调度过程中，和触发器Trigger相关的事件包括：触发器触发、触发器没有正常触发、触发器完成。

package org.quartz;

import org.quartz.Trigger.CompletedExecutionInstruction;

public interface TriggerListener {

    String getName();

    void triggerFired(Trigger trigger, JobExecutionContext context);

    boolean vetoJobExecution(Trigger trigger, JobExecutionContext context);

    void triggerMisfired(Trigger trigger);

    void triggerComplete(Trigger trigger, JobExecutionContext context,

            CompletedExecutionInstruction triggerInstructionCode);

}

其中：
getName方法：用于获取触发器的名称。
TriggerFired方法：当和触发器相关联的Trigger被触发，Job上的execute()方法将被执行的时候，Scheduler就调用该方法。
vetoJobExecution方法：在Trigger触发后，Job将要被执行的时候由Scheduler调用这个方法。TriggerListener给了一个选择去否决Job的执行。假如这个方法返回true，这个Job将不会为此Trigger触发而得到执行。
triggerMisfired方法：Scheduler调用这个方法是在Trigger错过触发的时候。
triggerComplete方法：Trigger被触发并且完成了Job的执行的时候，Scheduler就调用了该方法。

示例：
略。

3.4 SchedulerListener

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

package org.quartz;

public interface SchedulerListener {

    void jobScheduled(Trigger trigger);

    void jobUnscheduled(TriggerKey triggerKey);

    void triggerFinalized(Trigger trigger);

    void triggerPaused(TriggerKey triggerKey);

    void triggersPaused(String triggerGroup);

    void triggerResumed(TriggerKey triggerKey);

    void triggersResumed(String triggerGroup);

    void jobAdded(JobDetail jobDetail);

    void jobDeleted(JobKey jobKey);

    void jobPaused(JobKey jobKey);

    void jobsPaused(String jobGroup);

    void jobResumed(JobKey jobKey);

    void jobsResumed(String jobGroup);

    void schedulerError(String msg, SchedulerException cause);

    void schedulerInStandbyMode();

    void schedulerStarted();

    void schedulerStarting();

    void schedulerShutdown();

    void schedulerShuttingdown();

    void schedulingDataCleared();

}

其中：
jobScheduled方法：用于部署JobDetail时被调用。
jobUnscheduled方法：用于卸载JobDetail时被调用。
triggerFinalized方法：当一个Trigger来到了再也不会触发的状态时调用这个方法。除非这个Job已经设置成了持久性，否则它就会从Scheduler中移除。
triggersPaused方法：Scheduler调用这个方法是发生在一个Trigger或Trigger组被暂停时。假如是Trigger组的话，triggerName参数将为null。
triggersResumed方法：Scheduler调用这个方法是发生成一个Trigger或Trigger组从暂停中恢复时。假如是Trigger组的话，triggerName的参数将为null。
jobsPaused方法：当一个或一组JobDetail暂停时调用这个方法。
jobsResumed方法：当一个或一组Job从暂停上恢复时调用这个方法。
schedulerError方法：在Scheduler的正常运行期间产生一个严重错误的时候调用这个方法。
schedulerStarted方法：在Scheduler开启的时候，调用该方法。
schedulerStandbyMode方法：当Scheduler处于StandBy模式，调用该方法。
schedulerShutdown方法：当Scheduler停止的时候，调用该方法。
schedulingDataCleared方法：当Scheduler的数据被清除的时候，调用该方法。

示例：
略。

秒客网

Quartz（二）

1 SchedulerFactory

1.1 概述

1.2 Scheduler的创建方式

1.2.1 StdSchedulerFactory

1.2.1.1 输出调度器开始的时间：

1.2.1.2 启动任务调度

1.2.1.3 任务调度挂起，即暂停

1.2.1.4 关闭任务调度

1.2.2 DirectSchedulerFactory（了解）

2 Quartz.properties

3 Quartz监听器

3.1 概述

3.2 JobListener

3.3 TriggerListener

3.4 SchedulerListener

相关文章