Quartz —— 从 HelloWorld 开始

1.Quartz 是用来完成任务调度的。

2.Quartz 的三个核心概念：调度器、任务、触发器。

（1）Job：通过实现该接口来定义需要执行的任务。

public interface Job {

    /**
     * Called by the <code>{@link Scheduler}</code> when a <code>{@link Trigger}</code> fires that is associated with the <code>Job</code>.
     */
    void execute(JobExecutionContext context) throws JobExecutionException;
}

（2）JobDetail：Quartz 在每次执行 Job 时，都重新创建一个 Job 实例，所以它不是直接接受一个 Job 的实例，而是接受 Job 的一个实现类，以便运行时通过反射区实例化 Job。

JobDtail 就是用来描述 Job 的实现类以及其他相关的静态信息。

package org.quartz;

import java.io.Serializable;

/**
 * Conveys the detail properties of a given <code>Job</code> instance. JobDetails are
 * to be created/defined with {@link JobBuilder}.
 *
 * <p>
 * Quartz does not store an actual instance of a <code>Job</code> class, but
 * instead allows you to define an instance of one, through the use of a <code>JobDetail</code>.
 * </p>
 *
 * <p>
 * <code>Job</code>s have a name and group associated with them, which
 * should uniquely identify them within a single <code>{@link Scheduler}</code>.
 * </p>
 *
 * <p>
 * <code>Trigger</code>s are the ‘mechanism‘ by which <code>Job</code>s
 * are scheduled. Many <code>Trigger</code>s can point to the same <code>Job</code>,
 * but a single <code>Trigger</code> can only point to one <code>Job</code>.
 * </p>*/
public interface JobDetail extends Serializable, Cloneable {

    public JobKey getKey();

    public String getDescription();

    public Class<? extends Job> getJobClass();

    public JobDataMap getJobDataMap();

    public boolean isDurable();

    public boolean isPersistJobDataAfterExecution();

    public boolean isConcurrentExectionDisallowed();

    public boolean requestsRecovery();

    public Object clone();

    public JobBuilder getJobBuilder();

}

（3）Trigger(中文"触发"的意思)：描述出发 Job 执行的时间触发规则。

package org.quartz;

import java.io.Serializable;
import java.util.Comparator;
import java.util.Date;
import org.quartz.JobDataMap;
import org.quartz.JobKey;
import org.quartz.ScheduleBuilder;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;

/**
 * The base interface with properties common to all <code>Trigger</code>s -
 * use {@link TriggerBuilder} to instantiate an actual Trigger.
 *
 * <p>
 * <code>Triggers</code>s have a {@link TriggerKey} associated with them, which
 * should uniquely identify them within a single <code>{@link Scheduler}</code>.
 * </p>
 *
 * <p>
 * <code>Trigger</code>s are the ‘mechanism‘ by which <code>Job</code>s
 * are scheduled. Many <code>Trigger</code>s can point to the same <code>Job</code>,
 * but a single <code>Trigger</code> can only point to one <code>Job</code>.
 * </p>
 *
 * <p>
 * Triggers can ‘send‘ parameters/data to <code>Job</code>s by placing contents
 * into the <code>JobDataMap</code> on the <code>Trigger</code>.
 * </p>
 *
 * @see TriggerBuilder
 * @see JobDataMap
 * @see JobExecutionContext
 * @see TriggerUtils
 * @see SimpleTrigger
 * @see CronTrigger
 * @see CalendarIntervalTrigger
 *
 * @author James House
 */
public interface Trigger extends Serializable, Cloneable, Comparable<Trigger> {
    long serialVersionUID = -3904243490805975570L;
    int MISFIRE_INSTRUCTION_SMART_POLICY = 0;
    int MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY = -1;
    int DEFAULT_PRIORITY = 5;

    TriggerKey getKey();

    JobKey getJobKey();

    String getDescription();

    String getCalendarName();

    JobDataMap getJobDataMap();

    int getPriority();

    boolean mayFireAgain();

    Date getStartTime();

    Date getEndTime();

    Date getNextFireTime();

    Date getPreviousFireTime();

    Date getFireTimeAfter(Date var1);

    Date getFinalFireTime();

    int getMisfireInstruction();

    TriggerBuilder<? extends Trigger> getTriggerBuilder();

    ScheduleBuilder<? extends Trigger> getScheduleBuilder();

    boolean equals(Object var1);

    int compareTo(Trigger var1);

    public static class TriggerTimeComparator implements Comparator<Trigger>, Serializable {
        private static final long serialVersionUID = -3904243490805975570L;

        public TriggerTimeComparator() {
        }

