SpringBoot整合Quartz做爲調度中心完整實用例子

時間  2019-11-16
標籤 springboot 整合 quartz 做爲 調度 中心 完整 實用 例子 欄目 Spring 简体版
原文   原文鏈接

由於想要作一個相似於調度中心的東西，定時執行一些Job(一般是一些自定義程序或者可執行的jar包)，搭了一個例子，總結了前輩們的相關經驗和本身的一些理解，若有雷同或不當之處，望各位大佬見諒和幫忙指正。java

因爲以前有許多小夥伴問過我如何寫個定時任務，裏面寫上邏輯本身的邏輯,我另作了一個SpringBoot徹底整合Quartz的簡單例子mysql

能夠做爲Quartz的入門參考 : https://github.com/EalenXie/springboot-quartz-simplegit

 

本例子是整合Quartz做爲調度中心使用的。github

1.首先新建項目SpringBoot-Quartz ,選用的技術棧爲 SpringBoot + Quartz + Spring Data Jpa。完整代碼可見(本文已非最新代碼,最新見Github) : https://github.com/EalenXie/SpringBoot-Quartzweb

pom.xml依賴 : spring

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <project xmlns="http://maven.apache.org/POM/4.0.0"
 3          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 5     <modelVersion>4.0.0</modelVersion>
 6     <groupId>name.ealenxie</groupId>
 7     <artifactId>SpringBoot-Quartz</artifactId>
 8     <version>1.0</version>
 9     <parent>
10         <groupId>org.springframework.boot</groupId>
11         <artifactId>spring-boot-starter-parent</artifactId>
12         <version>2.0.1.RELEASE</version>
13     </parent>
14     <dependencies>
15         <dependency>
16             <groupId>org.springframework.boot</groupId>
17             <artifactId>spring-boot-starter-data-jpa</artifactId>
18         </dependency>
19         <dependency>
20             <groupId>org.springframework.boot</groupId>
21             <artifactId>spring-boot-starter-web</artifactId>
22         </dependency>
23         <dependency>
24             <groupId>mysql</groupId>
25             <artifactId>mysql-connector-java</artifactId>
26             <scope>runtime</scope>
27         </dependency>
28         <dependency> <!--quartz依賴-->
29             <groupId>org.quartz-scheduler</groupId>
30             <artifactId>quartz</artifactId>
31             <version>2.2.3</version>
32         </dependency>
33         <dependency>
34             <groupId>org.springframework</groupId>
35             <artifactId>spring-context-support</artifactId>
36         </dependency>
37         <dependency>
38             <groupId>org.quartz-scheduler</groupId>
39             <artifactId>quartz-jobs</artifactId>
40             <version>2.2.3</version>
41         </dependency>
42     </dependencies>
43 </project>

 

