慕課網_《Java定時任務調度工具詳解之Quartz篇》學習總結

hiYoHoo 發布于2019-08-15 10:36 / 3328人閱讀

摘要：時間年月日星期一說明本文部分內容均來自慕課網。屬性任務名稱任務所屬組任務實現類傳參的作用淺談上是什么當調用一個，就會將傳遞給的方法能通過對象訪問到運行時候的環境以及本身的明細數據。

時間：2017年06月26日星期一
說明：本文部分內容均來自慕課網。@慕課網：http://www.imooc.com
教學示例源碼：https://github.com/zccodere/s...
個人學習源碼：https://github.com/zccodere/s...

第一章：課程介紹 1-1 初識Quartz

Quartz概要

OpenSymphony提供的強大的開源任務調度框架
官網：http://www.quartz-scheduler.org
純Java實現，精細控制排程

Quartz特點

強大的調度功能
靈活的應用方式
分布式和集群能力

Quartz的設計模式

Builder模式
Factory模式
組件模式
鏈式寫法

Quartz三個核心概念

調度器
任務
觸發器

Quartz體系結構

JobDetail
trigger
    SimpleTrigger
    CronTrigger
scheduler
    start
    stop
    pause
    resume

示意圖

Quartz重要組成

Job
JobDetail
JobBuilder
JobStore
Trigger
TriggerBuilder
ThreadPool
Scheduler
Calendar：一個Trigger可以和多個Calendar關聯，以排除或包含某些時間點
監聽器
    JobListener
    TriggerListener
    SchedulerListener

第二章：Quartz詳解 2-1 第一個Quartz程序

準備工作

建立Maven項目工程
引入Quartz包

編寫第一個Quartz任務

讓任務每隔兩秒打印一次hellworld

代碼演示

1.編寫任務類

package com.myimooc.helloquartz.one;

import java.text.SimpleDateFormat;
import java.util.Date;

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

/**
 * 編寫 自定義任務
 * @author ZhangCheng on 2017-06-26
 *
 */
public class HelloJob implements Job{
    
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 打印當前的執行時間，格式為2017-01-01 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("Current Exec Time Is : " + sf.format(date));
        
        // 編寫具體的業務邏輯
        System.out.println("Hello World!");
    }
    
}

2.編寫任務調度類

package com.myimooc.helloquartz.one;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

/**
 * 編寫 任務調度類
 * @author ZhangCheng on 2017-06-26
 *
 */
public class HelloScheduler {
    
