一、 SpringBoot自帶的定時任務

在采用SpringBoot框架的應用中，只需要簡單的兩個步驟就能實現(xiàn)定時任務的使用。

1. 創(chuàng)建Job類

@Slf4j
@Component
public class JobTest {
    @Scheduled(cron = "0/5 * * * * ?")
    public void job1(){
        log.info("job1 running...");
    }

    @Scheduled(fixedRate = 2000)
    public void job2(){
        log.info("job2 running...");
    }
}

2. 在啟動類上啟用調(diào)度策略

@EnableScheduling
@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

如上兩個步驟，就能使得我們定義的兩個JOB按照設置的頻率執(zhí)行了。

那么問題來了，既然springboot都自帶了任務調(diào)度的功能，而且使用起來還那么簡單，我們?yōu)樯哆€要使用Quartz呢？

原因當然是其自帶的任務調(diào)用擁有如下的一些缺點：

• cron表達式不支持年；
  在如上的例子中我們可以看到cron表達式只能寫6位，不支持對年的設置，否則就會報錯，而Quartz就可以設置年。
• 所有JOB都是共享一個線程；
  為了證明這一點，我們需要對如上的例子做下更改，我們假設job1需要執(zhí)行10秒，然后job2還是按照固定頻率每2秒執(zhí)行一次。

    @Scheduled(cron = "0/5 * * * * ?")
    public void job1() throws InterruptedException {
        log.info("job1 running...");
        Thread.sleep(10000);
        log.info("job1 end...");
    }

    @Scheduled(fixedRate = 2000)
    public void job2(){
        log.info("job2 running...");
    }

然后會發(fā)現(xiàn)，job1運行的10秒期間內(nèi)阻塞了job2的運行，等到job1運行完，job2才會一次性把錯過的都補執(zhí)行完。當然，也有別的方案可以彌補這個問題，比如給其配置線程池，但是會比較麻煩，不如Quartz來的簡便，Quartz有默認線程數(shù)，省去了初學者配置。

• 系統(tǒng)重啟，任務丟失（待驗證）；
• 不支持分布式任務調(diào)度（待驗證）；

二、使用Quartz任務調(diào)度框架

1.1 Quartz的基本要素介紹

• Job，用來定義我們自己要執(zhí)行的任務；
• JobDetail，用來綁定具體的Job，支持多個JobDetail綁定同一個Job，實現(xiàn)同一個Job的并發(fā)。
• Trigger，觸發(fā)器用來定義我們的JobDetail以什么樣的方式開始工作；
• Scheduler，調(diào)度器，用來綁定JobDetail和Trigger，并控制任務的開始、暫停和終結(jié)。

1.2 最簡單的一個入門案例

我們需要創(chuàng)建一個任務，每2秒鐘控制臺告訴我現(xiàn)在幾點了。

import lombok.extern.slf4j.Slf4j;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import java.util.Date;

@Slf4j
public class HelloJob implements Job {

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        log.info("開始執(zhí)行時間是： {}", new Date());
    }
}

import lombok.extern.slf4j.Slf4j;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

@Slf4j
public class JobMain {

    public static void main(String[] args) throws SchedulerException {
        // 創(chuàng)建JobDetail，用來綁定具體的Job
        JobDetail jd = JobBuilder.newJob(HelloJob.class).withIdentity("job1", "group1").build();

        // 創(chuàng)建Trigger，定義任務的調(diào)度形式
        SimpleScheduleBuilder ss = SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(2).repeatForever();
        CronScheduleBuilder cs = CronScheduleBuilder.cronSchedule("0/2 * * * * ?");
        Trigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "triggerGroup1")
                .startNow()
                .withSchedule(cs)
                .build();

        // 創(chuàng)建調(diào)度器
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = schedulerFactory.getScheduler();
        // 執(zhí)行-使用調(diào)度器調(diào)度trigger和job
        scheduler.scheduleJob(jd, trigger);
        scheduler.start();

        log.info("主線程結(jié)束");
    }

}

好了，如上就能完成我們的任務，每2秒鐘在控制臺打印出當前的日期時間了。

在這個例子中，有以下幾點需要補充說明下：