2.你須要在數據庫中創建Quartz的相關係統表，因此你須要在數據庫中執行以下來自Quartz官方的腳本。sql

  1 -- in your Quartz properties file, you'll need to set org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
  2 -- 你須要在你的quartz.properties文件中設置org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
  3 -- StdJDBCDelegate說明支持集羣，全部的任務信息都會保存到數據庫中，能夠控制事物，還有就是若是應用服務器關閉或者重啓，任務信息都不會丟失，而且能夠恢復因服務器關閉或者重啓而致使執行失敗的任務
  4 -- This is the script from Quartz to create the tables in a MySQL database, modified to use INNODB instead of MYISAM
  5 -- 這是來自quartz的腳本，在MySQL數據庫中建立如下的表，修改成使用INNODB而不是MYISAM
  6 -- 你須要在數據庫中執行如下的sql腳本
  7 DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;
  8 DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
  9 DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;
 10 DROP TABLE IF EXISTS QRTZ_LOCKS;
 11 DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;
 12 DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;
 13 DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;
 14 DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;
 15 DROP TABLE IF EXISTS QRTZ_TRIGGERS;
 16 DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;
 17 DROP TABLE IF EXISTS QRTZ_CALENDARS;
 18 -- 存儲每個已配置的Job的詳細信息
 19 CREATE TABLE QRTZ_JOB_DETAILS(
 20 SCHED_NAME VARCHAR(120) NOT NULL,
 21 JOB_NAME VARCHAR(200) NOT NULL,
 22 JOB_GROUP VARCHAR(200) NOT NULL,
 23 DESCRIPTION VARCHAR(250) NULL,
 24 JOB_CLASS_NAME VARCHAR(250) NOT NULL,
 25 IS_DURABLE VARCHAR(1) NOT NULL,
 26 IS_NONCONCURRENT VARCHAR(1) NOT NULL,
 27 IS_UPDATE_DATA VARCHAR(1) NOT NULL,
 28 REQUESTS_RECOVERY VARCHAR(1) NOT NULL,
 29 JOB_DATA BLOB NULL,
 30 PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP))
 31 ENGINE=InnoDB;
 32 -- 存儲已配置的Trigger的信息
 33 CREATE TABLE QRTZ_TRIGGERS (
 34 SCHED_NAME VARCHAR(120) NOT NULL,
 35 TRIGGER_NAME VARCHAR(200) NOT NULL,
 36 TRIGGER_GROUP VARCHAR(200) NOT NULL,
 37 JOB_NAME VARCHAR(200) NOT NULL,
 38 JOB_GROUP VARCHAR(200) NOT NULL,
 39 DESCRIPTION VARCHAR(250) NULL,
 40 NEXT_FIRE_TIME BIGINT(13) NULL,
 41 PREV_FIRE_TIME BIGINT(13) NULL,
 42 PRIORITY INTEGER NULL,
 43 TRIGGER_STATE VARCHAR(16) NOT NULL,
 44 TRIGGER_TYPE VARCHAR(8) NOT NULL,
 45 START_TIME BIGINT(13) NOT NULL,
 46 END_TIME BIGINT(13) NULL,
 47 CALENDAR_NAME VARCHAR(200) NULL,
 48 MISFIRE_INSTR SMALLINT(2) NULL,
 49 JOB_DATA BLOB NULL,
 50 PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
 51 FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
 52 REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP))
 53 ENGINE=InnoDB;
 54 -- 存儲已配置的Simple Trigger的信息
 55 CREATE TABLE QRTZ_SIMPLE_TRIGGERS (
 56 SCHED_NAME VARCHAR(120) NOT NULL,
 57 TRIGGER_NAME VARCHAR(200) NOT NULL,
 58 TRIGGER_GROUP VARCHAR(200) NOT NULL,
 59 REPEAT_COUNT BIGINT(7) NOT NULL,
 60 REPEAT_INTERVAL BIGINT(12) NOT NULL,
 61 TIMES_TRIGGERED BIGINT(10) NOT NULL,
 62 PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
 63 FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
 64 REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
 65 ENGINE=InnoDB;
 66 -- 存儲Cron Trigger，包括Cron表達式和時區信息
 67 CREATE TABLE QRTZ_CRON_TRIGGERS (
 68 SCHED_NAME VARCHAR(120) NOT NULL,
 69 TRIGGER_NAME VARCHAR(200) NOT NULL,
 70 TRIGGER_GROUP VARCHAR(200) NOT NULL,
 71 CRON_EXPRESSION VARCHAR(120) NOT NULL,
 72 TIME_ZONE_ID VARCHAR(80),
 73 PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
 74 FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
 75 REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
 76 ENGINE=InnoDB;
 77 CREATE TABLE QRTZ_SIMPROP_TRIGGERS
 78   (
 79     SCHED_NAME VARCHAR(120) NOT NULL,
 80     TRIGGER_NAME VARCHAR(200) NOT NULL,
 81     TRIGGER_GROUP VARCHAR(200) NOT NULL,
 82     STR_PROP_1 VARCHAR(512) NULL,
 83     STR_PROP_2 VARCHAR(512) NULL,
 84     STR_PROP_3 VARCHAR(512) NULL,
 85     INT_PROP_1 INT NULL,
 86     INT_PROP_2 INT NULL,
 87     LONG_PROP_1 BIGINT NULL,
 88     LONG_PROP_2 BIGINT NULL,
 89     DEC_PROP_1 NUMERIC(13,4) NULL,
 90     DEC_PROP_2 NUMERIC(13,4) NULL,
 91     BOOL_PROP_1 VARCHAR(1) NULL,
 92     BOOL_PROP_2 VARCHAR(1) NULL,
 93     PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
 94     FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
 95     REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
 96 ENGINE=InnoDB;
 97 --  Trigger做爲Blob類型存儲(用於Quartz用戶用JDBC建立他們本身定製的Trigger類型，JobStore並不知道如何存儲實例的時候)
 98 CREATE TABLE QRTZ_BLOB_TRIGGERS (
 99 SCHED_NAME VARCHAR(120) NOT NULL,
100 TRIGGER_NAME VARCHAR(200) NOT NULL,
101 TRIGGER_GROUP VARCHAR(200) NOT NULL,
102 BLOB_DATA BLOB NULL,
103 PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
104 INDEX (SCHED_NAME,TRIGGER_NAME, TRIGGER_GROUP),
105 FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
106 REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
107 ENGINE=InnoDB;
108 -- 以Blob類型存儲Quartz的Calendar日曆信息,quartz可配置一個日從來指定一個時間範圍
109 CREATE TABLE QRTZ_CALENDARS (
110 SCHED_NAME VARCHAR(120) NOT NULL,
111 CALENDAR_NAME VARCHAR(200) NOT NULL,
112 CALENDAR BLOB NOT NULL,
113 PRIMARY KEY (SCHED_NAME,CALENDAR_NAME))
114 ENGINE=InnoDB;
115 -- 存儲已暫停的Trigger組的信息
116 CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS (
117 SCHED_NAME VARCHAR(120) NOT NULL,
118 TRIGGER_GROUP VARCHAR(200) NOT NULL,
119 PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP))
120 ENGINE=InnoDB;
121 -- 存儲與已觸發的Trigger相關的狀態信息，以及相聯Job的執行信息
122 CREATE TABLE QRTZ_FIRED_TRIGGERS (
123 SCHED_NAME VARCHAR(120) NOT NULL,
124 ENTRY_ID VARCHAR(95) NOT NULL,
125 TRIGGER_NAME VARCHAR(200) NOT NULL,
126 TRIGGER_GROUP VARCHAR(200) NOT NULL,
127 INSTANCE_NAME VARCHAR(200) NOT NULL,
128 FIRED_TIME BIGINT(13) NOT NULL,
129 SCHED_TIME BIGINT(13) NOT NULL,
130 PRIORITY INTEGER NOT NULL,
131 STATE VARCHAR(16) NOT NULL,
132 JOB_NAME VARCHAR(200) NULL,
133 JOB_GROUP VARCHAR(200) NULL,
134 IS_NONCONCURRENT VARCHAR(1) NULL,
135 REQUESTS_RECOVERY VARCHAR(1) NULL,
136 PRIMARY KEY (SCHED_NAME,ENTRY_ID))
137 ENGINE=InnoDB;
138 -- 存儲少許的有關 Scheduler的狀態信息，和別的 Scheduler 實例(假如是用於一個集羣中)
139 CREATE TABLE QRTZ_SCHEDULER_STATE (
140 SCHED_NAME VARCHAR(120) NOT NULL,
141 INSTANCE_NAME VARCHAR(200) NOT NULL,
142 LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
143 CHECKIN_INTERVAL BIGINT(13) NOT NULL,
144 PRIMARY KEY (SCHED_NAME,INSTANCE_NAME))
145 ENGINE=InnoDB;
146 -- 存儲程序的非觀鎖的信息(假如使用了悲觀鎖)
147 CREATE TABLE QRTZ_LOCKS (
148 SCHED_NAME VARCHAR(120) NOT NULL,
149 LOCK_NAME VARCHAR(40) NOT NULL,
150 PRIMARY KEY (SCHED_NAME,LOCK_NAME))
151 ENGINE=InnoDB;
152 CREATE INDEX IDX_QRTZ_J_REQ_RECOVERY ON QRTZ_JOB_DETAILS(SCHED_NAME,REQUESTS_RECOVERY);
153 CREATE INDEX IDX_QRTZ_J_GRP ON QRTZ_JOB_DETAILS(SCHED_NAME,JOB_GROUP);
154 CREATE INDEX IDX_QRTZ_T_J ON QRTZ_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
155 CREATE INDEX IDX_QRTZ_T_JG ON QRTZ_TRIGGERS(SCHED_NAME,JOB_GROUP);
156 CREATE INDEX IDX_QRTZ_T_C ON QRTZ_TRIGGERS(SCHED_NAME,CALENDAR_NAME);
157 CREATE INDEX IDX_QRTZ_T_G ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);
158 CREATE INDEX IDX_QRTZ_T_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE);
159 CREATE INDEX IDX_QRTZ_T_N_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP,TRIGGER_STATE);
160 CREATE INDEX IDX_QRTZ_T_N_G_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP,TRIGGER_STATE);
161 CREATE INDEX IDX_QRTZ_T_NEXT_FIRE_TIME ON QRTZ_TRIGGERS(SCHED_NAME,NEXT_FIRE_TIME);
162 CREATE INDEX IDX_QRTZ_T_NFT_ST ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE,NEXT_FIRE_TIME);
163 CREATE INDEX IDX_QRTZ_T_NFT_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME);
164 CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_STATE);
165 CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE_GRP ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_GROUP,TRIGGER_STATE);
166 CREATE INDEX IDX_QRTZ_FT_TRIG_INST_NAME ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME);
167 CREATE INDEX IDX_QRTZ_FT_INST_JOB_REQ_RCVRY ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME,REQUESTS_RECOVERY);
168 CREATE INDEX IDX_QRTZ_FT_J_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
169 CREATE INDEX IDX_QRTZ_FT_JG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_GROUP);
170 CREATE INDEX IDX_QRTZ_FT_T_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP);
171 CREATE INDEX IDX_QRTZ_FT_TG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);
172 commit;

 