    public static void main(String[] args) throws SchedulerException {
        
        // 創建一個 JobDetail 實例，將該實例與 HelloJob 實例綁定
        JobDetail jobDeatil = JobBuilder.newJob(HelloJob.class)
                .withIdentity("myjob", "jobgroup1")// 定義標識符
                .build();
        
        System.out.println("jobDetail"s name : " + jobDeatil.getKey().getName());
        System.out.println("jobDetail"s group : " + jobDeatil.getKey().getGroup());
        System.out.println("jobDetail"s jobClass : " + jobDeatil.getJobClass().getName());
        
        // 創建一個 Trigger 實例，定義該 job 立即執行，并且每隔兩秒重復執行一次，直到永遠
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger","trigroup1")// 定義標識符
                .startNow()// 定義立即執行
                .withSchedule(SimpleScheduleBuilder
                        .simpleSchedule()
                        .withIntervalInSeconds(2)
                        .repeatForever())// 定義執行頻度
                .build();
        
        // 創建 Scheduler 實例
        SchedulerFactory sfact = new StdSchedulerFactory();
        Scheduler scheduler = sfact.getScheduler();
        
        // 綁定 JobDetail 和 trigger
        scheduler.scheduleJob(jobDeatil, trigger);
        
        // 執行任務
        scheduler.start();
        
        // 打印當前的執行時間，格式為2017-01-01 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("Current Time Is : " + sf.format(date));
    }
    
}

2-2 淺談Job&JobDetail

Job定義

實現業務邏輯的任務接口

淺談Job

Job接口非常容易實現，只有一個execute方法，類似TimerTask的run方法，在里面編寫業務邏輯
Job接口源碼
public interface Job {
    void execute(JobExecutionContext context) throws JobExecutionException;
}

Job實例在Quartz中的生命周期

每次調度器執行job時，它在調用execute方法前會創建一個新的job實例
當調用完成后，關聯的job對象實例會被釋放，釋放的實例會被垃圾回收機制回收

淺談JobDetail

JobDetail為Job實例提供了許多設置屬性，以及JobDetailMap成員變量屬性，它用來存儲特定Job實例的狀態信息，調度器需要借助JobDetail對象來添加Job實例。

JobDetail屬性

name：任務名稱
group：任務所屬組
jobClass：任務實現類
jobDataMap：傳參的作用

2-3 淺談JobExecutionContext&JobDataMap（上）

JobExecutionContext是什么

當Scheduler調用一個Job，就會將JobExecutionContext傳遞給Job的execute()方法；
Job能通過JobExecutionContext對象訪問到Quartz運行時候的環境以及Job本身的明細數據。

JobDataMap是什么

在進行任務調度時JobDataMap存儲在JobExecutionContext中，非常方便獲取
JobDataMap可以用來裝載任務可序列化的數據對象，當job實例對象被執行時這些參數對象會傳遞給它
JobDataMap實現了JDK的Map接口，并且添加了一些非常方便的方法用來存取基本數據類型

2-4 淺談JobExecutionContext&JobDataMap（下）

獲取JobDataMap的兩種方式

從Map中直接獲取
Job實現類中添加setter方法對應JobDataMap的鍵值
（Quartz框架默認的JobFactory實現類在初始化job實例對象時會自動地調用這些setter方式）

代碼演示

1.HelloScheduler類改造

package com.myimooc.helloquartz.two;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

/**
 * 編寫 任務調度類
 * @author ZhangCheng on 2017-06-26
 *
 */
public class HelloScheduler {
    
    public static void main(String[] args) throws SchedulerException {
        
        // 創建一個 JobDetail 實例，將該實例與 HelloJob 實例綁定
        JobDetail jobDeatil = JobBuilder.newJob(HelloJob.class)
                .withIdentity("myjob", "jobgroup1")// 定義標識符
                .usingJobData("message", "hello myjob1")// 傳入自定義參數
                .usingJobData("floatJobValue", 3.14F)// 傳入自定義參數
                .build();
        
        System.out.println("jobDetail"s name : " + jobDeatil.getKey().getName());
        System.out.println("jobDetail"s group : " + jobDeatil.getKey().getGroup());
        System.out.println("jobDetail"s jobClass : " + jobDeatil.getJobClass().getName());
        
        // 創建一個 Trigger 實例，定義該 job 立即執行，并且每隔兩秒重復執行一次，直到永遠
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger","trigroup1")// 定義標識符
                .usingJobData("message", "hello mytrigger1")// 傳入自定義參數
                .usingJobData("doubleTriggerValue", 2.0D)// 傳入自定義參數
                .startNow()// 定義立即執行
                .withSchedule(SimpleScheduleBuilder
                        .simpleSchedule()
                        .withIntervalInSeconds(2)
                        .repeatForever())// 定義執行頻度
                .build();
        
        // 創建 Scheduler 實例
        SchedulerFactory sfact = new StdSchedulerFactory();
        Scheduler scheduler = sfact.getScheduler();
        
        // 綁定 JobDetail 和 trigger
        scheduler.scheduleJob(jobDeatil, trigger);
        
        // 執行任務
        scheduler.start();
        
        // 打印當前的執行時間，格式為2017-01-01 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("Current Time Is : " + sf.format(date));
    }
    
}

2.HelloJob類改造

package com.myimooc.helloquartz.two;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobKey;
import org.quartz.TriggerKey;

/**
 * 編寫 自定義任務
 * @author ZhangCheng on 2017-06-26
 *
 */
public class HelloJob implements Job{
    
    // 方式二：getter和setter獲取
    // 成員變量 與 傳入參數的key一致
    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;
    }
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 打印當前的執行時間，格式為2017-01-01 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("Current Exec Time Is : " + sf.format(date));
        
        // 編寫具體的業務邏輯
        //System.out.println("Hello World!");
        
        JobKey key = context.getJobDetail().getKey();
        System.out.println("My name and group are : " + key.getName() + " : " + key.getGroup());
        
        TriggerKey trkey = context.getTrigger().getKey();
        System.out.println("My Trigger name and group are : " + trkey.getName() + " : " + trkey.getGroup());
        
        // 方式一：Map中直接  獲取自定義參數
        JobDataMap jdataMap = context.getJobDetail().getJobDataMap();
        JobDataMap tdataMap = context.getTrigger().getJobDataMap();
        String jobMsg = jdataMap.getString("message");
        Float jobFloatValue = jdataMap.getFloat("floatJobValue");
        
        String triMsg = tdataMap.getString("message");
        Double triDoubleValue = tdataMap.getDouble("doubleTriggerValue");
        
        System.out.println("jobMsg is : " + jobMsg);
        System.out.println("jobFloatValue is : " + jobFloatValue);
        System.out.println("triMsg is : " + triMsg);
        System.out.println("triDoubleValue is : " + triDoubleValue);
        
        // 方式一：Map中直接獲取 獲取自定義參數
        JobDataMap jobDataMap = context.getMergedJobDataMap();
        jobMsg = jobDataMap.getString("message");
        jobFloatValue = jobDataMap.getFloat("floatJobValue");
        
        triMsg = jobDataMap.getString("message");
        triDoubleValue = jobDataMap.getDouble("doubleTriggerValue");
        
        System.out.println("jobMsg is : " + jobMsg);
        System.out.println("jobFloatValue is : " + jobFloatValue);
        System.out.println("triMsg is : " + triMsg);
        System.out.println("triDoubleValue is : " + triDoubleValue);
        
        // 方式二：getter和setter獲取
        System.out.println("message is : " + this.message);
        System.out.println("jobFloatValue is : " + this.floatJobValue);
        System.out.println("triDoubleValue is : " + this.doubleTriggerValue);
    }
    
}

2-5 淺談Trigger

Trigger是什么

Quartz中的觸發器用來告訴調度程序作業什么時候觸發
即Trigger對象時用來觸發執行Job的

Quartz框架中的Trigger示意圖

觸發器通用屬性

JobKey：表示job實例的標識，觸發器被觸發時，該指定的job實例會執行
StartTime：表示觸發器的時間表首次被觸發的時間，它的值的類型是Java.util.Date
EndTime：指定觸發器的不再被觸發的時間，它的值的類型是Java.util.Date

代碼演示

1.HelloJob類改造

package com.myimooc.helloquartz.three;

import java.text.SimpleDateFormat;
import java.util.Date;

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

/**
 * 自定義任務  觸發器通用屬性
 * @author ZhangCheng on 2017-06-26
 *
 */
public class HelloJob implements Job{
    
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 打印當前的執行時間，格式為2017-01-01 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("Current Exec Time Is : " + sf.format(date));
        
        Trigger currentTrigger = context.getTrigger();
        System.out.println("Start Time Is : " + sf.format(currentTrigger.getStartTime()));
        System.out.println("End Time Is : " + sf.format(currentTrigger.getEndTime()));
        
        JobKey jobKey = currentTrigger.getJobKey();
        System.out.println("JobKey info : " + " jobName : " + jobKey.getName()
                + " jobGroup : " + jobKey.getGroup());
    }
    
}

2.HelloScheduler類改造

package com.myimooc.helloquartz.three;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

/**
 * 任務調度類  觸發器通用屬性
 * @author ZhangCheng on 2017-06-26
 *
 */
public class HelloScheduler {
    
    public static void main(String[] args) throws SchedulerException {
        // 打印當前的執行時間，格式為2017-01-01 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("Current Time Is : " + sf.format(date));
        
        // 創建一個 JobDetail 實例，將該實例與 HelloJob 實例綁定
        JobDetail jobDeatil = JobBuilder.newJob(HelloJob.class)
                .withIdentity("myjob", "jobgroup1")// 定義標識符
                .build();
        
        // 獲取距離當前時間3秒后的時間
        date.setTime(date.getTime() + 3000);
        // 獲取距離當前時間6秒后的時間
        Date endDate = new Date();
        endDate.setTime(endDate.getTime() + 6000);
        
        // 創建一個 Trigger 實例，定義該 job 立即執行，并且每隔兩秒重復執行一次，直到永遠
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger","trigroup1")// 定義標識符
                .startAt(date)// 定義3秒后執行
                .endAt(endDate)// 定義6秒后結束
                .withSchedule(SimpleScheduleBuilder
                        .simpleSchedule()
                        .withIntervalInSeconds(2)
                        .repeatForever())// 定義執行頻度
                .build();
        
        // 創建 Scheduler 實例
        SchedulerFactory sfact = new StdSchedulerFactory();
        Scheduler scheduler = sfact.getScheduler();
        
        // 綁定 JobDetail 和 trigger
        scheduler.scheduleJob(jobDeatil, trigger);
        
        // 執行任務
        scheduler.start();
    }
    
}

2-6 SimpleTrigger

SimpleTrigger的作用

在一個指定時間段內執行一次作業任務
或是在指定的時間間隔內多次執行作業任務

需要注意的點

重復次數可以為0，正整數或是SimpleTrigger.REPEAT_INDEFINITELY常量值
重復執行間隔必須為0或長整數
一旦被指定了endTime參數，那么它會覆蓋重復次數參數的效果

代碼演示

1.HelloJob類改造

package com.myimooc.helloquartz.four;

import java.text.SimpleDateFormat;
import java.util.Date;

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

/**
 * SimpleTrigger 演示
 * @author ZhangCheng on 2017-06-26
 *
 */
public class HelloJob implements Job{
    
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 打印當前的執行時間，格式為2017-01-01 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("Current Exec Time Is : " + sf.format(date));
        
        System.out.println("Hello World!");
    }
    
}

2.HelloScheduler類改造

package com.myimooc.helloquartz.four;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.SimpleTrigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

/**
 * SimpleTrigger 演示
 * @author ZhangCheng on 2017-06-26
 *
 */
public class HelloScheduler {
    
    public static void main(String[] args) throws SchedulerException {
        // 打印當前的執行時間，格式為2017-01-01 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("Current Time Is : " + sf.format(date));
        
        // 創建一個 JobDetail 實例，將該實例與 HelloJob 實例綁定
        JobDetail jobDeatil = JobBuilder.newJob(HelloJob.class)
                .withIdentity("myjob", "jobgroup1")// 定義標識符
                .build();
        
        // 獲取距離當前時間4秒鐘之后的具體時間
        date.setTime(date.getTime() + 4000);
        // 獲取距離當前時間6秒鐘之后的具體時間
        Date endDate = new Date();
        endDate.setTime(endDate.getTime() + 6000);
        
        // 距離當前時間4秒鐘后首次執行任務，之后每隔2秒鐘重復執行一次任務
        // 知道距離當前時間6秒鐘之后為止
        SimpleTrigger trigger = (SimpleTrigger) TriggerBuilder
                .newTrigger()
                .withIdentity("myTrigger","trigroup1")// 定義標識符
                .startAt(date)
                .endAt(endDate)
                .withSchedule(SimpleScheduleBuilder
                        .simpleSchedule()
                        .withIntervalInSeconds(2)
                        .withRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY))
                .build();
         
        // 創建 Scheduler 實例
        SchedulerFactory sfact = new StdSchedulerFactory();
        Scheduler scheduler = sfact.getScheduler();
        scheduler.scheduleJob(jobDeatil, trigger);
        scheduler.start();
    }
    
}

2-7 CronTrigger

CronTrigger的作用

基于日歷的作業調度器，而不是像SimpleTrigger那樣精確指定間隔時間，比SimpleTrigger更常用

Cron表達式

用于配置CronTrigger實例
是由7個子表達式組成的字符串，描述了時間表的詳細信息
格式：[秒][分][小時][日][月][周][年]

Cron表達式特殊字符意義對應表

特殊符號解釋

Cron表達式舉例

Cron表達式小提示

L和W可以一組合使用
周字段英文字母不區分大小寫即MON與mon相同
利用工具，在線生成

2-8 淺談Scheduler

Scheduler工廠模式

所有的Scheduler實例應該由SchedulerFactory來創建

SchedulerFactory類圖

回顧Quartz三個核心概念

調度器
任務
觸發器

示意圖

Scheduler的創建方式

StdSchedulerFactory

使用一組參數（Java.util.Properties）來創建和初始化Quartz調度器
配置參數一般存儲在quartz.properties中
調用getScheduler方法就能創建和初始化調度器對象

Scheduler的主要函數

// 綁定 jobDetail 和 trigger，將它注冊進 Scheduler 當中
Date scheduleJob(JobDetail jobDetail, Trigger trigger)
// 啟動 Scheduler
void start()
// 暫停 Scheduler
void standby()
// 關閉 Scheduler
void shutdown()

2-9 QuartzProperties文件

quartz.properties組成部分

調度器屬性
線程池屬性
作業存儲設置
插件配置

調度器屬性

線程池屬性

threadCount：工作線程數量
threadPriority：工作線程優先級
org.quartz.threadPool.class：配置線程池實現類

作業存儲設置

描述了在調度器實例的生命周期中，Job和Trigger信息是如何被存儲的

插件配置

滿足特定需求用到的Quartz插件的配置

第三章：Spring、Quartz大合體 3-1 搭建工程

基于Maven創建一個簡單的SpringMVC工程，學習時，使用springboot框架。

項目POM文件


