Quartz的基本使用之入門（2.3.0版本）

時間 2019-11-13

標籤 quartz 基本使用入門 2.3.0 版本欄目 Quartz 简体版

原文原文鏈接

1、Quartz能夠用來作什麼

Quartz是一個強大任務調度框架，我工做時候會在這些狀況下使用到quartz框架，固然還有不少的應用場景，在這裏只列舉2個實際用到的java

餐廳系統會在每週四晚上的22點自動審覈並生成報表
人事系統會在天天早晨8點給有待辦的人員自動發送Email提醒數據庫

2、使用Quartz以前的準備

1.創建一個Maven項目

2.引入quartz的依賴　　

　　使用quartz，咱們僅僅須要在maven的pom文件中添加依賴便可。我使用的是如今最新的一個版本2.3.0，你們能夠在maven的倉庫獲取到最新的版本依賴，地址：http://mvnrepository.com/artifact/org.quartz-scheduler/quartz併發

　但然也可使用這個2.3.0的依賴，下面的例子都是使用此依賴並實現了效果。框架

<!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz -->
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.0</version>
</dependency>

3、編寫第一個Quartz任務案例 - 每隔2秒鐘打印一次HelloQuartz

先實現一下這個基本的Quartz的任務再來介紹一下Quartz的3個重要組成，JobDetail，Trigger，Schedulermaven

1.建立一個類 HelloJob.java，這個類是編寫咱們的具體要實現任務（打印Hello Quartz）

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import java.text.SimpleDateFormat;
import java.util.Date;
public class HelloJob implements Job{
　　public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //打印當前的執行時間 例如 2017-11-23 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("如今的時間是："+ sf.format(date));
        //具體的業務邏輯
        System.out.println("Hello Quartz");
    }
}

2.建立一個類HelloScheduler.java，這個是具體觸發咱們的任務

public class HelloScheduler {
    public static void main(String[] args) throws SchedulerException {
        //建立一個jobDetail的實例，將該實例與HelloJob Class綁定
        JobDetail jobDetail = JobBuilder.newJob(HelloJob.class).withIdentity("myJob").build();
        //建立一個Trigger觸發器的實例，定義該job當即執行，而且每2秒執行一次，一直執行
        SimpleTrigger trigger = TriggerBuilder.newTrigger().withIdentity("myTrigger").startNow().withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(2).repeatForever()).build();
        //建立schedule實例
        StdSchedulerFactory factory = new StdSchedulerFactory();
        Scheduler scheduler = factory.getScheduler();
        scheduler.start();
        scheduler.scheduleJob(jobDetail,trigger);

    }
}

3.執行main方法，Run 'HelloScheduler.main()'，能夠看見以下效果，代表任務執行成功了

4.一句話看懂quartz

一、建立調度工廠(); 　　 //工廠模式函數

二、根據工廠取得調度器實例(); 　　//工廠模式

三、Builder模式構建子組件<Job,Trigger> 　　 // builder模式, 如JobBuilder、TriggerBuilder、DateBuilder

四、經過調度器組裝子組件調度器.組裝<子組件1,子組件2...> 　　//工廠模式

五、調度器.start();　　 //工廠模式

4、第二個案例 - 每日的9點40分觸發任務打印HelloQuartz

　與上一個的簡單案例的區別在於，SimpleTrigger/CronTrigger. 簡單的定時任務,能夠採用SimpleTrigger,複雜的任務通常採用CronTrigger.cronTrigger不只能夠設定單的觸發時間表,更能夠設定很是複雜的觸發時間表。 CronTrigger 是基於 Unix相似於 cron 表達式,若是對cron表達式比較熟悉,那麼學習起來經很是簡單. 即便對cron表達式不熟悉,花一下子的功夫也能夠學會。（在工做中咱們直接使用網上的在線生成表達式便可又快又準確）生成地址：http://cron.qqe2.com/學習

先上代碼，而後介紹一下cron表達式生成規則。ui

1.編寫任務類 HelloJob.java，具體狀況編寫具體內容，如生成報表，發送郵件。。