3.新建完Quartz系統表以後,你須要作SpringBoot和Quartz的相關配置
application.yml
 1 quartz:
 2   enabled: true
 3 server:
 4   port: 9090
 5 spring:
 6   datasource:
 7     url: jdbc:mysql://localhost:3306/spring_quartz
 8     username: yourname
 9     password: yourpassword
10     tomcat:
11       initialSize: 20
12       maxActive: 100
13       maxIdle: 100
14       minIdle: 20
15       maxWait: 10000
16       testWhileIdle: true
17       testOnBorrow: false
18       testOnReturn: false

 

quartz.properties文件, (注 : 這裏若是使用yml文件格式的配置,裏面的配置會失效；spring-boot-starter-quartz已經有全新的支持，感興趣的道友能夠參考文章:https://www.jianshu.com/p/056281e057b3)
 1 #ID設置爲自動獲取 每個必須不一樣 （全部調度器實例中是惟一的）
 2 org.quartz.scheduler.instanceId=AUTO
 3 #指定調度程序的主線程是否應該是守護線程
 4 org.quartz.scheduler.makeSchedulerThreadDaemon=true
 5 #ThreadPool實現的類名
 6 org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
 7 #ThreadPool配置線程守護進程
 8 org.quartz.threadPool.makeThreadsDaemons=true
 9 #線程數量
10 org.quartz.threadPool.threadCount:20
11 #線程優先級
12 org.quartz.threadPool.threadPriority:5
13 #數據保存方式爲持久化
14 org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
15 #StdJDBCDelegate說明支持集羣
16 org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
17 #quartz內部表的前綴
18 org.quartz.jobStore.tablePrefix=QRTZ_
19 #是否加入集羣
20 org.quartz.jobStore.isClustered=true
21 #允許的最大做業延長時間
22 org.quartz.jobStore.misfireThreshold=25000

 

4.須要調度數據庫中的Job實例定義。
JobEntity.class
package com.ealen.entity;
import javax.persistence.*;
import java.io.Serializable;
/**
 * Created by EalenXie on 2018/6/4 14:09
 * 這裏我的示例,可自定義相關屬性
 */
@Entity
@Table(name = "JOB_ENTITY")
public class JobEntity implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    private String name;          //job名稱
    private String group;         //job組名
    private String cron;          //執行的cron
    private String parameter;     //job的參數
    private String description;   //job描述信息
    @Column(name = "vm_param")
    private String vmParam;       //vm參數
    @Column(name = "jar_path")
    private String jarPath;       //job的jar路徑,在這裏我選擇的是定時執行一些可執行的jar包
    private String status;        //job的執行狀態,這裏我設置爲OPEN/CLOSE且只有該值爲OPEN纔會執行該Job
    public JobEntity() {
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getGroup() {
        return group;
    }
    public void setGroup(String group) {
        this.group = group;
    }
    public String getCron() {
        return cron;
    }
    public void setCron(String cron) {
        this.cron = cron;
    }
    public String getParameter() {
        return parameter;
    }
    public void setParameter(String parameter) {
        this.parameter = parameter;
    }
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
    public String getVmParam() {
        return vmParam;
    }
    public void setVmParam(String vmParam) {
        this.vmParam = vmParam;
    }
    public String getJarPath() {
        return jarPath;
    }
    public void setJarPath(String jarPath) {
        this.jarPath = jarPath;
    }
    public String getStatus() {
        return status;
    }
    public void setStatus(String status) {
        this.status = status;
    }
    @Override
    public String toString() {
        return "JobEntity{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", group='" + group + '\'' +
                ", cron='" + cron + '\'' +
                ", parameter='" + parameter + '\'' +
                ", description='" + description + '\'' +
                ", vmParam='" + vmParam + '\'' +
                ", jarPath='" + jarPath + '\'' +
                ", status='" + status + '\'' +
                '}';
    }
    //新增Builder模式,可選,選擇設置任意屬性初始化對象
    public JobEntity(Builder builder) {
        id = builder.id;
        name = builder.name;
        group = builder.group;
        cron = builder.cron;
        parameter = builder.parameter;
        description = builder.description;
        vmParam = builder.vmParam;
        jarPath = builder.jarPath;
        status = builder.status;
    }
    public static class Builder {
        private Integer id;
        private String name = "";          //job名稱
        private String group = "";         //job組名
        private String cron = "";          //執行的cron
        private String parameter = "";     //job的參數
        private String description = "";   //job描述信息
        private String vmParam = "";       //vm參數
        private String jarPath = "";       //job的jar路徑
        private String status = "";        //job的執行狀態,只有該值爲OPEN纔會執行該Job
        public Builder withId(Integer i) {
            id = i;
            return this;
        }
        public Builder withName(String n) {
            name = n;
            return this;
        }
        public Builder withGroup(String g) {
            group = g;
            return this;
        }
        public Builder withCron(String c) {
            cron = c;
            return this;
        }
        public Builder withParameter(String p) {
            parameter = p;
            return this;
        }
        public Builder withDescription(String d) {
            description = d;
            return this;
        }
        public Builder withVMParameter(String vm) {
            vmParam = vm;
            return this;
        }
        public Builder withJarPath(String jar) {
            jarPath = jar;
            return this;
        }
        public Builder withStatus(String s) {
            status = s;
            return this;
        }
        public JobEntity newJobEntity() {
            return new JobEntity(this);
        }
    }
}

 

爲了方便測試,設計好表以後先插入幾條記錄,job_entity.sql,相關sql語句以下: 
SET FOREIGN_KEY_CHECKS=0;
DROP TABLE IF EXISTS `job_entity`;
CREATE TABLE `job_entity` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `group` varchar(255) DEFAULT NULL,
  `cron` varchar(255) DEFAULT NULL,
  `parameter` varchar(255) NOT NULL,
  `description` varchar(255) DEFAULT NULL,
  `vm_param` varchar(255) DEFAULT NULL,
  `jar_path` varchar(255) DEFAULT NULL,
  `status` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
INSERT INTO `job_entity` VALUES ('1',  'first', 'helloworld', '0/2 * * * * ? ', '1', '第一個', '', null, 'OPEN');
INSERT INTO `job_entity` VALUES ('2',  'second', 'helloworld', '0/5 * * * * ? ', '2', '第二個', null, null, 'OPEN');
INSERT INTO `job_entity` VALUES ('3',  'third', 'helloworld', '0/15 * * * * ? ', '3', '第三個', null, null, 'OPEN');
INSERT INTO `job_entity` VALUES ('4',  'four', 'helloworld', '0 0/1 * * * ? *', '4', '第四個', null, null, 'CLOSE');
INSERT INTO `job_entity` VALUES ('5',  'OLAY Job', 'Nomal', '0 0/2 * * * ?', '5', '第五個', null, 'C:\\EalenXie\\Download\\JDE-Order-1.0-SNAPSHOT.jar', 'CLOSE');

 

Quartz的核心配置類 : ConfigureQuartz.class
package com.ealen.config;
import org.quartz.spi.JobFactory;
import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;
import javax.sql.DataSource;
import java.io.IOException;
import java.util.Properties;
/**
 * Created by EalenXie on 2018/6/4 11:02
 * Quartz的核心配置類
 */
@Configuration
public class ConfigureQuartz {
    //配置JobFactory
    @Bean
    public JobFactory jobFactory(ApplicationContext applicationContext) {
        AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory();
        jobFactory.setApplicationContext(applicationContext);
        return jobFactory;
    }
    /**
     * SchedulerFactoryBean這個類的真正做用提供了對org.quartz.Scheduler的建立與配置，而且會管理它的生命週期與Spring同步。
     * org.quartz.Scheduler: 調度器。全部的調度都是由它控制。
     * @param dataSource 爲SchedulerFactory配置數據源
     * @param jobFactory 爲SchedulerFactory配置JobFactory
     */
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(DataSource dataSource, JobFactory jobFactory) throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        //可選,QuartzScheduler啓動時更新己存在的Job,這樣就不用每次修改targetObject後刪除qrtz_job_details表對應記錄
        factory.setOverwriteExistingJobs(true);
        factory.setAutoStartup(true); //設置自行啓動
        factory.setDataSource(dataSource);
        factory.setJobFactory(jobFactory);
        factory.setQuartzProperties(quartzProperties());
        return factory;
    }
    //從quartz.properties文件中讀取Quartz配置屬性
    @Bean
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }
    //配置JobFactory,爲quartz做業添加自動鏈接支持
    public final class AutowiringSpringBeanJobFactory extends SpringBeanJobFactory implements
            ApplicationContextAware {
        private transient AutowireCapableBeanFactory beanFactory;
        @Override
        public void setApplicationContext(final ApplicationContext context) {
            beanFactory = context.getAutowireCapableBeanFactory();
        }
        @Override
        protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception {
            final Object job = super.createJobInstance(bundle);
            beanFactory.autowireBean(job);
            return job;
        }
    }
}

 