• JobDetail和Trigger中的withIdentity都不是必須的，不設置它們我們的任務照樣能夠按照要求運行，而設置它們是為了給它們一個身份標識，通過name和group來唯一確定它們。
• SimpleScheduleBuilder和CronScheduleBuilder是兩種觸發(fā)器調(diào)度類型，在功能實現(xiàn)上是完全一樣的。但是在一般開發(fā)中，CronScheduleBuilder更加常用一些，它更加地簡便靈活，開發(fā)者也不用記住那么多的方法調(diào)用。
• 當scheduler執(zhí)行start之后，就會新起一個線程去執(zhí)行我們的JOB，而當前的主線程就運行完畢了。

1.3 Job的并發(fā)

我們假設要執(zhí)行的任務需要耗時5秒，但是任務本身是2秒觸發(fā)一次的，那么問題來了，當任務第一次觸發(fā)后，第二次觸發(fā)是等第一次任務完成，還是不等它完成，按照原調(diào)度計劃觸發(fā)呢？

@Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        log.info("開始執(zhí)行時間是： {}", new Date());
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("結(jié)束執(zhí)行時間是： {}", new Date());
    }

我們將例子改造成如上之后，再來運行試下，輸出如下：

開始執(zhí)行時間是： Thu Nov 07 13:39:36 CST 2019
開始執(zhí)行時間是： Thu Nov 07 13:39:38 CST 2019
開始執(zhí)行時間是： Thu Nov 07 13:39:40 CST 2019
結(jié)束執(zhí)行時間是： Thu Nov 07 13:39:41 CST 2019
開始執(zhí)行時間是： Thu Nov 07 13:39:42 CST 2019
結(jié)束執(zhí)行時間是： Thu Nov 07 13:39:43 CST 2019
............

實驗結(jié)論就出來了，同一Job的后續(xù)執(zhí)行開始時間是不會受到上一次執(zhí)行是否完成影響的，也就是說默認情況下，同一個Job是可以并發(fā)執(zhí)行的。

可我們想要后續(xù)任務執(zhí)行必須等上一次執(zhí)行完畢后才能開始怎么辦呢？只需要禁止該JOB并發(fā)執(zhí)行即可。

@Slf4j
@DisallowConcurrentExecution
public class HelloJob implements Job {
..........
}

再次執(zhí)行，輸出結(jié)果如下：

開始執(zhí)行時間是： Thu Nov 07 14:54:12 CST 2019
結(jié)束執(zhí)行時間是： Thu Nov 07 14:54:17 CST 2019
開始執(zhí)行時間是： Thu Nov 07 14:54:17 CST 2019
結(jié)束執(zhí)行時間是： Thu Nov 07 14:54:22 CST 2019
開始執(zhí)行時間是： Thu Nov 07 14:54:22 CST 2019
結(jié)束執(zhí)行時間是： Thu Nov 07 14:54:27 CST 2019
開始執(zhí)行時間是： Thu Nov 07 14:54:27 CST 2019
..........

需要注意的是，我們禁止并發(fā)其實禁止的是JobDetail，一個具體的JobDetail才代表我們真正的任務，雖然@DisallowConcurrentExecution注解是加在Job類上的。

我們下面來一個例子，兩個不同的JobDetail綁定同一個Job，且在Job類上標明禁止并發(fā)，那么這兩個JobDetail會同時執(zhí)行嗎？

@Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        log.info("{} 開始執(zhí)行時間是： {}", jobExecutionContext.getJobDetail().getKey().getName() , new Date());
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("{} 結(jié)束執(zhí)行時間是： {}", jobExecutionContext.getJobDetail().getKey().getName() , new Date());
    }

public static void main(String[] args) throws SchedulerException {
        // 創(chuàng)建調(diào)度器Scheduler
        SchedulerFactory sf = new StdSchedulerFactory();
        Scheduler scheduler = sf.getScheduler();

        // 創(chuàng)建JobDetail，用來綁定具體的Job
        JobDetail jd1 = JobBuilder.newJob(HelloJob.class).withIdentity("job1", "group1").build();
        JobDetail jd2 = JobBuilder.newJob(HelloJob.class).withIdentity("job2", "group1").build();

        // 創(chuàng)建Trigger，定義任務的調(diào)度形式
        SimpleScheduleBuilder ss = SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(2).repeatForever();
        CronScheduleBuilder cs = CronScheduleBuilder.cronSchedule("0/2 * * * * ?");
        Trigger trigger1 = TriggerBuilder.newTrigger().withIdentity("trigger1", "triggerGroup1")
                .startNow()
                .withSchedule(cs)
                .build();
        Trigger trigger2 = TriggerBuilder.newTrigger().withIdentity("trigger2", "triggerGroup1")
                .startNow()
                .withSchedule(ss)
                .build();

        // 執(zhí)行-使用調(diào)度器調(diào)度trigger和job
        scheduler.scheduleJob(jd1, trigger1);
        scheduler.scheduleJob(jd2, trigger2);
        scheduler.start();

        log.info("主線程結(jié)束");
    }