public class HelloJob implements Job{
 public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //打印當前的執行時間 例如 2017-11-22 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("如今的時間是："+ sf.format(date));
        //具體的業務邏輯
        System.out.println("開始生成任務報表 或 開始發送郵件");
    }
}

2.編寫任務觸發類 CronScheduler.java

public class CronScheduler {
     public static void main(String[] args) throws SchedulerException, InterruptedException {
        //jobDetail
        JobDetail jobDetail = JobBuilder.newJob(HelloJob.class).withIdentity("cronJob").build();
        //cronTrigger
        //每日的9點40觸發任務
        CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("cronTrigger").withSchedule(CronScheduleBuilder.cronSchedule("0 40 9 * * ? ")).build();
        //1.每日10點15分觸發      0 15 10 ？* *
        //2.天天下午的2點到2點59分（正點開始，隔5分觸發）       0 0/5 14 * * ?
        //3.從週一到週五天天的上午10點15觸發      0 15 10 ? MON-FRI
        //4.每個月的第三週的星期五上午10點15觸發     0 15 10 ? * 6#3
        //5.2016到2017年每個月最後一週的星期五的10點15分觸發   0 15 10 ? * 6L 2016-2017
        //Scheduler實例
        StdSchedulerFactory stdSchedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = stdSchedulerFactory.getScheduler();
        scheduler.start();
        scheduler.scheduleJob(jobDetail,cronTrigger);
    }
}

3.觸發的效果

5、cron表達式編寫規則

　1.　Quartz Cron 表達式支持7個域 ,分別是秒/分/時/日/月/周/年.期中年是非必須項.以下圖

名稱	是否必須	容許值	特殊字符
秒	是	0-59	, - * /
分	是	0-59	, - * /
時	是	0-23	, - * /
日	是	1-31	, - * ? / L W C
月	是	1-12 或 JAN-DEC	, - * /
周	是	1-7 或 SUN-SAT	, - * ? / L C #
年	否	空或 1970-2099	, - * /

注意在cron表達式中不區分大小寫.this

星號(*)：可用在全部字段中，表示對應時間域的每個時刻，例如， 在分鐘字段時，表示「每分鐘」；spa

問號（?）：該字符只在日期和星期字段中使用，它一般指定爲「無心義的值」，至關於點位符；

減號(-)：表達一個範圍，如在小時字段中使用「10-12」，則表示從10到12點，即10,11,12；

逗號(,)：表達一個列表值，如在星期字段中使用「MON,WED,FRI」，則表示星期一，星期三和星期五；

斜槓(/)：x/y表達一個等步長序列，x爲起始值，y爲增量步長值。如在分鐘字段中使用0/15，則表示爲0,15,30和45秒，而5/15在分鐘字段中表示5,20,35,50，你也可使用*/y，它等同於0/y；

L：該字符只在日期和星期字段中使用，表明「Last」的意思，但它在兩個字段中意思不一樣。L在日期字段中，表示這個月份的最後一天，如一月的31號，非閏年二月的28號；若是L用在星期中，則表示星期六，等同於7。可是，若是L出如今星期字段裏，並且在前面有一個數值X，則表示「這個月的最後X天」，例如，6L表示該月的最後星期五；

W：該字符只能出如今日期字段裏，是對前導日期的修飾，表示離該日期最近的工做日。例如15W表示離該月15號最近的工做日，若是該月15號是星期六，則匹配14號星期五；若是15日是星期日，則匹配16號星期一；若是15號是星期二，那結果就是15號星期二。但必須注意關聯的匹配日期不可以跨月，如你指定1W，若是1號是星期六，結果匹配的是3號星期一，而非上個月最後的那天。W字符串只能指定單一日期，而不能指定日期範圍；

LW組合：在日期字段能夠組合使用LW，它的意思是當月的最後一個工做日；