寫一個dao訪問數據庫，JobEntityRepository.class
package com.ealen.dao;
import com.ealen.entity.JobEntity;
import org.springframework.data.repository.CrudRepository;
/**
 * Created by EalenXie on 2018/6/4 14:27
 */
public interface JobEntityRepository extends CrudRepository<JobEntity, Long> {
    JobEntity getById(Integer id);
}

 

5.定義調度中心執行邏輯的Job,這個Job的做用就是按照數據庫中的Job的邏輯,規則去執行數據庫中的Job。
這裏使用了一個自定義的枚舉工具類StringUtils , StringUtils.class : 
package com.ealen.util;
import java.util.List;
import java.util.Map;
/**
 * Created by EalenXie on 2018/6/4 14:20
 * 自定義枚舉單例對象 StringUtil
 */
public enum StringUtils {
    getStringUtil;
    //是否爲空
    public boolean isEmpty(String str) {
        return (str == null) || (str.length() == 0) || (str.equals(""));
    }
    //去空格
    public String trim(String str) {
        return str == null ? null : str.trim();
    }
    //獲取Map參數值
    public String getMapString(Map<String, String> map) {
        String result = "";
        for (Map.Entry entry : map.entrySet()) {
            result += entry.getValue() + " ";
        }
        return result;
    }
    //獲取List參數值
    public String getListString(List<String> list) {
        String result = "";
        for (String s : list) {
            result += s + " ";
        }
        return result;
    }
}

 

