springboot開發之定時器quartz 定時任務排程(壓縮版,抽取quartz的單個任務表實現)

阿新 • • 發佈：2019-03-19

開發十年，就只剩下這套架構體系了！ >>>

前言

老了, 記不住了, 好記性不如爛筆頭;

沒想到曾經過目不忘的我, 也有這麼一天, 歲月蹉跎,學習一天不如一天

難受

Quartz可以用來做什麼？

Quartz是一個任務排程框架。比如你遇到這樣的問題

想每月25號，信用卡自動還款
想每年4月1日自己給當年暗戀女神發一封匿名賀卡
想每隔1小時，備份一下自己的愛情動作片學習筆記到雲盤

這些問題總結起來就是：在某一個有規律的時間點幹某件事。並且時間的觸發的條件可以非常複雜（比如每月最後一個工作日的17:50），複雜到需要一個專門的框架來幹這個事。 Quartz就是來幹這樣的事，你給它一個觸發條件的定義，它負責到了時間點，觸發相應的Job起來幹活。

彙總以上的, 就是兩點: 1.定時定點的執行任務(一次性), 2.迴圈執行任務(迴圈);

一個簡單的示例

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

import java.util.GregorianCalendar;

import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.calendar.AnnualCalendar;

public class QuartzTest {

    public static void main(String[] args) {
        try {
            //建立scheduler
            Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

            //定義一個Trigger
            Trigger trigger = newTrigger().withIdentity("trigger1", "group1") //定義name/group
                .startNow()//一旦加入scheduler，立即生效
                .withSchedule(CronScheduleBuilder.cronSchedule("0 0/2 8-17 * * ?"))//每天8:00-17:00，每隔2分鐘執行一次
                .build();

            //定義一個JobDetail
            JobDetail job = newJob(HelloQuartz.class) //定義Job類為HelloQuartz類，這是真正的執行邏輯所在
                .withIdentity("job1", "group1") //定義name/group
                .usingJobData("name", "quartz") //定義屬性
                .build();

            //加入這個排程
            scheduler.scheduleJob(job, trigger);

            //啟動之
            scheduler.start();

            //執行一段時間後關閉
            Thread.sleep(10000);
            scheduler.shutdown(true);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.util.Date;

import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
/** 具體業務類 **/

public class HelloQuartz implements Job {
    public void execute(JobExecutionContext context) throws JobExecutionException {
        JobDetail detail = context.getJobDetail();
        String name = detail.getJobDataMap().getString("name");
        System.out.println("say hello to " + name + " at " + new Date());
    }
}

針對以上程式碼做個小白可能會一臉懵逼;這裡做個解釋

Scheduler：排程器。所有的排程都是由它控制。
Trigger：定義觸發的條件。例子中，它的型別是SimpleTrigger，每隔1秒中執行一次（什麼是SimpleTrigger下面會有詳述）。
JobDetail & Job： JobDetail 定義的是任務資料，而真正的執行邏輯是在Job中，例子中是HelloQuartz。為什麼設計成JobDetail + Job，不直接使用Job？這是因為任務是有可能併發執行，如果Scheduler直接使用Job，就會存在對同一個Job例項併發訪問的問題。而JobDetail & Job 方式，sheduler每次執行，都會根據JobDetail建立一個新的Job例項，這樣就可以規避併發訪問的問題。

講重點

CronTrigger

適合於更復雜的任務，它支援型別於Linux Cron的語法（並且更強大）。基本上它覆蓋了以上三個Trigger的絕大部分能力（但不是全部）—— 當然，也更難理解。

它適合的任務類似於：每天0:00,9:00,18:00各執行一次。

它的屬性只有:

Cron表示式

位置	時間域	允許值	特殊值
1	秒	0-59	, - * /
2	分鐘	0-59	, - * /
3	小時	0-23	, - * /
4	日期	1-31	, - * ? / L W C
5	月份	1-12	, - * /
6	星期	1-7	, - * ? / L C #
7	年份（可選）	1-31	, - * /

星號()：可用在所有欄位中，表示對應時間域的每一個時刻，例如， 在分鐘欄位時，表示“每分鐘”；

問號（?）：該字元只在日期和星期欄位中使用，它通常指定為“無意義的值”，相當於點位符；

減號(-)：表達一個範圍，如在小時欄位中使用“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表示式對特殊字元的大小寫不敏感，對代表星期的縮寫英文大小寫也不敏感。

一些例子：

表示式	說明
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分執行。

JobDetail & Job

要定義一個任務，需要幹幾件事

建立一個org.quartz.Job的實現類，並實現實現自己的業務邏輯。比如上面的DoNothingJob。
定義一個JobDetail，引用這個實現類
加入scheduleJob

Quartz排程一次任務，會幹如下的事：

JobClass jobClass=JobDetail.getJobClass()
Job jobInstance=jobClass.newInstance()。所以Job實現類，必須有一個public的無參構建方法。
jobInstance.execute(JobExecutionContext context)。JobExecutionContext是Job執行的上下文，可以獲得Trigger、Scheduler、JobDetail的資訊。

也就是說，每次排程都會建立一個新的Job例項，這樣的好處是有些任務併發執行的時候，不存在對臨界資源的訪問問題——當然，如果需要共享JobDataMap的時候，還是存在臨界資源的併發訪問的問題。

JobDataMap

ob都次都是newInstance的例項，那我怎麼傳值給它？比如我現在有兩個傳送郵件的任務，一個是發給"liLei",一個發給"hanmeimei",不能說我要寫兩個Job實現類LiLeiSendEmailJob和HanMeiMeiSendEmailJob。實現的辦法是通過JobDataMap。

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

我們可以在定義JobDetail，加入屬性值，方式有二：

newJob().usingJobData("age", 18) //加入屬性到ageJobDataMap

 or

 job.getJobDataMap().put("name", "quertz"); //加入屬性name到JobDataMap

然後在Job中可以獲取這個JobDataMap的值，方式同樣有二：

public class HelloQuartz implements Job {
    private String name;

    public void execute(JobExecutionContext context) throws JobExecutionException {
        JobDetail detail = context.getJobDetail();
        JobDataMap map = detail.getJobDataMap(); //方法一：獲得JobDataMap
        System.out.println("say hello to " + name + "[" + map.getInt("age") + "]" + " at "
                           + new Date());
    }

    //方法二：屬性的setter方法，會將JobDataMap的屬性自動注入
    public void setName(String name) { 
        this.name = name;
    }
}

對於同一個JobDetail例項，執行的多個Job例項，是共享同樣的JobDataMap，也就是說，如果你在任務裡修改了裡面的值，會對其他Job例項（併發的或者後續的）造成影響。

除了JobDetail，Trigger同樣有一個JobDataMap，共享範圍是所有使用這個Trigger的Job例項。

Job併發

Job是有可能併發執行的，比如一個任務要執行10秒中，而排程演算法是每秒中觸發1次，那麼就有可能多個任務被併發執行。

有時候我們並不想任務併發執行，比如這個任務要去”獲得資料庫中所有未傳送郵件的名單“，如果是併發執行，就需要一個數據庫鎖去避免一個數據被多次處理。這個時候一個@DisallowConcurrentExecution解決這個問題。

就是這樣

public class DoNothingJob implements Job {
    @DisallowConcurrentExecution
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("do nothing");
    }
}

注意，@DisallowConcurrentExecution是對JobDetail例項生效，也就是如果你定義兩個JobDetail，引用同一個Job類，是可以併發執行的。

JobExecutionException

Job.execute()方法是不允許丟擲除JobExecutionException之外的所有異常的（包括RuntimeException)，所以編碼的時候，最好是try-catch住所有的Throwable，小心處理。

文中內容也是基本來自本篇: http://www.cnblogs.com/drift-ice/p/3817269.html

重點來了, 如何整合到springboot 呢

整合至springboot

1. 拆分表設計

不重複早輪子了, 剛好發現它, 很有意思;

https://www.cnblogs.com/softidea/p/7444998.html

原理就是: 單獨拆分定時表出來, 查詢任務, 新增任務, 修改任務狀態, 等均在這個表;

具體實現,完全可以參照上面說的

在springboot初始化時,

新增config類

package com.xx.xx.xxx.config;

import com.xxx.xxx.xxx.bean.dto.task.TaskConstant;
import com.xxx.xxx.xxx.bean.entity.XXX;
import com.xxx.xxx.xxx.env.quartz.JobTest;
import com.xxx.xxx.xxx.env.quartz.MyJobFactory;
import com.xxx.xxx.xxx.service.TaskService;
import lombok.extern.slf4j.Slf4j;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.util.List;

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

/**
 * 啟動專案時定時呼叫任務
 */
@Service
@Slf4j
public class QuartzConfig {