執(zhí)行結(jié)果如下：

job2 開始執(zhí)行時間是： Thu Nov 07 15:30:03 CST 2019
job1 開始執(zhí)行時間是： Thu Nov 07 15:30:04 CST 2019
job2 結(jié)束執(zhí)行時間是： Thu Nov 07 15:30:08 CST 2019
job2 開始執(zhí)行時間是： Thu Nov 07 15:30:08 CST 2019
job1 結(jié)束執(zhí)行時間是： Thu Nov 07 15:30:09 CST 2019
job1 開始執(zhí)行時間是： Thu Nov 07 15:30:09 CST 2019
job2 結(jié)束執(zhí)行時間是： Thu Nov 07 15:30:13 CST 2019
...........

如此，我們可以確定如上的結(jié)論，不同JobDetail的Job是可以并發(fā)執(zhí)行的。

1.4 Job的Misfire

Misfire策略主要是為了解決我們的Job錯過了某些執(zhí)行時機該怎么處理的問題，是等待下一次時機呢還是補救所有錯過的執(zhí)行時機？

首先，我們需要了解misfireThreshold這個參數(shù)值，其默認值是60秒，表示，任務晚于原計劃執(zhí)行時間60秒之后，才判定該次執(zhí)行是錯過了，否則，就不算錯過，任務立馬開始執(zhí)行。

為了驗證這一點，我們需要更改實驗示例，首先將任務的啟動改為每10秒運行一次，然后通過JobDetail傳入?yún)?shù)來決定Job每次執(zhí)行需要耗費的時間：

JobDetail jd = JobBuilder.newJob(HelloJob.class).withIdentity("job1", "group1")
                .usingJobData("sleepTime",12).build();

然后在具體的Job中，每次執(zhí)行都動態(tài)地更改執(zhí)行耗費的時間，從而能讓后續(xù)執(zhí)行時能恢復計劃，不再misfire。

@Slf4j
// 每次執(zhí)行修改的參數(shù)sleepTime都能保留到下一次執(zhí)行
@PersistJobDataAfterExecution
// 禁止單個JobDetail并發(fā)執(zhí)行
@DisallowConcurrentExecution
public class HelloJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) {
        log.info("開始執(zhí)行時間是： {}", new Date());
        int sleepTime = (Integer) jobExecutionContext.getJobDetail().getJobDataMap().get("sleepTime");
        log.info("任務需要休眠{}秒",sleepTime);
        try {
            Thread.sleep(sleepTime * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if(sleepTime > 3){
            sleepTime -= 3;
            jobExecutionContext.getJobDetail().getJobDataMap().put("sleepTime", sleepTime);
        }
    }
}

然后得到運行結(jié)果如下：

開始執(zhí)行時間是： Thu Nov 14 21:56:30 CST 2019
任務需要休眠12秒
開始執(zhí)行時間是： Thu Nov 14 21:56:42 CST 2019
任務需要休眠9秒
開始執(zhí)行時間是： Thu Nov 14 21:56:51 CST 2019
任務需要休眠6秒
開始執(zhí)行時間是： Thu Nov 14 21:57:00 CST 2019
任務需要休眠3秒
開始執(zhí)行時間是： Thu Nov 14 21:57:10 CST 2019
任務需要休眠3秒
開始執(zhí)行時間是： Thu Nov 14 21:57:20 CST 2019
任務需要休眠3秒
..........

我們可以看出來，第二次和第三次的執(zhí)行都misfire了，但是因為沒有超過60秒，所以都可以立即得到執(zhí)行，后續(xù)第四次開始，就仍然按照原計劃執(zhí)行。

然后，我們再來了解Misfire超過默認60秒之后的策略，對于不同的Trigger是擁有不通的Misfire策略的，此處我們先只看CronTrigger的三種策略：

• withMisfireHandlingInstructionFireAndProceed，這是默認的策略，我們可以不在代碼中添加，也可以手動加上：

CronScheduleBuilder cs = CronScheduleBuilder.cronSchedule("10 * * * * ?")
.withMisfireHandlingInstructionFireAndProceed();

意思是，錯過多少次就不去補救了，現(xiàn)在立馬執(zhí)行一次，后續(xù)則是按照原計劃執(zhí)行。
我們修改如上的例子，將任務改為每分鐘的第10秒開始，并且傳遞到JobDetail中的初始sleepTime為223秒，然后每次執(zhí)行耗費時間衰減3倍：