調度中心執行邏輯的Job。DynamicJob.class :  
 1 package com.ealen.job;
 2 import com.ealen.util.StringUtils;
 3 import org.quartz.*;
 4 import org.slf4j.Logger;
 5 import org.slf4j.LoggerFactory;
 6 import org.springframework.stereotype.Component;
 7 import java.io.*;
 8 import java.util.ArrayList;
 9 import java.util.List;
10 /**
11  * Created by EalenXie on 2018/6/4 14:29
12  * :@DisallowConcurrentExecution : 此標記用在實現Job的類上面,意思是不容許併發執行.
13  * :注意org.quartz.threadPool.threadCount線程池中線程的數量至少要多個,不然@DisallowConcurrentExecution不生效
14  * :假如Job的設置時間間隔爲3秒,但Job執行時間是5秒,設置@DisallowConcurrentExecution之後程序會等任務執行完畢之後再去執行,不然會在3秒時再啓用新的線程執行
15  */
16 @DisallowConcurrentExecution
17 @Component
18 public class DynamicJob implements Job {
19     private Logger logger = LoggerFactory.getLogger(DynamicJob.class);
20     /**
21      * 核心方法,Quartz Job真正的執行邏輯.
22      * @param executorContext executorContext JobExecutionContext中封裝有Quartz運行所須要的全部信息
23      * @throws JobExecutionException execute()方法只容許拋出JobExecutionException異常
24      */
25     @Override
26     public void execute(JobExecutionContext executorContext) throws JobExecutionException {
27         //JobDetail中的JobDataMap是共用的,從getMergedJobDataMap獲取的JobDataMap是全新的對象
28         JobDataMap map = executorContext.getMergedJobDataMap();
29         String jarPath = map.getString("jarPath");
30         String parameter = map.getString("parameter");
31         String vmParam = map.getString("vmParam");
32         logger.info("Running Job name : {} ", map.getString("name"));
33         logger.info("Running Job description : " + map.getString("JobDescription"));
34         logger.info("Running Job group: {} ", map.getString("group"));
35         logger.info("Running Job cron : " + map.getString("cronExpression"));
36         logger.info("Running Job jar path : {} ", jarPath);
37         logger.info("Running Job parameter : {} ", parameter);
38         logger.info("Running Job vmParam : {} ", vmParam);
39         long startTime = System.currentTimeMillis();
40         if (!StringUtils.getStringUtil.isEmpty(jarPath)) {
41             File jar = new File(jarPath);
42             if (jar.exists()) {
43                 ProcessBuilder processBuilder = new ProcessBuilder();
44                 processBuilder.directory(jar.getParentFile());
45                 List<String> commands = new ArrayList<>();
46                 commands.add("java");
47                 if (!StringUtils.getStringUtil.isEmpty(vmParam)) commands.add(vmParam);
48                 commands.add("-jar");
49                 commands.add(jarPath);
50                 if (!StringUtils.getStringUtil.isEmpty(parameter)) commands.add(parameter);
51                 processBuilder.command(commands);
52                 logger.info("Running Job details as follows >>>>>>>>>>>>>>>>>>>>: ");
53                 logger.info("Running Job commands : {}  ", StringUtils.getStringUtil.getListString(commands));
54                 try {
55                     Process process = processBuilder.start();
56                     logProcess(process.getInputStream(), process.getErrorStream());
57                 } catch (IOException e) {
58                     throw new JobExecutionException(e);
59                 }
60             } else throw new JobExecutionException("Job Jar not found >>  " + jarPath);
61         }
62         long endTime = System.currentTimeMillis();
63         logger.info(">>>>>>>>>>>>> Running Job has been completed , cost time :  " + (endTime - startTime) + "ms\n");
64     }
65     //打印Job執行內容的日誌
66     private void logProcess(InputStream inputStream, InputStream errorStream) throws IOException {
67         String inputLine;
68         String errorLine;
69         BufferedReader inputReader = new BufferedReader(new InputStreamReader(inputStream));
70         BufferedReader errorReader = new BufferedReader(new InputStreamReader(errorStream));
71         while ((inputLine = inputReader.readLine()) != null) logger.info(inputLine);
72         while ((errorLine = errorReader.readLine()) != null) logger.error(errorLine);
73     }
74 }

 