    @Autowired
    TaskService taskService;
    @Autowired
    Scheduler myScheduler;


    @PostConstruct  // spirngIOC初始化後, 標識執行該方法;
    private void startQuartzConfig() {
        log.info("啟動初始化完成,開始啟動定時任務");

        Scheduler sched = null;
        try {
            sched = myScheduler;
            sched.start();
            List<XXX> xxxList= taskService.getALLTasks();  // 查詢資料中, 所有已新增好的任務表
            for (XXX t : xxxList) {
                JobDetail job = newJob(JobTest.class)
                        .usingJobData(TaskConstant.SERVICE_ID, t.getId())
                        .withIdentity(t.getId() + ":task", TaskConstant.GROUP_NAME)
                        .build();
                // Trigger the job to run now, and then every 40 seconds
                Trigger trigger = newTrigger()
                        .withIdentity(kz01.getId() + ":trigger", TaskConstant.GROUP_NAME)
                        .startNow()
                        .withSchedule(CronScheduleBuilder.cronSchedule("*/5 * * * * ?")
                        .build();
                sched.scheduleJob(job, trigger);
            }
        } catch (SchedulerException e) {
            log.error("定時任務執行時出錯！", e);
        }
        log.info("定時任務初始化結束");
    }

}

package com.xxx.xxx.xxx.env.quartz;

import com.alibaba.fastjson.JSONObject;
import com.xxx.xxx.xxx.bean.dto.ResultSupport;
import com.xxx.xxx.xxx.bean.dto.auditcase.CasePointCountDTO;
import com.xxx.xxx.xxx.bean.dto.task.GroupingCaseDTO;
import com.xxx.xxx.xxx.bean.dto.task.TaskConstant; 
import com.xxx.xxx.xxx.controller.taskApi.TaskController;
import com.xxx.xxx.xxx.service.TaskService;
import lombok.extern.slf4j.Slf4j;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

import javax.xml.bind.util.JAXBSource;
import java.util.Date;


/*
* job啟動,可有效避免同步job執行*/
@DisallowConcurrentExecution
@Slf4j
public class JobTest implements Job {