        public static int compare(Date nextFireTime1, int priority1, TriggerKey key1, Date nextFireTime2, int priority2, TriggerKey key2) {
            if(nextFireTime1 != null || nextFireTime2 != null) {
                if(nextFireTime1 == null) {
                    return 1;
                }

                if(nextFireTime2 == null) {
                    return -1;
                }

                if(nextFireTime1.before(nextFireTime2)) {
                    return -1;
                }

                if(nextFireTime1.after(nextFireTime2)) {
                    return 1;
                }
            }

            int comp = priority2 - priority1;
            return comp != 0?comp:key1.compareTo(key2);
        }

        public int compare(Trigger t1, Trigger t2) {
            return compare(t1.getNextFireTime(), t1.getPriority(), t1.getKey(), t2.getNextFireTime(), t2.getPriority(), t2.getKey());
        }
    }

    public static enum CompletedExecutionInstruction {
        NOOP,
        RE_EXECUTE_JOB,
        SET_TRIGGER_COMPLETE,
        DELETE_TRIGGER,
        SET_ALL_JOB_TRIGGERS_COMPLETE,
        SET_TRIGGER_ERROR,
        SET_ALL_JOB_TRIGGERS_ERROR;

        private CompletedExecutionInstruction() {
        }
    }

    public static enum TriggerState {
        NONE,
        NORMAL,
        PAUSED,
        COMPLETE,
        ERROR,
        BLOCKED;

        private TriggerState() {
        }
    }
}

主要有两个实现类：

  • SimpleTrigger：当仅需要触发一次或者以固定间隔周期执行。
  • CronTrigger：可以通过 Cron 表达式定义出各种复杂的调度方案。

（4）Calendar：一些日历特定时间点的集合。一个 Trigger 可以和多个 Calendar 关联，以便包含或排除某些时间点。

（5）Scheduler：一个 Quartz 的独立运行容器，Trigger 和 JobDtail 可以注册到 Scheduler 中。

Scheduler 可以将 Trigger 绑定到某一个 JobDetail 中，这样当 Trigger 被触发时，对应的 Job 就被执行。

一个 Job 可以有多个对应的 Trigger ，但是一个 Trigger 只能对应一个 Job。

3. HelloWorld

（1）步骤：

  • 实现 Job 接口，可使 Java 类变为可调度的任务
  • 创建描述 Job 的 JobDetail 对象
  • 创建 Trigger 对象
  • 设置触发 Job 执行的时间规则
  • 通过 SchedulerFactory 获取 Scheduler 对象
  • 向 SchedulerFactory 中注册 JobDetail 和 Trigger
  • 启动调度任务

（2）SimpleTrigger

/**
 * @author solverpeng
 * @create 2016-09-25-14:56
 */
public class HelloWorld {

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

        JobDetailImpl jobDetail = new JobDetailImpl(); jobDetail.setGroup("test-group"); jobDetail.setName("test-name");
        jobDetail.setJobClass(MyJob.class);

        SimpleTriggerImpl trigger = new SimpleTriggerImpl();
        trigger.setName("test-trigger-name");
        trigger.setGroup("test-trigger-group");
        trigger.setStartTime(new Date());
        trigger.setRepeatCount(5);
        trigger.setRepeatInterval(1000*5);

        SchedulerFactory schedulerFactory = new StdSchedulerFactory(); Scheduler scheduler = schedulerFactory.getScheduler();
        scheduler.scheduleJob(jobDetail, trigger);

        scheduler.start();

    }

}

（3）CronTrigger

Cron 表达式1：

  • 由6或7个空格分割的时间字段组成
  • 对特殊字符的大小写不敏感
  • 从左到右时间范围越来越大：秒 分 时 日 月 星期 年（可选）
  • 秒：范围：0-59，允许特殊字符 ", - * /"
  • 分：范围：0-59，允许特殊字符 ", - * /"
  • 小时：范围：0-23
  • 日期：范围：1-31
  • 星期：范围：1-7（需要用英文简写表示）
  • 年：范围：控制或 1970-2099