井號(#)：該字符只能在星期字段中使用，表示當月某個工做日。如6#3表示當月的第三個星期五(6表示星期五，#3表示當前的第三個)，而4#5表示當月的第五個星期三，假設當月沒有第五個星期三，忽略不觸發；

C：該字符只在日期和星期字段中使用，表明「Calendar」的意思。它的意思是計劃所關聯的日期，若是日期沒有被關聯，則至關於日曆中全部日期。例如5C在日期字段中就至關於日曆5日之後的第一天。1C在星期字段中至關於星期往後的第一天。

Cron表達式對特殊字符的大小寫不敏感，對錶明星期的縮寫英文大小寫也不敏感。

2.官方的一些案例

表示式	說明
0 0 12 * * ?	天天12點運行
0 15 10 ? * *	天天10:15運行
0 15 10 * * ?	天天10:15運行
0 15 10 * * ? *	天天10:15運行
0 15 10 * * ? 2008	在2008年的天天10：15運行
0 * 14 * * ?	天天14點到15點之間每分鐘運行一次，開始於14:00，結束於14:59。
0 0/5 14 * * ?	天天14點到15點每5分鐘運行一次，開始於14:00，結束於14:55。
0 0/5 14,18 * * ?	天天14點到15點每5分鐘運行一次，此外天天18點到19點每5鍾也運行一次。
0 0-5 14 * * ?	天天14:00點到14:05，每分鐘運行一次。
0 10,44 14 ? 3 WED	3月每週三的14:10分到14: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 2007-2009	在2007,2008,2009年每月的最後一個星期五的10:15分運行。
0 15 10 ? * 6#3	每個月第三個星期五的10:15分運行。

以上就能夠實現大部分的業務的需求了，如下是對Quartz的API的一些瞭解

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

6、Quartz的三個基本要素

　　Quartz對任務調度的領域問題進行了高度的抽象，提出了調度器、任務和觸發器這3個核心的概念，並在org.quartz經過接口和類對重要的這些核心概念進行描述：

　　●Job：是一個接口，只有一個方法void execute(JobExecutionContext context)，開發者實現該接口定義運行任務，JobExecutionContext類提供了調度上下文的各類信息。Job運行時的信息保存在JobDataMap實例中；

　　●JobDetail：Quartz在每次執行Job時，都從新建立一個Job實例，因此它不直接接受一個Job的實例，相反它接收一個Job實現類，以便運行時經過newInstance()的反射機制實例化Job。所以須要經過一個類來描述Job的實現類及其它相關的靜態信息，如Job名字、描述、關聯監聽器等信息，JobDetail承擔了這一角色。

　　經過該類的構造函數能夠更具體地瞭解它的功用：JobDetail(java.lang.String name, java.lang.String group, java.lang.Class jobClass)，該構造函數要求指定Job的實現類，以及任務在Scheduler中的組名和Job名稱；

　　●Trigger：是一個類，描述觸發Job執行的時間觸發規則。主要有SimpleTrigger和CronTrigger這兩個子類。當僅需觸發一次或者以固定時間間隔週期執行，SimpleTrigger是最適合的選擇；而CronTrigger則能夠經過Cron表達式定義出各類複雜時間規則的調度方案：如每早晨9:00執行，周1、周3、週五下午5:00執行等；

　　●Calendar：org.quartz.Calendar和java.util.Calendar不一樣，它是一些日曆特定時間點的集合（能夠簡單地將org.quartz.Calendar看做java.util.Calendar的集合——java.util.Calendar表明一個日曆時間點，無特殊說明後面的Calendar即指org.quartz.Calendar）。一個Trigger能夠和多個Calendar關聯，以便排除或包含某些時間點。

　　假設，咱們安排每週星期一早上10:00執行任務，可是若是碰到法定的節日，任務則不執行，這時就須要在Trigger觸發機制的基礎上使用Calendar進行定點排除。針對不一樣時間段類型，Quartz在org.quartz.impl.calendar包下提供了若干個Calendar的實現類，如AnnualCalendar、MonthlyCalendar、WeeklyCalendar分別針對每一年、每個月和每週進行定義；

　　●Scheduler：表明一個Quartz的獨立運行容器，Trigger和JobDetail能夠註冊到Scheduler中，二者在Scheduler中擁有各自的組及名稱，組及名稱是Scheduler查找定位容器中某一對象的依據，Trigger的組及名稱必須惟一，JobDetail的組和名稱也必須惟一（但能夠和Trigger的組和名稱相同，由於它們是不一樣類型的）。Scheduler定義了多個接口方法，容許外部經過組及名稱訪問和控制容器中Trigger和JobDetail。

　　Scheduler能夠將Trigger綁定到某一JobDetail中，這樣當Trigger觸發時，對應的Job就被執行。一個Job能夠對應多個Trigger，但一個Trigger只能對應一個Job。能夠經過SchedulerFactory建立一個Scheduler實例。Scheduler擁有一個SchedulerContext，它相似於ServletContext，保存着Scheduler上下文信息，Job和Trigger均可以訪問SchedulerContext內的信息。SchedulerContext內部經過一個Map，以鍵值對的方式維護這些上下文數據，SchedulerContext爲保存和獲取數據提供了多個put()和getXxx()的方法。能夠經過Scheduler# getContext()獲取對應的SchedulerContext實例；

　　●ThreadPool：Scheduler使用一個線程池做爲任務運行的基礎設施，任務經過共享線程池中的線程提升運行效率。

　　Job有一個StatefulJob子接口，表明有狀態的任務，該接口是一個沒有方法的標籤接口，其目的是讓Quartz知道任務的類型，以便採用不一樣的執行方案。無狀態任務在執行時擁有本身的JobDataMap拷貝，對JobDataMap的更改不會影響下次的執行。而有狀態任務共享共享同一個JobDataMap實例，每次任務執行對JobDataMap所作的更改會保存下來，後面的執行能夠看到這個更改，也即每次執行任務後都會對後面的執行發生影響。

　　正由於這個緣由，無狀態的Job能夠併發執行，而有狀態的StatefulJob不能併發執行，這意味着若是前次的StatefulJob尚未執行完畢，下一次的任務將阻塞等待，直到前次任務執行完畢。有狀態任務比無狀態任務須要考慮更多的因素，程序每每擁有更高的複雜度，所以除非必要，應該儘可能使用無狀態的Job。

　　若是Quartz使用了數據庫持久化任務調度信息，無狀態的JobDataMap僅會在Scheduler註冊任務時保持一次，而有狀態任務對應的JobDataMap在每次執行任務後都會進行保存。

　　Trigger自身也能夠擁有一個JobDataMap，其關聯的Job能夠經過JobExecutionContext#getTrigger().getJobDataMap()獲取Trigger中的JobDataMap。無論是有狀態仍是無狀態的任務，在任務執行期間對Trigger的JobDataMap所作的更改都不會進行持久，也即不會對下次的執行產生影響。

　　Quartz擁有完善的事件和監聽體系，大部分組件都擁有事件，如任務執行前事件、任務執行後事件、觸發器觸發前事件、觸發後事件、調度器開始事件、關閉事件等等，能夠註冊相應的監聽器處理感興趣的事件。

7、Quartz的3大API之一 - Job

1.JobDetail & Job和JobDataMap

　　JobDetail是任務的定義，而Job是任務的執行邏輯。在JobDetail裏會引用一個Job Class定義。

　　每個JobDetail都會有一個JobDataMap。JobDataMap本質就是一個Map的擴展類，只是提供了一些更便捷的方法，好比getString()之類的。

仍是老樣子，編寫兩個類來看效果。

2.編寫觸發類 CronScheduler.java

public class HelloScheduler {
    public static void main(String[] args) throws SchedulerException {
        //1.建立一個jobDetail的實例，將該實例與HelloJob Class綁定
        JobDetail jobDetail = JobBuilder
                .newJob(HelloJob.class) //定義Job類爲HelloJob類，真正的執行邏輯所在
                .withIdentity("myJob", "group1") //定義name 和 group
                .usingJobData("message","hello myJob1") //加入屬性到jobDataMap
                .usingJobData("FloatJobValue",8.88f) //加入屬性到jobDataMap
                .build();

        //2.建立一個Trigger觸發器的實例，定義該job當即執行，而且每2秒執行一次，一直執行
        SimpleTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger", "group1")
                .startNow()
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(2).repeatForever())
                .build();
        //3.建立schedule實例
        StdSchedulerFactory factory = new StdSchedulerFactory();
        Scheduler scheduler = factory.getScheduler();
        scheduler.start(); //啓動
        scheduler.scheduleJob(jobDetail,trigger); // jobDetail和trigger加入調度

    }
}