6.爲了方便控制Job的運行，爲調度中心添加相關的業務邏輯 : 數據庫

DynamicJobService.class  :apache

 1 package com.ealen.service;
 2 import com.ealen.dao.JobEntityRepository;
 3 import com.ealen.entity.JobEntity;
 4 import com.ealen.job.DynamicJob;
 5 import org.quartz.*;
 6 import org.springframework.beans.factory.annotation.Autowired;
 7 import org.springframework.stereotype.Service;
 8 import java.util.ArrayList;
 9 import java.util.List;
10 /**
11  * Created by EalenXie on 2018/6/4 14:25
12  */
13 @Service
14 public class DynamicJobService {
15     @Autowired
16     private JobEntityRepository repository;
17     //經過Id獲取Job
18     public JobEntity getJobEntityById(Integer id) {
19         return repository.getById(id);
20     }
21     //從數據庫中加載獲取到全部Job
22     public List<JobEntity> loadJobs() {
23         List<JobEntity> list = new ArrayList<>();
24         repository.findAll().forEach(list::add);
25         return list;
26     }
27     //獲取JobDataMap.(Job參數對象)
28     public JobDataMap getJobDataMap(JobEntity job) {
29         JobDataMap map = new JobDataMap();
30         map.put("name", job.getName());
31         map.put("group", job.getGroup());
32         map.put("cronExpression", job.getCron());
33         map.put("parameter", job.getParameter());
34         map.put("JobDescription", job.getDescription());
35         map.put("vmParam", job.getVmParam());
36         map.put("jarPath", job.getJarPath());
37         map.put("status", job.getStatus());
38         return map;
39     }
40     //獲取JobDetail,JobDetail是任務的定義,而Job是任務的執行邏輯,JobDetail裏會引用一個Job Class來定義
41     public JobDetail geJobDetail(JobKey jobKey, String description, JobDataMap map) {
42         return JobBuilder.newJob(DynamicJob.class)
43                 .withIdentity(jobKey)
44                 .withDescription(description)
45                 .setJobData(map)
46                 .storeDurably()
47                 .build();
48     }
49     //獲取Trigger (Job的觸發器,執行規則)
50     public Trigger getTrigger(JobEntity job) {
51         return TriggerBuilder.newTrigger()
52                 .withIdentity(job.getName(), job.getGroup())
53                 .withSchedule(CronScheduleBuilder.cronSchedule(job.getCron()))
54                 .build();
55     }
56     //獲取JobKey,包含Name和Group
57     public JobKey getJobKey(JobEntity job) {
58         return JobKey.jobKey(job.getName(), job.getGroup());
59     }
60 }

 