Cron 表达式2：

  • * ：可用于所有字段，表示每一个时刻。e: * 分钟时段表示每分钟
  • ? ：只能使用在日期和星期字段，表示一个毫无意义的值。相当于占位符。（日期和星期字段必须有一个 ? ，不能使用 * 替代）
  • - ：表示一个范围。e: 10-12 使用在小时字段，表示10点、11点、12点
  • , ：表示一个列表值。e:在星期字段中使用 MON,WED,FRI，表示星期一,星期三，星期五
  • / ：x/y 表示一个等步长序列，x 为起始值，y 为增量步长。
    • e1:在分钟字段使用 0/15 ，则表示 0,15,30 和 45 秒；
    • e2:5/15，表示5,20,35,50。
    • */y 等同于 0/y。
  • L ：只在日期和星期字段中使用，代表 Last。
    • 使用在日期字段，表示这个月的最后一天；
    • 使用在星期字段，表示星期六。
    • 若 L 出现在星期字段里，且前面有一个数值X，则表示这个月的最后星期X，例如 6L 表示该月的最后一个星期五。
  • W ：只能出现在日期字段中，是对前导日期的修饰，表示离该日期最近的工作日。
    • e1:15W 表示离该月15号最近的工作日，若15号是星期六，则匹配14号，若15号是星期日，则匹配16号，若15号是星期二，则匹配15号。
    • 关联的匹配日期不能跨月。如用户指定1W，若1号是星期六，则匹配3号
    • W 只能指定单一日期，而不能指定日期范围
  • LW ：在日期字段可以组合使用LW，值 当月的最后一个工作日
  • # ：只能在星期字段中使用，表示当月某个工作日，如：6#3 表示当月的第三个星期5，4#5 表示当月第5个星期三。
  • C ：该字段只在日期和星期字段中使用，代表 Canlendar。指计划所关联的日期，如果日期没有被关联，则相当于日历中所有日期。
    • 5C在日期字段中相当于 5 日以后的第一天　　
    • 1C在星期字段中相当于星期日后的第一天

Cron表达式示例

  • 0 0 12 * * ?：每天中午12点触发
  • 0 15 10 ? * *：每天上午10:15触发
  • 0 15 10 * ? *： 每天上午10:15触发
  • 0 15 10 * * ?： 每天上午10:15触发
  • 0 15 10 * * ? 2005： 2005年的每天上午10:15触发
  • 0 * 14 * * ?：在每天下午2点到下午2:59期间的每1分钟触发
  • 0 0/5 14 * * ?：在每天下午2点到下午2:55期间的每5分钟触发
  • 0 0/5 14, 18 * * ?：在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟,触发
  • 0 0-5 14 * * ?：在每天下午2点到下午2:05期间的每1分钟触发
  • 0 10,44 14 ? 3 WED：每年三月的星期三的下午2:10和2:44触发
  • 0 15 10 ? * MON-FRI：周一至周五的上午10:15 触发
  • 0 15 10 15 * ?：每月15日上午10:15 触发
  • 0 15 10 L * ?：每月最后一日的上午10:15 触发
  • 0 15 10 ? * 6L：每月的最后一个星期五上午10:15 触发
  • 0 15 10 ? * 6L 2002-2005：2002年至2005年的每月的最后一个星期五上午10:15触发
  • 0 15 10 ? * 6#3：每月的第三个星期五上午10:15触发

例子：

/**
 * @author solverpeng
 * @create 2016-09-25-14:56
 */
public class HelloWorld {
    public static void main(String[] args) throws SchedulerException, ParseException {

        JobDetailImpl jobDetail = new JobDetailImpl(); jobDetail.setGroup("test-group"); jobDetail.setName("test-name");
        jobDetail.setJobClass(MyJob.class);

        CronTriggerImpl trigger = new CronTriggerImpl(); trigger.setCronExpression("0/5 56 15 ? 9 SUN"); trigger.setStartTime(new Date());
        trigger.setName("test-trigger-name"); trigger.setGroup("test-trigger-group");

        SchedulerFactory schedulerFactory = new StdSchedulerFactory(); Scheduler scheduler = schedulerFactory.getScheduler();
        scheduler.scheduleJob(jobDetail, trigger);
        scheduler.start();

    }

}

官方 Demo：

package com.nucsoft.quartz;

import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;

import static org.quartz.JobBuilder.newJob;
import static org.quartz.SimpleScheduleBuilder.simpleSchedule;
import static org.quartz.TriggerBuilder.newTrigger;

/**
 * @author solverpeng
 * @create 2016-09-25-16:49
 */
public class HelloWorld {

    public static void main(String[] args) throws SchedulerException {
        // define the job and tie it to our MyJob class
        JobDetail job = newJob(MyJob.class).withIdentity("job1", "group1").build();

        // Trigger the job to run now, and then repeat every 40 seconds
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1").startNow().withSchedule(
                simpleSchedule().withIntervalInSeconds(40).repeatForever()).build();
        // Grab the Scheduler instance from the Factory
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        // Tell quartz to schedule the job using our trigger
        scheduler.scheduleJob(job, trigger);

        // and start it off
        scheduler.start();
    }

}

4.总结

介绍了Quartz的几个核心概念，Cron 表达式，以及 Quartz 的 HelloWorld。Job 是用来定义要完成的任务，JobDetail用来描述它，Trigger 是一个触发器，用于触发任务，它们统一由 Scheduler

