Quartz —— 從 HelloWorld 開始_ZenDei技術網路在線

1.Quartz 是用來完成任務調度的。 2.Quartz 的三個核心概念：調度器、任務、觸發器。（1）Job：通過實現該介面來定義需要執行的任務。（2）JobDetail：Quartz 在每次執行 Job 時，都重新創建一個 Job 實例，所以它不是直接接受一個 Job 的實例，而是接受 Jo ...

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() {
        }
    }
}

View Code

主要有兩個實現類：

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 表示星期五。