  4.0.0

  com.myimooc
  springquartz
  0.0.1-SNAPSHOT
  jar

  springquartz
  http://maven.apache.org

  
        org.springframework.boot
        spring-boot-starter-parent
        1.5.1.RELEASE
         
    

    
        UTF-8
        UTF-8
    

    
        
            org.springframework.boot
            spring-boot-starter
        
    
        
            org.springframework.boot
            spring-boot-starter-web
        
        
        
            org.springframework
            spring-context-support
        
        
        
            org.springframework
            spring-tx
        
        
        
            org.springframework.boot
            spring-boot-starter-freemarker
        
        
        
        
            org.quartz-scheduler
            quartz
            2.3.0
        
        
        
            junit
            junit
            test
        
    
  
  
        
            
                org.apache.maven.plugins
                maven-compiler-plugin
                
                    1.8
                    1.8

項目目錄結構

3-2 Quartz和Spring大合體

使用Quartz配置作業兩種方式

MethodInvokingJobDetailFactoryBean
JobDetailFactoryBean

方式一：使用MethodInvokingJobDetailFactoryBean

1.調用myBean的printMessage方法

2.MyBean類

方式二：使用JobDetailFactoryBean

1.需要給作業傳遞數據，想要更加靈活的話就是用這種方式

2.FirstScheduleJob類

3.AnotherBean類

代碼演示：

演示說明：教學基于xml進行配置，學習時基于javaconfig進行配置。

1.編寫MyBean類

package com.myimooc.springquartz.quartz;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.springframework.stereotype.Component;

/**
 * 方式一：使用MethodInvokingJobDetailFactoryBean 演示
 * @author ZhangCheng on 2017-06-28
 *
 */
@Component
public class MyBean {
    