3.編寫具體任務類HelloJob.java,並打印值

public class HelloJob implements Job{
  public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //打印當前的執行時間 例如 2017-11-22 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("如今的時間是："+ sf.format(date));
        //具體的業務邏輯
        System.out.println("開始生成任務報表 或 開始發送郵件....");
        JobKey key = jobExecutionContext.getJobDetail().getKey();
        System.out.println("jobDetail 的name ： "+key.getName());     //打印jobDetail 的name
        System.out.println("jobDetail 的group ： "+key.getGroup());    //打印jobDetail 的group
        JobDataMap jobDetailDataMap = jobExecutionContext.getJobDetail().getJobDataMap();
        String message = jobDetailDataMap.getString("message"); //
        float floatJobValue = jobDetailDataMap.getFloat("FloatJobValue");
        System.out.println("jobDataMap定義的message的值 : "+message );  //打印jobDataMap定義的message的值 
        System.out.println("jobDataMap定義的floatJobValue的值 : "+floatJobValue );   //jobDataMap定義的floatJobValue的值
    }
}

4.實現的效果

5.經過get、Set方式獲取dataMap中的值（修改一下HelloJob.java）便可

public class HelloJob implements Job{

    //這裏是第二種獲取jobDataMap中的值的方法
    private String message;
    private Float floatJobValue;
    private Double doubleTriggerValue;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public Float getFloatJobValue() {
        return floatJobValue;
    }