来管理。其中需要注意一点的是，国外每个星期的开始是从 星期日开始的，所以 6 表示星期五。

时间： 2024-10-03 00:38:13

Quartz —— 从 HelloWorld 开始的相关文章

Quartz(1)：helloworld

一:相关依赖与环境 <dependencies> <!--核心包--> <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.3.0</version> </dependency> <!--工具包--> <dependency>

定时器(Quartz)快速入门

Quartz概述 Quartz中的触发器 Quartz中提供了两种触发器,分别是CronTrigger和SimpleTrigger. SimpleTrigger 每 隔若干毫秒来触发纳入进度的任务.因此,对于夏令时来说,根本不需要做任何特殊的处理来"保持进度".它只是简单地保持每隔若干毫秒来触发一次,无论你的 SimpleTrigger每隔10秒触发一次还是每隔15分钟触发一次,还是每隔24小时触发一次. CronTrigger 在特定"格林日历"时刻触发纳入进程的

Quartz的使用

近期项目中有用到Quartz,故现在学习Quartz以满足工作需求. 这里列出几个Quartz的Demo,循序渐进的学习Quartz,找出最方便好用的使用方式. 方式一:Maven+Quartz本身Api,实现每隔两秒打印HelloWorld 1.在pom.xml中加入Quartz的依赖:     <dependency>             <groupId>org.quartz-scheduler</groupId>         <artifactId

quartz笔记

首先网络上的很多教程经常有错(信息过载了),其主要原因是版本发生了变化,例如quartz1和2之间还是有不少差别的,导致查找资料的人浪费了不少时间.所以无论教程如何写,都建议读者首先学习官网的教程,如果有一些资料官网没有,例如扩展的东西或者和其他框架整合的东西,再去参考其他资料. 本文仅为我个人学习记录.建议重点参考官网:www.quartz-scheduler.org quartz版本:2.2.1 原生quartz: 基本思路: 通过工厂创建一个Scheduler 创建一个实现Job接口的实现

quartz集群调度机制调研及源码分析---转载

quartz2.2.1集群调度机制调研及源码分析引言quartz集群架构调度器实例化调度过程触发器的获取触发trigger:Job执行过程:总结:附: 引言 quratz是目前最为成熟,使用最广泛的java任务调度框架,功能强大配置灵活.在企业应用中占重要地位.quratz在集群环境中的使用方式是每个企业级系统都要考虑的问题.早在2006年,在ITeye上就有一篇关于quratz集群方案的讨论:http://www.iteye.com/topic/40970 ITeye创始人@Robbin在8楼

定时组件quartz系列&lt;三&gt;quartz调度机制调研及源码分析

quartz2.2.1集群调度机制调研及源码分析引言quartz集群架构调度器实例化调度过程触发器的获取触发trigger:Job执行过程:总结:附: 引言 quratz是目前最为成熟,使用最广泛的java任务调度框架,功能强大配置灵活.在企业应用中占重要地位.quratz在集群环境中的使用方式是每个企业级系统都要考虑的问题.早在2006年,在ITeye上就有一篇关于quratz集群方案的讨论:http://www.iteye.com/topic/40970 ITeye创始人@Robbin在8楼

（1）quartz集群调度机制调研及源码分析---转载

quartz2.2.1集群调度机制调研及源码分析 原文地址:http://demo.netfoucs.com/gklifg/article/details/27090179 引言quartz集群架构调度器实例化调度过程触发器的获取触发trigger:Job执行过程:总结:附: 引言 quratz是目前最为成熟,使用最广泛的java任务调度框架,功能强大配置灵活.在企业应用中占重要地位.quratz在集群环境中的使用方式是每个企业级系统都要考虑的问题.早在2006年,在ITeye上就有一篇关于qu

quartz定时任务框架调度机制解析

转自集群调度机制调研及源码分析 quartz2.2.1集群调度机制调研及源码分析引言quartz集群架构调度器实例化调度过程触发器的获取触发trigger:Job执行过程:总结:附: 引言 quratz是目前最为成熟,使用最广泛的java任务调度框架,功能强大配置灵活.在企业应用中占重要地位.quratz在集群环境中的使用方式是每个企业级系统都要考虑的问题.早在2006年,在ITeye上就有一篇关于quratz集群方案的讨论:http://www.iteye.com/topic/40970 IT

Quartz学习笔记

什么是job schedule system? job schedule system是负责在预定义的时间执行或者通知某个应用组件的系统.举个例子来说,比如在每周一早上9:30发送email通知客户最新的业务情况. java.util.Timer和java.util.TimerTask Timer和TimerTask是可以完成job schedule的两个jdk提供的类,不过这不能称为一个system.Timer和TimerTask是很简单的,不直接支持持久化任务,线程池和类似日历(calend