    public void printMessage(){
        
        // 打印當前的執行時間，格式為2017-01-01 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        
        System.out.println("MyBean Executes!" + sf.format(date));
    }
    
}

2.編寫AnotherBean類

package com.myimooc.springquartz.quartz;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.springframework.stereotype.Component;

/**
 * 方式二：使用JobDetailFactoryBean 演示
 * @author ZhangCheng on 2017-06-28
 *
 */
@Component
public class AnotherBean {
    
    public void printAnotherMessage(){
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        
        System.out.println("I am AnotherBean." + sf.format(date));
    }
    
}

3.編寫FirstScheduledJob類

package com.myimooc.springquartz.quartz;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

/**
 * 方式二：使用JobDetailFactoryBean 演示
 * @author ZhangCheng on 2017-06-28
 *
 */
public class FirstScheduledJob extends QuartzJobBean {
    
    private AnotherBean anotherBean;
    
    public void setAnotherBean(AnotherBean anotherBean) {
        this.anotherBean = anotherBean;
    }

    @Override
    protected void executeInternal(JobExecutionContext arg0) throws JobExecutionException {
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        
        System.out.println("FirstScheduledJob Excutes!" + sf.format(date));
        this.anotherBean.printAnotherMessage();
    }

}

4.編寫QuartzConfig類

package com.myimooc.springquartz.config;

import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.Trigger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.scheduling.quartz.SimpleTriggerFactoryBean;

import com.myimooc.springquartz.quartz.AnotherBean;
import com.myimooc.springquartz.quartz.FirstScheduledJob;
import com.myimooc.springquartz.quartz.MyBean;

/**
 * Quartz 配置類
 * @author ZhangCheng on 2017-06-28
 *
 */
@Configuration
public class QuartzConfig {
    