    public void setFloatJobValue(Float floatJobValue) {
        this.floatJobValue = floatJobValue;
    }

    public Double getDoubleTriggerValue() {
        return doubleTriggerValue;
    }

    public void setDoubleTriggerValue(Double doubleTriggerValue) {
        this.doubleTriggerValue = doubleTriggerValue;
    }

    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //打印當前的執行時間 例如 2017-11-22 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("如今的時間是："+ sf.format(date));
        System.out.println("jobDataMap定義的message的值 : "+message );  //打印jobDataMap定義的message的值
        System.out.println("jobDataMap定義的floatJobValue的值 : "+floatJobValue );   //jobDataMap定義的floatJobValue的值
　　 }
}

6.效果以下

8、Quartz的3大API之一 - Tigger

1.startTime和endTime

　　有時候咱們但願一個定時任務在必定的時間內是天天執行，好比2017年11月24日到2017年12月15日之間執行，這時候咱們就要使用startTime和endTime來限定事件範圍了。例子中咱們把時間規定在幾秒鐘以內運行，方便查看效果。

1.1編寫Scheduler類SecondScheduler.java

public class SecondScheduler {
    public static void main(String[] args) throws SchedulerException {
        //建立一個JobDetail的實例，將該實例與HelloJob綁定
        JobDetail jobDetail = JobBuilder.newJob(HelloJob.class).withIdentity("zhlJob").build();
        //開始時間 3秒鐘以後  （具體時間按實際業務編寫）
        Date sData = new Date();
        sData.setTime(sData.getTime()+3000); 
        //結束時間 6秒鐘以後 （具體時間按實際業務編寫）
        Date eData = new Date();
        eData.setTime(eData.getTime()+6000);
        //建立一個Trigger實例，定義該job3秒以後執行，在6秒以後結束
        SimpleTrigger zhlTrigger = TriggerBuilder.newTrigger().withIdentity("zhlTrigger")
                .startAt(sData) //設定開始時間
                .endAt(eData)   //設定結束時間
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(2).repeatForever()) //每兩秒打印一次
                .build();
        //建立Scheduler實例
        StdSchedulerFactory stdSchedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = stdSchedulerFactory.getScheduler();
        scheduler.start();
        scheduler.scheduleJob(jobDetail,zhlTrigger);
    }
}