    @Autowired
    TaskService taskService;
    @Autowired
    TaskController taskController;

 // 定時執行方法
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        Long serviceId = (Long) jobExecutionContext.getJobDetail().getJobDataMap().get(TaskConstant.SERVICE_ID); //獲取傳參值
        log.info("開始呼叫定時任務" + serviceId);
        Tast tempt = taskService.getTask(serviceId);//獲取單個任務詳情
        
        doTask();
    }

    public static  void doTask() {
         // 業務邏輯
    }
}

總結:

quartz 有多種分配方式, 重的, 有建立5個表, 可具體跟蹤定位任務執行情況,適合大型專案;

比如這篇文章: https://www.cnblogs.com/nick-huang/p/8456272.html

拆分個人任務表(job_task)整合到專案中, 如上 , 精簡版, 僅僅用來一個小量的定時業務;

完結撒花;

springboot開發之定時器quartz 定時任務排程(壓縮版,抽取quartz的單個任務表實現)

前言

Quartz可以用來做什麼？

CronTrigger

JobDetail & Job

JobDataMap

Job併發

JobExecutionException

整合至springboot

springboot開發之定時器quartz 定時任務排程(壓縮版,抽取quartz的單個任務表實現)

springboot項目，啟動項目後啟動的定時器，定時執行任務

springboot專案，啟動專案後啟動的定時器，定時執行任務

Spring boot之攔截器與定時任務的實現

Atitit 定時器timer 總結目錄 1. 定時器迴圈定時器和timeout超時定時器 1 2. Spring定時器 1 2.1. 大概流程 1 2.2. 核心原始碼springboot 1

關於Spring中用quartz定時器在定時到達時同時執行兩次的問題

SpringBoot 定時器(動態定時器)的使用

Java 中Timer和TimerTask 定時器和定時任務使用的例子

Java定時器 spring定時器及cron表示式(quartz中時間表達式)

Atitit 定時器timer 總結目錄 1. 定時器迴圈定時器和timeout超時定時器 1 2. Spring定時器 1 2.1. 大概流程 1 2.2. 核心原始碼springboot 1

Spring --- java定時器,Spring定時器和Quartz定時器

JS的多種提示框、定時器、定時任務

STM32-通用定時器基本定時功能

十、python開發之裝飾器

【CC2530強化實訓03】定時器間隔定時實現按鍵N連擊

Broadcast基礎（使用廣播，傳送臨時廣播，註冊接收器，通過定時器設定定時廣播）

javaWeb開發之攔截器和過濾器的區別

晝貓筆記 JavaScript -- 非同步執行 | 定時器真的定時執行？

【Spring 定時器】定時器 No qualifying bean of type [org.springframework.scheduling.TaskScheduler] is defined

【CC2530強化實訓03】定時器間隔定時實現按鍵長按與短按

springboot開發之定時器quartz 定時任務排程(壓縮版,抽取quartz的單個任務表實現)

前言

Quartz可以用來做什麼？

CronTrigger

JobDetail & Job

JobDataMap

Job併發

JobExecutionException

整合至springboot

相關推薦