    @Autowired
    private MyBean myBean;
    
    @Autowired
    private AnotherBean anotherBean;
    
    /**
     * 方式一：使用MethodInvokingJobDetailFactoryBean
     * @return
     */
    @Bean
    public MethodInvokingJobDetailFactoryBean methodInvokingJobDetailFactoryBean(){
        MethodInvokingJobDetailFactoryBean mb = new MethodInvokingJobDetailFactoryBean();
        mb.setTargetObject(myBean);// 指定要運行的類
        mb.setTargetMethod("printMessage");// 指定要允許類中的那個方法
        return mb;
    }
    
    /**
     * 方式二：使用JobDetailFactoryBean
     * @return
     */
    @Bean
    public JobDetailFactoryBean jobDetailFactoryBean(){
        JobDetailFactoryBean  jb= new JobDetailFactoryBean();
        jb.setJobClass(FirstScheduledJob.class);// 指定要運行的類
        JobDataMap jobDataMap = new JobDataMap();
        jobDataMap.put("anotherBean", anotherBean);
        
        jb.setJobDataMap(jobDataMap);// 設置傳入自定義參數
        jb.setDurability(true);
        return jb;
    }
    
    /**
     * 配置 SimpleTriggerFactoryBean
     * @return
     */
    @Bean
    public SimpleTriggerFactoryBean simpleTriggerFactoryBean(){
        SimpleTriggerFactoryBean sb = new SimpleTriggerFactoryBean();
        sb.setJobDetail(methodInvokingJobDetailFactoryBean().getObject());// 設置需要綁定的 jobDetail
        sb.setStartDelay(1000L);// 距離當前時間1秒后執行
        sb.setRepeatInterval(2000L);// 之后每隔2秒執行一次
        return sb;
    }
    