1.2編寫job類

public class HelloJob implements Job{public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //打印當前的執行時間 例如 2017-11-22 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("如今的時間是："+ sf.format(date));
        //具體的業務邏輯
        System.out.println("具體執行的業務...");
        JobKey key = jobExecutionContext.getJobDetail().getKey();
        Trigger trigger = jobExecutionContext.getTrigger();
        System.out.println("開始的時間： "+sf.format(trigger.getStartTime())); //打印開始時間
        System.out.println("結束的事件： "+sf.format(trigger.getEndTime())); //打印結束時間
    }
}

1.3打印效果

2.BaseCalndar

此calendar不是java.util.Calendar，calendar是爲了補充Trigger的時間，能夠拍除了或加入一下特定的時間。Quartz 的 Calender 專門用於屏閉一個時間區間，使 Trigger 在這個區間中不被觸發。

2.1Quartz 包含了你的應用可用的許多的 Calender 類型

AnnualCalendar:排除每年中指定的一天或者多少天，精度是天
CronCalendar:使用表達式排除某些時間段不執行，精度取決於Cron表達式，最大精度到秒
DailyCalendar：指定的時間範圍內的每一天不執行，指定天天的時間段，格式是HH:MM[:SS[:mmm]]。也就是最大精度能夠到毫秒。
HolidayCalendar：排除節假日，精度到天
MonthlyCalendar：排除月份中的數天，可選值爲1-31。精度是天
WeeklyCalendar：排除星期中的一天或多天，可選值好比爲java.util.Calendar.SUNDAY，精度是天。

下面以AnnualCalendar舉例，來實現某一天不執行程序。

2.2編寫Scheduler類CalendarSchedule.java

public class CalendarSchedule {
    public static void main(String[] args) throws SchedulerException {
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //建立一個JobDetail的實例，將該實例與HelloJob綁定
        JobDetail jobDetail = JobBuilder.newJob(HelloJob.class).withIdentity("zhlJob").build();
        AnnualCalendar holidays = new AnnualCalendar();
        GregorianCalendar nationalDay = new GregorianCalendar(2017, 10, 27);  // 排除今天的時間2017年11月27日（月份是從0～11的）
        
        holidays.setDayExcluded(nationalDay,true); //排除的日期，若是爲false則爲包含*/
        //建立Scheduler實例
        StdSchedulerFactory stdSchedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = stdSchedulerFactory.getScheduler();
        //向Scheduler註冊日曆
        scheduler.addCalendar("holidays",holidays,false,false);
        Trigger simpleTrigger = TriggerBuilder.newTrigger()
                .withIdentity("zhlTrigger")
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(1).repeatForever()) //每一秒執行一次job
                .modifiedByCalendar("holidays")   //將咱們設置好的Calander與trigger綁定
                .build();
        //讓trigger應用指定的日曆規則
        //scheduler.scheduleJob(jobDetail,simpleTrigger);
        System.out.println("如今的時間 ："+sf.format(new Date()));
        System.out.println("最近的一次執行時間 ："+sf.format(scheduler.scheduleJob(jobDetail,simpleTrigger))); //scheduler與jobDetail、trigger綁定，並打印出最近一次執行的事件
        scheduler.start();
    }
}

2.3編寫job類，仍然使用HelloJob就能夠

public class HelloJob implements Job{public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //打印當前的執行時間 例如 2017-11-22 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("如今的時間是："+ sf.format(date));
        //具體的業務邏輯
        System.out.println("具體執行的業務...");
        Trigger trigger = jobExecutionContext.getTrigger();
        System.out.println("開始的時間： "+sf.format(trigger.getStartTime())); //打印開始時間
        System.out.println("結束的事件： "+sf.format(trigger.getEndTime())); //打印結束時間
}

2.4執行後的效果

能夠發現，我將程序設置爲2017年11月27日也就是今天不執行，並打印出了程序最近的一次的執行時間，是明天。因而可知，排除時間成功。

3.Trigger的實現類