        if(sleepTime > 3){
            sleepTime /= 3;
            jobExecutionContext.getJobDetail().getJobDataMap()
.put("sleepTime", sleepTime);
        }

其執(zhí)行結(jié)果為：

開始執(zhí)行時間是： Thu Nov 14 22:23:10 CST 2019
任務需要休眠223秒
開始執(zhí)行時間是： Thu Nov 14 22:26:53 CST 2019
任務需要休眠74秒
開始執(zhí)行時間是： Thu Nov 14 22:28:07 CST 2019
任務需要休眠24秒
開始執(zhí)行時間是： Thu Nov 14 22:28:31 CST 2019
任務需要休眠8秒
開始執(zhí)行時間是： Thu Nov 14 22:29:10 CST 2019
任務需要休眠2秒
開始執(zhí)行時間是： Thu Nov 14 22:30:10 CST 2019
任務需要休眠2秒
..........

可以看到，原本計劃在22:24:10、22:25:10執(zhí)行的全部misfire超過60秒，而計劃在22:26:10執(zhí)行的雖然沒有misfire超過60秒，但會和之前所有misfire的任務合并成一個，在休眠結(jié)束后立即執(zhí)行。后續(xù)就沒有misfire超過60秒的任務了，因此就按照misfire小于60秒的機制進行處理。

• withMisfireHandlingInstructionDoNothing，意思是，所有錯過的都不去補救了，直接按照原計劃執(zhí)行。
  我們還是使用上面的示例，只不過更換策略為：

CronScheduleBuilder cs = CronScheduleBuilder.cronSchedule("10 * * * * ?")
.withMisfireHandlingInstructionDoNothing();

執(zhí)行結(jié)果為：

開始執(zhí)行時間是： Thu Nov 14 23:00:10 CST 2019
任務需要休眠223秒
開始執(zhí)行時間是： Thu Nov 14 23:04:10 CST 2019
任務需要休眠74秒
開始執(zhí)行時間是： Thu Nov 14 23:05:24 CST 2019
任務需要休眠24秒
開始執(zhí)行時間是： Thu Nov 14 23:06:10 CST 2019
任務需要休眠8秒
開始執(zhí)行時間是： Thu Nov 14 23:07:10 CST 2019
任務需要休眠2秒
..........

可以看到，計劃于23:01:10、23:02:10、23:03:10執(zhí)行的任務全部misfire了，任務休眠到23:03:53結(jié)束，此時雖然23:03:10misfire不超過60秒，但和前面misfire超過60秒的一樣，全部被忽略，等到下一個計劃時間23:04:10才重新執(zhí)行。后續(xù)就沒有misfire超過60秒的任務了，因此就按照misfire小于60秒的機制進行處理。

• withMisfireHandlingInstructionIgnoreMisfires，意思是，所有錯過的都需要按照順序一個個補執(zhí)行。
  我們還是使用上面的示例，只不過更換策略為：

CronScheduleBuilder cs = CronScheduleBuilder.cronSchedule("10 * * * * ?").withMisfireHandlingInstructionIgnoreMisfires();

執(zhí)行結(jié)果為：

開始執(zhí)行時間是： Thu Nov 14 23:19:10 CST 2019
任務需要休眠223秒
開始執(zhí)行時間是： Thu Nov 14 23:22:53 CST 2019
任務需要休眠74秒
開始執(zhí)行時間是： Thu Nov 14 23:24:07 CST 2019
任務需要休眠24秒
開始執(zhí)行時間是： Thu Nov 14 23:24:31 CST 2019
任務需要休眠8秒
開始執(zhí)行時間是： Thu Nov 14 23:24:39 CST 2019
任務需要休眠2秒
開始執(zhí)行時間是： Thu Nov 14 23:24:41 CST 2019
任務需要休眠2秒
開始執(zhí)行時間是： Thu Nov 14 23:25:10 CST 2019
任務需要休眠2秒
..........

可以看出，原計劃23:20:10、23:21:10、23:22:10全部misfire了，此時總計misfire3個任務；然后等任務休眠到23:22:53結(jié)束時，立即補充執(zhí)行一次，然后23:23:10的任務misfire，此時總計misfire3個任務；等任務休眠到23:24:07結(jié)束時，再立即補充執(zhí)行一次，然后23:24:10的任務misfire，此時總計misfire3個任務；然后在23:24:31、23:24:39、23:24:41補充執(zhí)行了3次，此時已經(jīng)沒有misfire的任務了，然后再按照原計劃執(zhí)行。

1.5 監(jiān)聽器的使用

監(jiān)聽器主要分為Job監(jiān)聽器、Trigger監(jiān)聽器和Scheduler監(jiān)聽器，分別用來監(jiān)聽各自事件觸發(fā)或者生命周期的，從而能在特定的事件前后做一些事情，比如做消息通知、執(zhí)行記錄等。

• Job監(jiān)聽器
  我們先創(chuàng)建一個Job監(jiān)聽器：

@Slf4j
public class HelloListener implements JobListener {
    @Override
    public String getName() {
        String listenerName = this.getClass().getSimpleName();
        log.info("當前監(jiān)聽器的名字是：{}", listenerName);
        return this.getClass().getSimpleName();
    }