    /**
     * 配置 SimpleTriggerFactoryBean
     * @return
     */
    @Bean
    public CronTriggerFactoryBean cronTriggerFactoryBean(){
        CronTriggerFactoryBean cb = new CronTriggerFactoryBean();
        cb.setJobDetail(jobDetailFactoryBean().getObject());// 設置需要綁定的 jobDetail
        cb.setStartDelay(1000L);// 距離當前時間1秒后執行
        cb.setCronExpression("0/5 * * ? * *");// 設置 Cron 表達式，之后每隔5秒執行一次
        return cb;
    }
    
    /**
     * 配置 SchedulerFactoryBean
     * @return
     */
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(){
        SchedulerFactoryBean sb= new SchedulerFactoryBean();
        // 配置 JobDetails
        JobDetail[] jobDetails = new JobDetail[2];
        jobDetails[0] = methodInvokingJobDetailFactoryBean().getObject();
        jobDetails[1] = jobDetailFactoryBean().getObject();
        sb.setJobDetails(jobDetails);
        
        // 配置 Trigger
        Trigger[] triggers = new Trigger[2];
        triggers[0] = simpleTriggerFactoryBean().getObject();
        triggers[1] = cronTriggerFactoryBean().getObject();
        sb.setTriggers(triggers);
        return sb;
        
    }
}

第四章：課程總結 4-1 課程總結

課程回顧

Timer
Quartz
Quartz&Spring融合

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://m.specialneedsforspecialkids.com/yun/67241.html

慕課網_《Java定時任務調度工具詳解之Timer篇》學習總結

時間：2017年05月24日星期三說明：本文部分內容均來自慕課網。@慕課網：http://www.imooc.com教學示例源碼：無個人學習源碼：https://github.com/zccodere/s... 第一章：課程介紹 1-1 課程介紹什么是定時任務調度基于給定的時間點，給定的時間間隔或者給定的執行次數自動執行的任務在Java中的定時調度工具 Timer：小弟，能實現日常60%的定...

wind5o 2019-08-14 18:37 評論0 收藏0
保存數據到MySql數據庫——我用scrapy寫爬蟲（二）

摘要：坦克大戰上簡介上的坦克大戰相信大家都玩過有逃學玩坦克的可以自己默默的扣一個了我們現在長大了，學習游戲開發了。寫在前面上一篇（https://www.tech1024.cn/origi... ）說了如何創建項目，并爬去網站內容，下面我們說一下如何保存爬去到的數據開始爬取創建Spider，上一篇我們已經創建了ImoocSpider，我們做一下修改，可以連續下一頁爬取。scrapyD...

Kross 2019-07-30 14:53 評論0 收藏0
慕課網_《RxJava與RxAndroid基礎入門》學習總結

時間：2017年10月16日星期一說明：本文部分內容均來自慕課網。@慕課網：http://www.imooc.com教學源碼：無學習源碼：https://github.com/zccodere/s... 第一章：課程簡介 1-1 課程介紹本門課程的主要內容 RxJava是什么 RxAndroid是什么 RxJava常用操作符（重點、難點）怎樣在項目中使用RxJava和RxAndroid 如何學...

劉明 2019-08-15 12:12 評論0 收藏0
慕課網_《RabbitMQ消息中間件極速入門與實戰》學習總結

摘要：慕課網消息中間件極速入門與實戰學習總結時間年月日星期三說明本文部分內容均來自慕課網。慕課網《RabbitMQ消息中間件極速入門與實戰》學習總結時間：2018年09月05日星期三說明：本文部分內容均來自慕課網。@慕課網：https://www.imooc.com 教學源碼：無學習源碼：https://github.com/zccodere/s... 第一章：RabbitM...

mykurisu 2019-08-19 11:07 評論0 收藏0
SpringCloud（第 010 篇）簡單 Quartz-Cluster 支持集群分布式且支持動態

摘要：通過再添加其他的元素可在中放置多個觸發器。停止觸發器重啟觸發器停止觸發器移除觸發器添加調度的任務類調度的任務。執行的張表入數據庫添加啟動類簡單微服務，支持集群分布式，并支持動態修改任務的執行時間。 SpringCloud（第 010 篇）簡單 Quartz-Cluster 微服務，支持集群分布式，并支持動態修改 Quartz 任務的 cronExpression 執行時間 - 一、大致...

xiyang 2019-08-16 10:47 評論0 收藏0