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

前言

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

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

難受

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

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

1. 建立一個org.quartz.Job的實現類，並實現實現本身的業務邏輯。好比上面的DoNothingJob。
2. 定義一個JobDetail，引用這個實現類
3. 加入scheduleJob

Quartz調度一次任務，會幹以下的事：

1. JobClass jobClass=JobDetail.getJobClass()
2. Job jobInstance=jobClass.newInstance()。因此Job實現類，必須有一個public的無參構建方法。
3. 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)集成到項目中, 如上 , 精簡版, 僅僅用來一個小量的定時業務;

 

完結撒花;