    @Override
    public void jobToBeExecuted(JobExecutionContext jobExecutionContext) {
        String jobName = jobExecutionContext.getJobDetail().getKey().getName();
        log.info("{}將要被執(zhí)行了...", jobName);
    }

    @Override
    public void jobExecutionVetoed(JobExecutionContext jobExecutionContext) {
        String jobName = jobExecutionContext.getJobDetail().getKey().getName();
        log.info("{}被取消執(zhí)行了...", jobName);
    }

    @Override
    public void jobWasExecuted(JobExecutionContext jobExecutionContext, JobExecutionException e) {
        String jobName = jobExecutionContext.getJobDetail().getKey().getName();
        log.info("{}已經(jīng)執(zhí)行完畢?。?！", jobName);
    }
}

然后在scheduler中注冊該監(jiān)聽器：

// 創(chuàng)建一個全局的Job監(jiān)聽器
scheduler.getListenerManager()
.addJobListener(new HelloListener(), EverythingMatcher.allJobs());

全局監(jiān)聽器的意思，就是無論多少Job，它們有幾個分組，全部都會使用該監(jiān)聽器進行事件觸發(fā)。

如果我們只是想監(jiān)聽某個特定的Job，可以這么注冊監(jiān)聽器：

// 通過Job的name和groupName來唯一綁定一個Job
scheduler.getListenerManager().addJobListener(new HelloListener()
, KeyMatcher.keyEquals(JobKey.jobKey("byeJob", "group2")));

如果我們只是想監(jiān)聽某個分組的所有Job，可以這么注冊監(jiān)聽器：

// 通過分組的名稱來綁定某一組或者多組的Job
scheduler.getListenerManager().addJobListener(new HelloListener()
, GroupMatcher.jobGroupEquals("group1"));

如果我們既想綁定某組Job，又想綁定其他組中的某個Job，可以這樣注冊：

scheduler.getListenerManager().addJobListener(new HelloListener()
, OrMatcher.or(GroupMatcher.jobGroupEquals("group1")
, KeyMatcher.keyEquals(JobKey.jobKey("byeJob", "group2"))));

• Trigger監(jiān)聽器
  大體用法同JobListener，我們簡單過一下，先創(chuàng)建一個TriggerListener：

public class HelloTrigger implements TriggerListener {
    @Override
    public String getName() {
        String triggerName = this.getClass().getSimpleName();
        log.info("當前觸發(fā)器監(jiān)聽器的名字是：{}", triggerName);
        return this.getClass().getSimpleName();
    }

    @Override
    public void triggerFired(Trigger trigger, JobExecutionContext context) {
        String jobName = context.getJobDetail().getKey().getName();
        String triggerName = trigger.getKey().getName();
        log.info("{}將要被{}執(zhí)行了...", jobName, triggerName);
    }

    @Override
    public boolean vetoJobExecution(Trigger trigger, JobExecutionContext context) {
        String triggerName = trigger.getKey().getName();
        log.info("{}觸發(fā)器vote...", triggerName);
        // 如果返回true，則Job會被取消執(zhí)行，并且觸發(fā)JobListener中的jobExecutionVetoed方法
        return false;
    }

    @Override
    public void triggerMisfired(Trigger trigger) {
        String triggerName = trigger.getKey().getName();
        log.info("{}觸發(fā)器misfire了...", triggerName);
    }