JobController.class :
package com.ealen.web;

import com.ealen.entity.JobEntity;
import com.ealen.service.DynamicJobService;
import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

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

/**
 * Created by EalenXie on 2018/6/4 16:12
 */
@RestController
public class JobController {

    private static final Logger logger = LoggerFactory.getLogger(JobController.class);
    @Autowired
    private SchedulerFactoryBean schedulerFactoryBean;
    @Autowired
    private DynamicJobService jobService;

    //初始化啓動全部的Job
    @PostConstruct
    public void initialize() {
        try {
            reStartAllJobs();
            logger.info("INIT SUCCESS");
        } catch (SchedulerException e) {
            logger.info("INIT EXCEPTION : " + e.getMessage());
            e.printStackTrace();
        }
    }

    //根據ID重啓某個Job
    @RequestMapping("/refresh/{id}")
    public String refresh(@PathVariable Integer id) throws SchedulerException {
        String result;
        JobEntity entity = jobService.getJobEntityById(id);
        if (entity == null) return "error: id is not exist ";
        synchronized (logger) {
            JobKey jobKey = jobService.getJobKey(entity);
            Scheduler scheduler = schedulerFactoryBean.getScheduler();
            scheduler.pauseJob(jobKey);
            scheduler.unscheduleJob(TriggerKey.triggerKey(jobKey.getName(), jobKey.getGroup()));
            scheduler.deleteJob(jobKey);
            JobDataMap map = jobService.getJobDataMap(entity);
            JobDetail jobDetail = jobService.geJobDetail(jobKey, entity.getDescription(), map);
            if (entity.getStatus().equals("OPEN")) {
                scheduler.scheduleJob(jobDetail, jobService.getTrigger(entity));
                result = "Refresh Job : " + entity.getName() + "\t jarPath: " + entity.getJarPath() + " success !";
            } else {
                result = "Refresh Job : " + entity.getName() + "\t jarPath: " + entity.getJarPath() + " failed ! , " +
                        "Because the Job status is " + entity.getStatus();
            }
        }
        return result;
    }