SimpleTrigger和CronTrigger以前已經介紹過了，接下來介紹一下CalendarIntervalTrigger 和 DailyTimeIntervalTrigger

1.CalendarIntervalTrigger

CalendarIntervalTrigger：是一個具體的Trigger，用來觸發基於定時重複的JobDetail。

Trigger將會每隔N個calendar在trigger中定義的時間單元觸發一次。這個trigger不適合使用SimpleTrigger完成(例如因爲每個月的時間不是固定的描述)，也不適用於CronTrigger(例如每5個月)。

相較於SimpleTrigger有兩個優點：一、更方便，好比每隔1小時執行，你不用本身去計算1小時等於多少毫秒。二、支持不是固定長度的間隔，好比間隔爲月和年。但劣勢是精度只能到秒。

它適合的任務相似於：9:00 開始執行，而且之後每週 9:00 執行一次

它的屬性有:

interval 執行間隔
intervalUnit 執行間隔的單位（秒，分鐘，小時，天，月，年，星期）

例子：

CalendarIntervalScheduleBuilder
     .calendarIntervalSchedule()
     .withIntervalInDays(1)  //天天執行一次
   //.withIntervalInHours(1)
   //.withIntervalInMinutes(1)
   //.withIntervalInMonths(1)
   //.withIntervalInSeconds(1)
   //.withIntervalInWeeks(1)
   //.withIntervalInHours(1)
     .build()

2.DailyTimeIntervalTrigger

指定天天的某個時間段內，以必定的時間間隔執行任務。而且它能夠支持指定星期。

它適合的任務相似於：指定天天9:00 至 18:00 ，每隔70秒執行一次，而且只要週一至週五執行。

它的屬性有:

startTimeOfDay 天天開始時間
endTimeOfDay 天天結束時間
daysOfWeek 須要執行的星期
interval 執行間隔
intervalUnit 執行間隔的單位（秒，分鐘，小時，天，月，年，星期）
repeatCount 重複次數

2.1編寫Scheduler類

 public static void main(String[] args) throws SchedulerException {
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //1.建立一個jobDetail的實例，將該實例與HelloJob Class綁定
        JobDetail jobDetail = JobBuilder
                .newJob(HelloJob.class)
                .withIdentity("myJob", "group1") //定義name 和 group
                .build();

        //2.建立一個Trigger觸發器的實例
        Trigger simpleTrigger = TriggerBuilder.newTrigger()
                .withIdentity("zhlTrigger")
                .withSchedule(
                        DailyTimeIntervalScheduleBuilder.dailyTimeIntervalSchedule()
                                .startingDailyAt(TimeOfDay.hourAndMinuteOfDay(8, 0)) //天天8：00開始
                                .endingDailyAt(TimeOfDay.hourAndMinuteOfDay(17, 0)) //17：00 結束
                                .onDaysOfTheWeek(MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY) //週一至週五執行
                                .withIntervalInHours(1) //每間隔1小時執行一次
                                .withRepeatCount(100) //最多重複100次（實際執行100+1次）
                )
                .modifiedByCalendar("holidays")   //將咱們設置好的Calander與trigger綁定
                .build();

        //3.建立schedule實例
        StdSchedulerFactory factory = new StdSchedulerFactory();
        Scheduler scheduler = factory.getScheduler();
        System.out.println("如今的時間 ："+sf.format(new Date()));
        System.out.println();
        System.out.println("最近的一次執行時間 ："+sf.format(scheduler.scheduleJob(jobDetail,simpleTrigger))); //scheduler與jobDetail、trigger綁定，並打印出最近一次執行的事件
        scheduler.start();
    }

2.2打印的效果

9、總結：

雖然介紹了Quartz一些基本的用法，可是Quartz的強大不止這些，包括集成Spring，與Spring Boot的集成，quartz的listener，quartz的持久化，集羣，插件等等，以後會陸續的介紹。最後，quartz是一個基於java的很是成熟的任務調度框架，適合於任何常規的使用，以及個性化的開發使用，其次經過數據庫的持久化，能夠選擇實現集羣，大大增長了任務調度的可靠性，值得每一個程序人借鑑使用。