    @Override
    public void triggerComplete(Trigger trigger, JobExecutionContext context, Trigger.CompletedExecutionInstruction triggerInstructionCode) {
        String jobName = context.getJobDetail().getKey().getName();
        String triggerName = trigger.getKey().getName();
        log.info("{}將{}執(zhí)行完畢！??！", jobName, triggerName);
    }
}

然后在scheduler中注冊該監(jiān)聽器：

scheduler.getListenerManager().addTriggerListener(new HelloTrigger(), EverythingMatcher.allTriggers());

• Scheduler監(jiān)聽器
  大體用法同JobListener，當增刪Job、Trigger或者Scheduler自己觸發(fā)生命周期時可以使用：

@Slf4j
public class SchedulerListener implements org.quartz.SchedulerListener {
      // 內(nèi)容較多，此處不再展示
}

然后注冊該監(jiān)聽器：

scheduler.getListenerManager().addSchedulerListener(new SchedulerListener());

1.6 使用配置文件

如果我們沒有創(chuàng)建自己的quartz.properties的話，就會默認使用jar包中的。并不是所有的配置項都需要我們進行配置。

這里是一份常用的配置列表：
Quartz配置文件常用配置項
更加詳細的配置可以參考：
Quartz配置參考

1.7 SpringBoot整合Quartz的最佳實踐

如果按照上面的示例使用Quartz的話，將會存在如下問題：

• WEB應用打包部署后如何啟動所有的JOB？
• 如何管理所有的JOBDetail和Trigger?
• 如何管理Cron表達式？

如果使用SpringBoot的話，這些問題都可以得到解決，如下是一個實際開發(fā)中常用的案例。
首先，第一步我們需要引入springboot中關于quartz的啟動器，之前引入的單獨Quartz依賴可以不需要了。

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>

然后，我們創(chuàng)建需要的JOB

@Slf4j
public class HelloJob extends QuartzJobBean {
    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        log.info("{}開始執(zhí)行時間是：{}", jobExecutionContext.getJobDetail().getKey().getName(), new Date());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("{}結(jié)束執(zhí)行時間是：{}", jobExecutionContext.getJobDetail().getKey().getName(), new Date());
    }
}

@Slf4j
public class ByeJob extends QuartzJobBean {
    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        log.info("{}開始執(zhí)行時間是：{}", jobExecutionContext.getJobDetail().getKey().getName(), new Date());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("{}結(jié)束執(zhí)行時間是：{}", jobExecutionContext.getJobDetail().getKey().getName(), new Date());
    }
}

最后，我們需要創(chuàng)建一個配置類，來管理所有的JobDetail和Trigger。

@Configuration
@PropertySource("cron.properties")
public class QuartzConfig {
    @Value("${helloJob.cron}")
    private String helloJobCron;
    @Value("${byeJob.cron}")
    private String byeJobCron;

    // HelloJob的啟動配置信息
    @Bean
    public JobDetail helloJobDetail(){
        return JobBuilder.newJob(HelloJob.class)
                .withIdentity("helloJob","myJobGroup")
                .storeDurably()
                .build();
    }

    @Bean
    public Trigger helloJobTrigger(){
        return TriggerBuilder.newTrigger()
                .forJob(helloJobDetail())
                .withIdentity("helloJobTrigger","myTriggerGroup")
                .startNow()
                .withSchedule(CronScheduleBuilder.cronSchedule(helloJobCron))
                .build();
    }
    //############################
    // ByeJob的啟動配置信息
    @Bean
    public JobDetail byeJobDetail(){
        return JobBuilder.newJob(ByeJob.class)
                .withIdentity("byeJob","myJobGroup")
                .storeDurably()
                .build();
    }
    @Bean
    public Trigger byeJobTrigger(){
        return TriggerBuilder.newTrigger()
                .forJob(byeJobDetail())
                .withIdentity("byeJobTrigger","myTriggerGroup")
                .startNow()
                .withSchedule(CronScheduleBuilder.cronSchedule(byeJobCron))
                .build();
    }
}

其中，所有的cron表達式我們使用properties文件進行管理：

helloJob.cron=0/5 * * * * ?
byeJob.cron=0/10 * * * * ?

如果需要管理的JOB太多了，一個配置文件會顯得內(nèi)容很長，那么可以為每一個JOB創(chuàng)建一個單獨的配置類，比如HelloJobConfig.java和ByeJobConfig.java，然后將如上配置文件中各自的內(nèi)容挪到各個單獨的配置文件中即可。

如此，在我們需要更改某個JOB執(zhí)行時間或者管理JOB的時候，就更加的方便了。