    //重啓數據庫中全部的Job
    @RequestMapping("/refresh/all")
    public String refreshAll() {
        String result;
        try {
            reStartAllJobs();
            result = "SUCCESS";
        } catch (SchedulerException e) {
            result = "EXCEPTION : " + e.getMessage();
        }
        return "refresh all jobs : " + result;
    }

    /**
     * 從新啓動全部的job
     */
    private void reStartAllJobs() throws SchedulerException {
        synchronized (logger) {                                                         //只容許一個線程進入操做
            Scheduler scheduler = schedulerFactoryBean.getScheduler();
            Set<JobKey> set = scheduler.getJobKeys(GroupMatcher.anyGroup());
            scheduler.pauseJobs(GroupMatcher.anyGroup());                               //暫停全部JOB
            for (JobKey jobKey : set) {                                                 //刪除從數據庫中註冊的全部JOB
                scheduler.unscheduleJob(TriggerKey.triggerKey(jobKey.getName(), jobKey.getGroup()));
                scheduler.deleteJob(jobKey);
            }
            for (JobEntity job : jobService.loadJobs()) {                               //從數據庫中註冊的全部JOB
                logger.info("Job register name : {} , group : {} , cron : {}", job.getName(), job.getGroup(), job.getCron());
                JobDataMap map = jobService.getJobDataMap(job);
                JobKey jobKey = jobService.getJobKey(job);
                JobDetail jobDetail = jobService.geJobDetail(jobKey, job.getDescription(), map);
                if (job.getStatus().equals("OPEN")) scheduler.scheduleJob(jobDetail, jobService.getTrigger(job));
                else
                    logger.info("Job jump name : {} , Because {} status is {}", job.getName(), job.getName(), job.getStatus());
            }
        }
    }
}

7.如今已經完事具有,只欠東風了,寫一個啓動類,跑一下看看效果。
 1 package com.ealen;
 2 import org.springframework.boot.SpringApplication;
 3 import org.springframework.boot.autoconfigure.SpringBootApplication;
 4 /**
 5  * Created by EalenXie on 2018/6/4 11:00
 6  */
 7 @SpringBootApplication
 8 public class QuartzApplication {
 9     public static void main(String[] args) {
10         SpringApplication.run(QuartzApplication.class, args);
11     }
12 }

 

運行效果以下 :

　看到這裏，那麼恭喜你，Quartz集羣已經搭建成功了。若是部署該項目應用到多個服務器上面，Job會在多個服務器上面執行，但同一個Job只會在某個服務器上面執行，即若是服務器A在某個時間執行了某個Job,則其餘服務器如B,C,D在此時間均不會執行此Job。即不會形成該Job被屢次執行。tomcat

這裏能夠看到數據庫中的Job已經在Quartz註冊並初始化成功了。

這裏可看到Scheduler已經在工做了，Job也已經按照cron在定時執行了。

執行一個包含jar的Job，看一下效果，圖下已經看到JOB在正常運行了  : 

看到Job執行完成了。

 

 

此時若是在數據庫中手動修改某個Job的執行cron，並不會立刻生效，則能夠調用上面寫到的業務方法，/refresh/all，則可刷新全部的Job，或/refresh/{id},刷新某個Job。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程