spring boot+Quartz+數據庫存儲

本文轉載自查看原文 2019-12-04 15:03 271

SpingBoot+Quartz+數據庫存儲

1、Spring整合Quartz

2、讀取數據庫中表達式啟動定時任務1（每5s執行）

3、更改定時任務狀態（啟用/禁用），定時任務1停止

4、讀取數據庫中表達式啟動定時任務2（每5s執行），在對應作業類中打印定時任務2攜帶的參數

5、讀取數據庫中表達式啟動定時任務3（每5s執行改成每20s執行），更改數據庫定時任務表達式，定時任務3對應執行策略相應發生改變。

Spring整合Quartz

a、quartz調度框架是有內置表的

進入quartz的官網http://www.quartz-scheduler.org/，點擊Downloads，

下載后在目錄\docs\dbTables下有常用數據庫創建quartz表的腳本，例如：“tables_mysql.sql”

table_mysql.sql

table_mysql_innodb.sql

上述兩者所有的數據庫引擎不一樣

導入pom依賴

1   <dependency>
2     <groupId>com.alibaba</groupId>
3     <artifactId>druid-spring-boot-starter</artifactId>
4     <version>1.1.10</version>
5    </dependency>

c、在項目中添加quartz.properties文件(這樣就不會加載自帶的properties文件)
此文件的內容主要分為：scheduler，ThreadPool，JobStore，plugin，Datasources等部分，
覆蓋properties文件的目的是覆蓋默認的數據源，更換為druid的數據配置
d、自定義MyJobFactory，解決spring不能在quartz中注入bean的問題
e、創建調度器schedule，交給spring進行管理
f、創建自定義任務
g、更新quartz中的任務
自定義任務表與quartz內置表的區分

要搞清楚一個問題：從數據庫讀取任務信息動態生成定時任務，和把quartz持久化到數據庫是沒有關系的。

前者是我們自己定義的業務表，而后者是quartz使用自己的表來存儲信息。

持久化到數據庫后，就算服務器重啟或是多個quartz節點也沒關系，因為他們共享數據庫中的任務信息。

創建項目

自定義業務表

 1 -- 注意：job_name存放的任務類的全路徑，在quartz中通過jobName和jobGroup來確定trigger的唯一性，所以這兩列為聯合唯一索引
 2 create table t_schedule_trigger
 3 (
 4   id int primary key auto_increment,                                -- ID
 5   cron varchar(200) not null,                                       -- 時間表達式
 6   status char(1) not null,                                          -- 使用狀態 0：禁用   1：啟用
 7   job_name varchar(200) not null,                                   -- 任務名稱
 8   job_group varchar(200) not null,                                  -- 任務分組  
 9   unique index(job_name,job_group)
10 );
11 
12 -- 額外添加到任務中的參數
13 create table t_schedule_trigger_param
14 (
15   param_id int primary key auto_increment,                                -- ID
16   name varchar(200) not null,                                             -- 參數名
17   value varchar(512),                                                     -- 參數值
18  
19   schedule_trigger_id int not null,                                       -- 外鍵：引用t_schedule_trigger(id)
20   foreign key(schedule_trigger_id) references t_schedule_trigger(id)
21 );

DruidConnectionProvider

  1 package com.yuan.quartz02.utils;
  2 
  3 import com.alibaba.druid.pool.DruidDataSource;
  4 import org.quartz.SchedulerException;
  5 import org.quartz.utils.ConnectionProvider;
  6 
  7 import java.sql.Connection;
  8 import java.sql.SQLException;
  9 
 10 /*
 11 #============================================================================
 12 # JDBC
 13 #============================================================================
 14 org.quartz.jobStore.driverDelegateClass:org.quartz.impl.jdbcjobstore.StdJDBCDelegate
 15 org.quartz.jobStore.useProperties:false
 16 org.quartz.jobStore.dataSource:qzDS
 17 #org.quartz.dataSource.qzDS.connectionProvider.class:org.quartz.utils.PoolingConnectionProvider
 18 org.quartz.dataSource.qzDS.connectionProvider.class:com.zking.q03.quartz.DruidConnectionProvider
 19 org.quartz.dataSource.qzDS.driver:com.mysql.jdbc.Driver
 20 org.quartz.dataSource.qzDS.URL:jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=UTF-8
 21 org.quartz.dataSource.qzDS.user:root
 22 org.quartz.dataSource.qzDS.password:root
 23 org.quartz.dataSource.qzDS.maxConnections:30
 24 org.quartz.dataSource.qzDS.validationQuery: select 0
 25 */
 26 
 27 /**
 28  * [Druid連接池的Quartz擴展類]
 29  *
 30  * @ProjectName: []
 31  * @Author: [xuguang]
 32  * @CreateDate: [2015/11/10 17:58]
 33  * @Update: [說明本次修改內容] BY[xuguang][2015/11/10]
 34  * @Version: [v1.0]
 35  */
 36 public class DruidConnectionProvider implements ConnectionProvider {
 37 
 38      /*
 39      * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 40      *
 41      * 常量配置，與quartz.properties文件的key保持一致(去掉前綴)，同時提供set方法，Quartz框架自動注入值。
 42      *
 43      * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 44      */
 45 
 46     //JDBC驅動
 47     public String driver;
 48     //JDBC連接串
 49     public String URL;
 50     //數據庫用戶名
 51     public String user;
 52     //數據庫用戶密碼
 53     public String password;
 54     //數據庫最大連接數
 55     public int maxConnection;
 56     //數據庫SQL查詢每次連接返回執行到連接池，以確保它仍然是有效的。
 57     public String validationQuery;
 58 
 59     private boolean validateOnCheckout;
 60 
 61     private int idleConnectionValidationSeconds;
 62 
 63     public String maxCachedStatementsPerConnection;
 64 
 65     private String discardIdleConnectionsSeconds;
 66 
 67     public static final int DEFAULT_DB_MAX_CONNECTIONS = 10;
 68 
 69     public static final int DEFAULT_DB_MAX_CACHED_STATEMENTS_PER_CONNECTION = 120;
 70 
 71     //Druid連接池
 72     private DruidDataSource datasource;
 73 
 74     /*
 75     * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 76     *
 77     * 接口實現
 78     *
 79     * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 80     */
 81     public Connection getConnection() throws SQLException {
 82         return datasource.getConnection();
 83     }
 84 
 85     public void shutdown() throws SQLException {
 86         datasource.close();
 87     }
 88     public void initialize() throws SQLException{
 89         if (this.URL == null) {
 90             throw new SQLException("DBPool could not be created: DB URL cannot be null");
 91         }
 92 
 93         if (this.driver == null) {
 94             throw new SQLException("DBPool driver could not be created: DB driver class name cannot be null!");
 95         }
 96 
 97         if (this.maxConnection < 0) {
 98             throw new SQLException("DBPool maxConnectins could not be created: Max connections must be greater than zero!");
 99         }
100 
101         datasource = new DruidDataSource();
102         try{
103             datasource.setDriverClassName(this.driver);
104         } catch (Exception e) {
105             try {
106                 throw new SchedulerException("Problem setting driver class name on datasource: " + e.getMessage(), e);
107             } catch (SchedulerException e1) {
108             }
109         }
110 
111         datasource.setUrl(this.URL);
112         datasource.setUsername(this.user);
113         datasource.setPassword(this.password);
114         datasource.setMaxActive(this.maxConnection);
115         datasource.setMinIdle(1);
116         datasource.setMaxWait(0);
117         datasource.setMaxPoolPreparedStatementPerConnectionSize(this.DEFAULT_DB_MAX_CACHED_STATEMENTS_PER_CONNECTION);
118 
119         if (this.validationQuery != null) {
120             datasource.setValidationQuery(this.validationQuery);
121             if(!this.validateOnCheckout)
122                 datasource.setTestOnReturn(true);
123             else
124                 datasource.setTestOnBorrow(true);
125             datasource.setValidationQueryTimeout(this.idleConnectionValidationSeconds);
126         }
127     }
128 
129     /*
130     * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
131     *
132     * 提供get set方法
133     *
134     * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
135     */
136     public String getDriver() {
137         return driver;
138     }
139 
140     public void setDriver(String driver) {
141         this.driver = driver;
142     }
143 
144     public String getURL() {
145         return URL;
146     }
147 
148     public void setURL(String URL) {
149         this.URL = URL;
150     }
151 
152     public String getUser() {
153         return user;
154     }
155 
156     public void setUser(String user) {
157         this.user = user;
158     }
159 
160     public String getPassword() {
161         return password;
162     }
163 
164     public void setPassword(String password) {
165         this.password = password;
166     }
167 
168     public int getMaxConnection() {
169         return maxConnection;
170     }
171 
172     public void setMaxConnection(int maxConnection) {
173         this.maxConnection = maxConnection;
174     }
175 
176     public String getValidationQuery() {
177         return validationQuery;
178     }
179 
180     public void setValidationQuery(String validationQuery) {
181         this.validationQuery = validationQuery;
182     }
183 
184     public boolean isValidateOnCheckout() {
185         return validateOnCheckout;
186     }
187 
188     public void setValidateOnCheckout(boolean validateOnCheckout) {
189         this.validateOnCheckout = validateOnCheckout;
190     }
191 
192     public int getIdleConnectionValidationSeconds() {
193         return idleConnectionValidationSeconds;
194     }
195 
196     public void setIdleConnectionValidationSeconds(int idleConnectionValidationSeconds) {
197         this.idleConnectionValidationSeconds = idleConnectionValidationSeconds;
198     }
199 
200     public DruidDataSource getDatasource() {
201         return datasource;
202     }
203 
204     public void setDatasource(DruidDataSource datasource) {
205         this.datasource = datasource;
206     }
207 }

quartz.properties

 1 #
 2 #============================================================================
 3 # Configure Main Scheduler Properties 調度器屬性
 4 #============================================================================
 5 org.quartz.scheduler.instanceName: DefaultQuartzScheduler
 6 org.quartz.scheduler.instanceId = AUTO
 7 org.quartz.scheduler.rmi.export: false
 8 org.quartz.scheduler.rmi.proxy: false
 9 org.quartz.scheduler.wrapJobExecutionInUserTransaction: false
10 org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
11 org.quartz.threadPool.threadCount= 10
12 org.quartz.threadPool.threadPriority: 5
13 org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true
14 org.quartz.jobStore.misfireThreshold: 60000
15 #============================================================================
16 # Configure JobStore
17 #============================================================================
18 #存儲方式使用JobStoreTX，也就是數據庫
19 org.quartz.jobStore.class: org.quartz.impl.jdbcjobstore.JobStoreTX
20 org.quartz.jobStore.driverDelegateClass:org.quartz.impl.jdbcjobstore.StdJDBCDelegate
21 #使用自己的配置文件
22 org.quartz.jobStore.useProperties:true
23 #數據庫中quartz表的表名前綴
24 org.quartz.jobStore.tablePrefix:qrtz_
25 org.quartz.jobStore.dataSource:qzDS
26 #是否使用集群（如果項目只部署到 一台服務器，就不用了）
27 org.quartz.jobStore.isClustered = true
28 #============================================================================
29 # Configure Datasources
30 #============================================================================
31 #配置數據庫源（org.quartz.dataSource.qzDS.maxConnections: c3p0配置的是有s的，druid數據源沒有s）
32 org.quartz.dataSource.qzDS.connectionProvider.class:com.yuan.quartz02.utils.DruidConnectionProvider
33 org.quartz.dataSource.qzDS.driver: com.mysql.jdbc.Driver
34 org.quartz.dataSource.qzDS.URL: jdbc:mysql://localhost:3306/j2ee?useUnicode=true&characterEncoding=utf8
35 org.quartz.dataSource.qzDS.user: root
36 org.quartz.dataSource.qzDS.password: 12345
37 org.quartz.dataSource.qzDS.maxConnection: 10

MyJobFactory

 1 package com.yuan.quartz02.utils;
 2 
 3 import lombok.extern.slf4j.Slf4j;
 4 import org.quartz.spi.TriggerFiredBundle;
 5 import org.springframework.beans.factory.annotation.Autowired;
 6 import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
 7 import org.springframework.scheduling.quartz.AdaptableJobFactory;
 8 import org.springframework.stereotype.Component;
 9 
10 @Component
11 @Slf4j
12 public class MyJobFactory extends AdaptableJobFactory {
13 
14     //這個對象Spring會幫我們自動注入進來
15     @Autowired
16     private AutowireCapableBeanFactory autowireCapableBeanFactory;
17 
18     //重寫創建Job任務的實例方法
19     @Override
20     protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
21         Object jobInstance = super.createJobInstance(bundle);
22         //通過以下方式，解決Job任務無法使用Spring中的Bean問題
23         autowireCapableBeanFactory.autowireBean(jobInstance);
24         return super.createJobInstance(bundle);
25     }
26 }

QuartzConfiguration.java（quartz調度框架與spring框架整合的配置類，主要是要將org.quartz.Scheduler交給spring進行管理）

 1 package com.yuan.quartz02.config;
 2 
 3 import com.yuan.quartz02.utils.MyJobFactory;
 4 import org.quartz.Scheduler;
 5 import org.springframework.beans.factory.annotation.Autowired;
 6 import org.springframework.beans.factory.config.PropertiesFactoryBean;
 7 import org.springframework.context.annotation.Bean;
 8 import org.springframework.context.annotation.Configuration;
 9 import org.springframework.core.io.ClassPathResource;
10 import org.springframework.scheduling.quartz.SchedulerFactoryBean;
11 
12 import java.io.IOException;
13 import java.util.Properties;
14 
15 @Configuration
16 public class QuartzConfiguration {
17 
18     @Autowired
19     private MyJobFactory myJobFactory;
20 
21     //創建調度器工廠
22     @Bean
23         public SchedulerFactoryBean schedulerFactoryBean(){
24             //1.創建SchedulerFactoryBean
25             //2.加載自定義的quartz.properties配置文件
26             //3.設置MyJobFactory
27 
28             SchedulerFactoryBean factoryBean=new SchedulerFactoryBean();
29             try {
30                 factoryBean.setQuartzProperties(quartzProperties());
31                 factoryBean.setJobFactory(myJobFactory);
32                 return factoryBean;
33             } catch (IOException e) {
34                 throw new RuntimeException(e);
35             }
36     }
37 
38     @Bean
39     public Properties quartzProperties() throws IOException {
40         PropertiesFactoryBean propertiesFactoryBean=new PropertiesFactoryBean();
41         propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
42         propertiesFactoryBean.afterPropertiesSet();
43         return propertiesFactoryBean.getObject();
44     }
45 
46     @Bean(name="scheduler")
47     public Scheduler scheduler(){
48         return schedulerFactoryBean().getScheduler();
49     }
50 }

案例中需要觀察表數據變化的表

 1 -- 自定義的業務表
 2 SELECT * FROM t_schedule_trigger;
 3 SELECT * FROM t_schedule_trigger_param;
 4 
 5 -- quartz調度框架自帶的表
 6 SELECT * FROM qrtz_scheduler_state;
 7 SELECT * FROM qrtz_cron_triggers;
 8 SELECT * FROM qrtz_simple_triggers
 9 SELECT * FROM qrtz_triggers;
10 SELECT * FROM qrtz_job_details;

項目目錄結構

導入pom依賴

  1 <?xml version="1.0" encoding="UTF-8"?>
  2 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4     <modelVersion>4.0.0</modelVersion>
  5     <parent>
  6         <groupId>org.springframework.boot</groupId>
  7         <artifactId>spring-boot-starter-parent</artifactId>
  8         <version>2.2.1.RELEASE</version>
  9         <relativePath/> <!-- lookup parent from repository -->
 10     </parent>
 11     <groupId>com.yuan</groupId>
 12     <artifactId>quartz02</artifactId>
 13     <version>0.0.1-SNAPSHOT</version>
 14     <name>quartz02</name>
 15     <description>Demo project for Spring Boot</description>
 16 
 17     <properties>
 18         <java.version>1.8</java.version>
 19         <mysql.version>5.1.44</mysql.version>
 20     </properties>
 21 
 22     <dependencies>
 23         <dependency>
 24             <groupId>org.springframework.boot</groupId>
 25             <artifactId>spring-boot-starter-jdbc</artifactId>
 26         </dependency>
 27         <dependency>
 28             <groupId>org.springframework.boot</groupId>
 29             <artifactId>spring-boot-starter-quartz</artifactId>
 30         </dependency>
 31         <dependency>
 32             <groupId>org.springframework.boot</groupId>
 33             <artifactId>spring-boot-starter-thymeleaf</artifactId>
 34         </dependency>
 35         <dependency>
 36             <groupId>org.springframework.boot</groupId>
 37             <artifactId>spring-boot-starter-web</artifactId>
 38         </dependency>
 39         <dependency>
 40             <groupId>org.mybatis.spring.boot</groupId>
 41             <artifactId>mybatis-spring-boot-starter</artifactId>
 42             <version>2.1.1</version>
 43         </dependency>
 44 
 45         <dependency>
 46             <groupId>mysql</groupId>
 47             <artifactId>mysql-connector-java</artifactId>
 48             <version>${mysql.version}</version>
 49             <scope>runtime</scope>
 50         </dependency>
 51         <dependency>
 52             <groupId>org.projectlombok</groupId>
 53             <artifactId>lombok</artifactId>
 54             <optional>true</optional>
 55         </dependency>
 56         <dependency>
 57             <groupId>org.springframework.boot</groupId>
 58             <artifactId>spring-boot-starter-test</artifactId>
 59             <scope>test</scope>
 60             <exclusions>
 61                 <exclusion>
 62                     <groupId>org.junit.vintage</groupId>
 63                     <artifactId>junit-vintage-engine</artifactId>
 64                 </exclusion>
 65             </exclusions>
 66         </dependency>
 67 
 68         <dependency>
 69             <groupId>com.alibaba</groupId>
 70             <artifactId>druid-spring-boot-starter</artifactId>
 71             <version>1.1.10</version>
 72         </dependency>
 73         <dependency>
 74             <groupId>org.quartz-scheduler</groupId>
 75             <artifactId>quartz-jobs</artifactId>
 76             <version>2.2.1</version>
 77         </dependency>
 78 
 79     </dependencies>
 80 
 81     <build>
 82 
 83         <resources>
 84             <resource>
 85                 <directory>src/main/resources</directory>
 86             </resource>
 87             <!--解決mybatis-generator-maven-plugin運行時沒有將XxxMapper.xml文件放入target文件夾的問題-->
 88             <resource>
 89                 <directory>src/main/java</directory>
 90                 <includes>
 91                     <include>**/*.xml</include>
 92                 </includes>
 93             </resource>
 94             <!--解決mybatis-generator-maven-plugin運行時沒有將jdbc.properites文件放入target文件夾的問題-->
 95             <resource>
 96                 <directory>src/main/resources</directory>
 97                 <includes>
 98                     <include>*.properties</include>
 99                     <include>*.xml</include>
100                     <include>*.yml</include>
101                 </includes>
102             </resource>
103         </resources>
104 
105 
106         <plugins>
107             <plugin>
108                 <groupId>org.mybatis.generator</groupId>
109                 <artifactId>mybatis-generator-maven-plugin</artifactId>
110                 <version>1.3.2</version>
111                 <dependencies>
112                     <!--使用Mybatis-generator插件不能使用太高版本的mysql驅動 -->
113                     <dependency>
114                         <groupId>mysql</groupId>
115                         <artifactId>mysql-connector-java</artifactId>
116                         <version>${mysql.version}</version>
117                     </dependency>
118                 </dependencies>
119                 <configuration>
120                     <overwrite>true</overwrite>
121                 </configuration>
122             </plugin>
123 
124             <plugin>
125                 <groupId>org.springframework.boot</groupId>
126                 <artifactId>spring-boot-maven-plugin</artifactId>
127             </plugin>
128         </plugins>
129     </build>
130 
131 </project>

配置application.yml

 1 server:
 2   servlet:
 3     context-path: /quartz
 4 spring:
 5   datasource:
 6     #1.JDBC
 7     type: com.alibaba.druid.pool.DruidDataSource
 8     driver-class-name: com.mysql.jdbc.Driver
 9     url: jdbc:mysql://localhost:3306/j2ee?useUnicode=true&characterEncoding=utf8
10     username: root
11     password: 12345
12     druid:
13       #2.連接池配置
14       #初始化連接池的連接數量 大小，最小，最大
15       initial-size: 5
16       min-idle: 5
17       max-active: 20
18       #配置獲取連接等待超時的時間
19       max-wait: 60000
20       #配置間隔多久才進行一次檢測，檢測需要關閉的空閑連接，單位是毫秒
21       time-between-eviction-runs-millis: 60000
22       # 配置一個連接在池中最小生存的時間，單位是毫秒
23       min-evictable-idle-time-millis: 30000
24       validation-query: SELECT 1 FROM DUAL
25       test-while-idle: true
26       test-on-borrow: true
27       test-on-return: false
28       # 是否緩存preparedStatement，也就是PSCache  官方建議MySQL下建議關閉   個人建議如果想用SQL防火牆 建議打開
29       pool-prepared-statements: true
30       max-pool-prepared-statement-per-connection-size: 20
31       # 配置監控統計攔截的filters，去掉后監控界面sql無法統計，'wall'用於防火牆
32       filter:
33         stat:
34           merge-sql: true
35           slow-sql-millis: 5000
36       #3.基礎監控配置
37       web-stat-filter:
38         enabled: true
39         url-pattern: /*
40         #設置不統計哪些URL
41         exclusions: "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*"
42         session-stat-enable: true
43         session-stat-max-count: 100
44       stat-view-servlet:
45         enabled: true
46         url-pattern: /druid/*
47         reset-enable: true
48         #設置監控頁面的登錄名和密碼
49         login-username: admin
50         login-password: admin
51         allow: 127.0.0.1
52         #deny: 192.168.1.100
53 
54 #顯示日志
55 logging:
56   level:
57     com.yuan.quartz02.mapper: debug

Quartz02Application

 1 package com.yuan.quartz02;
 2 
 3 import org.mybatis.spring.annotation.MapperScan;
 4 import org.springframework.boot.SpringApplication;
 5 import org.springframework.boot.autoconfigure.SpringBootApplication;
 6 import org.springframework.scheduling.annotation.EnableScheduling;
 7 import org.springframework.transaction.annotation.EnableTransactionManagement;
 8 
 9 @MapperScan("com.yuan.quartz02.mapper")
10 @EnableTransactionManagement
11 @EnableScheduling
12 @SpringBootApplication
13 public class Quartz02Application {
14 
15     public static void main(String[] args) {
16         SpringApplication.run(Quartz02Application.class, args);
17     }
18 
19 }

添加逆向生成代碼generatorConfig.xml

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
 3         "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd" >
 4 <generatorConfiguration>
 5     <!-- 引入配置文件 -->
 6     <properties resource="jdbc.properties"/>
 7 
 8     <!--指定數據庫jdbc驅動jar包的位置-->
 9     <classPathEntry location="D:\Maven-folder\apache-maven-3.5.0-bin\apache-maven-3.5.0\mvn_repository\mysql\mysql-connector-java\5.1.44\mysql-connector-java-5.1.44.jar"/>
10 
11     <!-- 一個數據庫一個context -->
12     <context id="infoGuardian">
13         <!-- 注釋 -->
14         <commentGenerator>
15             <property name="suppressAllComments" value="true"/><!-- 是否取消注釋 -->
16             <property name="suppressDate" value="true"/> <!-- 是否生成注釋代時間戳 -->
17         </commentGenerator>
18 
19         <!-- jdbc連接 -->
20         <jdbcConnection driverClass="${jdbc.driver}"
21                         connectionURL="${jdbc.url}" userId="${jdbc.username}" password="${jdbc.password}"/>
22 
23         <!-- 類型轉換 -->
24         <javaTypeResolver>
25             <!-- 是否使用bigDecimal， false可自動轉化以下類型（Long, Integer, Short, etc.） -->
26             <property name="forceBigDecimals" value="false"/>
27         </javaTypeResolver>
28 
29         <!-- 01 指定javaBean生成的位置 -->
30         <!-- targetPackage：指定生成的model生成所在的包名 -->
31         <!-- targetProject：指定在該項目下所在的路徑  -->
32         <javaModelGenerator targetPackage="com.yuan.quartz02.model"
33                             targetProject="src/main/java">
34             <!-- 是否允許子包，即targetPackage.schemaName.tableName -->
35             <property name="enableSubPackages" value="false"/>
36             <!-- 是否對model添加構造函數 -->
37             <property name="constructorBased" value="true"/>
38             <!-- 是否針對string類型的字段在set的時候進行trim調用 -->
39             <property name="trimStrings" value="false"/>
40             <!-- 建立的Model對象是否 不可改變  即生成的Model對象不會有 setter方法，只有構造方法 -->
41             <property name="immutable" value="false"/>
42         </javaModelGenerator>
43 
44         <!-- 02 指定sql映射文件生成的位置 -->
45         <sqlMapGenerator targetPackage="com.yuan.quartz02.mapper"
46                          targetProject="src/main/java">
47             <!-- 是否允許子包，即targetPackage.schemaName.tableName -->
48             <property name="enableSubPackages" value="false"/>
49         </sqlMapGenerator>
50 
51         <!-- 03 生成XxxMapper接口 -->
52         <!-- type="ANNOTATEDMAPPER",生成Java Model 和基於注解的Mapper對象 -->
53         <!-- type="MIXEDMAPPER",生成基於注解的Java Model 和相應的Mapper對象 -->
54         <!-- type="XMLMAPPER",生成SQLMap XML文件和獨立的Mapper接口 -->
55         <javaClientGenerator targetPackage="com.yuan.quartz02.mapper"
56                              targetProject="src/main/java" type="XMLMAPPER">
57             <!-- 是否在當前路徑下新加一層schema,false路徑com.oop.eksp.user.model， true:com.oop.eksp.user.model.[schemaName] -->
58             <property name="enableSubPackages" value="false"/>
59         </javaClientGenerator>
60 
61         <!-- 配置表信息 -->
62         <table schema="" tableName="t_schedule_trigger" domainObjectName="ScheduleTrigger"
63                enableCountByExample="false" enableDeleteByExample="false"
64                enableSelectByExample="false" enableUpdateByExample="false">
65             <property name="useActualColumnNames" value="true" />
66         </table>
67         <table schema="" tableName="t_schedule_trigger_param" domainObjectName="ScheduleTriggerParam"
68                enableCountByExample="false" enableDeleteByExample="false"
69                enableSelectByExample="false" enableUpdateByExample="false">
70             <property name="useActualColumnNames" value="true" />
71         </table>
72 
73     </context>
74 </generatorConfiguration>

jdbc.properties

1 jdbc.driver=com.mysql.jdbc.Driver
2 jdbc.url=jdbc:mysql://localhost:3306/j2ee?useUnicode=true&characterEncoding=UTF-8
3 jdbc.username=root
4 jdbc.password=12345

ScheduleTriggerMapper

 1 package com.yuan.quartz02.mapper;
 2 
 3 import com.yuan.quartz02.model.ScheduleTrigger;
 4 import org.springframework.stereotype.Repository;
 5 
 6 import java.util.List;
 7 
 8 @Repository
 9 public interface ScheduleTriggerMapper {
10     int deleteByPrimaryKey(Integer id);
11 
12     int insert(ScheduleTrigger record);
13 
14     int insertSelective(ScheduleTrigger record);
15 
16     ScheduleTrigger selectByPrimaryKey(Integer id);
17 
18     int updateByPrimaryKeySelective(ScheduleTrigger record);
19 
20     int updateByPrimaryKey(ScheduleTrigger record);
21 
22     /**
23      * 查詢觸發器中包含的所有任務
24      * @return
25      */
26     List<ScheduleTrigger> queryScheduleTriggerLst();
27 }

在自動生成的ScheduleTriggerMapper.xml中添加

1   <select id="queryScheduleTriggerLst" resultType="com.yuan.quartz02.model.ScheduleTrigger">
2     select <include refid="Base_Column_List"/>
3     from t_schedule_trigger
4   </select>

ScheduleTriggerParamMapper

 1 package com.yuan.quartz02.mapper;
 2 
 3 import com.yuan.quartz02.model.ScheduleTriggerParam;
 4 import org.springframework.stereotype.Repository;
 5 
 6 import java.util.List;
 7 
 8 @Repository
 9 public interface ScheduleTriggerParamMapper {
10     int deleteByPrimaryKey(Integer param_id);
11 
12     int insert(ScheduleTriggerParam record);
13 
14     int insertSelective(ScheduleTriggerParam record);
15 
16     ScheduleTriggerParam selectByPrimaryKey(Integer param_id);
17 
18     int updateByPrimaryKeySelective(ScheduleTriggerParam record);
19 
20     int updateByPrimaryKey(ScheduleTriggerParam record);
21 
22     /**
23      * 查詢出當前任務類對應所需的參數
24      * @param triggerId
25      * @return
26      */
27     List<ScheduleTriggerParam> queryScheduleParamLst(Integer triggerId);
28 }

在自動生成的ScheduleTriggerParamMapper.xml中添加

1   <select id="queryScheduleParamLst" resultType="com.yuan.quartz02.model.ScheduleTriggerParam">
2     select <include refid="Base_Column_List"/>
3     from t_schedule_trigger_param where schedule_trigger_id=#{triggerId}
4   </select>

service層

ScheduleTriggerService

 1 package com.yuan.quartz02.service;
 2 
 3 import com.yuan.quartz02.model.ScheduleTrigger;
 4 
 5 import java.util.List;
 6 public interface ScheduleTriggerService {
 7     int deleteByPrimaryKey(Integer id);
 8 
 9     int insert(ScheduleTrigger record);
10 
11     int insertSelective(ScheduleTrigger record);
12 
13     ScheduleTrigger selectByPrimaryKey(Integer id);
14 
15     int updateByPrimaryKeySelective(ScheduleTrigger record);
16 
17     int updateByPrimaryKey(ScheduleTrigger record);
18 
19     /**
20      * 查詢觸發器中包含的所有任務
21      * @return
22      */
23     List<ScheduleTrigger> queryScheduleTriggerLst();
24 
25 }

ScheduleTriggerServiceImpl

  1 package com.yuan.quartz02.service.impl;
  2 
  3 import com.yuan.quartz02.mapper.ScheduleTriggerMapper;
  4 import com.yuan.quartz02.mapper.ScheduleTriggerParamMapper;
  5 import com.yuan.quartz02.model.ScheduleTrigger;
  6 import com.yuan.quartz02.model.ScheduleTriggerParam;
  7 import com.yuan.quartz02.service.ScheduleTriggerService;
  8 import org.quartz.*;
  9 import org.springframework.beans.factory.annotation.Autowired;
 10 import org.springframework.scheduling.annotation.Scheduled;
 11 import org.springframework.stereotype.Service;
 12 
 13 import java.util.List;
 14 
 15 @Service
 16 public class ScheduleTriggerServiceImpl implements ScheduleTriggerService {
 17 
 18     @Autowired
 19     private ScheduleTriggerMapper scheduleTriggerMapper;
 20 
 21     @Autowired
 22     private ScheduleTriggerParamMapper scheduleTriggerParamMapper;
 23 
 24     @Autowired
 25     private Scheduler scheduler;
 26 
 27     @Scheduled(cron = "0/10 * * * * ?")
 28     public void refreshScheduler(){
 29         try {
 30             List<ScheduleTrigger> scheduleTriggers =
 31                     scheduleTriggerMapper.queryScheduleTriggerLst();
 32             if(null!=scheduleTriggers){
 33                 for (ScheduleTrigger scheduleTrigger : scheduleTriggers) {
 34                     String cron = scheduleTrigger.getCron();  //表達式
 35                     String jobName = scheduleTrigger.getJob_name(); //任務名稱
 36                     String jobGroup = scheduleTrigger.getJob_group(); //任務分組
 37                     String status = scheduleTrigger.getStatus();  //任務狀態
 38 
 39                     //JobName+JobGroup=Primary Key
 40                     //根據jobName和jobGroup生成TriggerKey
 41                     TriggerKey triggerKey =
 42                             TriggerKey.triggerKey(jobName, jobGroup);
 43                     //根據TriggerKey到Scheduler調度器中獲取觸發器
 44                     CronTrigger cronTrigger = (CronTrigger)
 45                             scheduler.getTrigger(triggerKey);
 46 
 47                     if(null==cronTrigger){
 48                         if(status.equals("0"))
 49                             continue;
 50                         System.out.println("創建調度器");
 51                         //創建任務詳情
 52                         JobDetail jobDetail=
 53                                 JobBuilder.newJob((Class<? extends Job>) Class.forName(jobName))
 54                                 .withIdentity(jobName,jobGroup)
 55                                 .build();
 56 
 57                         //往Job任務中傳遞參數
 58                         JobDataMap jobDataMap = jobDetail.getJobDataMap();
 59                         List<ScheduleTriggerParam> params =
 60                                 scheduleTriggerParamMapper.queryScheduleParamLst(scheduleTrigger.getId());
 61                         for (ScheduleTriggerParam param : params) {
 62                             jobDataMap.put(param.getName(),param.getValue());
 63                         }
 64 
 65                         //創建表達式調度器
 66                         CronScheduleBuilder cronSchedule =
 67                                 CronScheduleBuilder.cronSchedule(cron);
 68 
 69                         //創建Trigger
 70                         cronTrigger=TriggerBuilder.newTrigger()
 71                                     .withIdentity(jobName,jobGroup)
 72                                     .withSchedule(cronSchedule)
 73                                     .build();
 74 
 75                         //將jobDetail和Trigger注入到scheduler調度器中
 76                         scheduler.scheduleJob(jobDetail,cronTrigger);
 77                     }else{
 78                         //System.out.println("Quartz 調度任務中已存在該任務");
 79                         if(status.equals("0")){
 80                             JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
 81                             scheduler.deleteJob(jobKey);
 82                             continue;
 83                         }
 84                         //調度器中的表達式
 85                         String cronExpression =
 86                                 cronTrigger.getCronExpression();
 87 
 88                         if(!cron.equals(cronExpression)){
 89                             //創建表達式調度器
 90                             CronScheduleBuilder cronSchedule =
 91                                     CronScheduleBuilder.cronSchedule(cron);
 92 
 93                             //重構
 94                             cronTrigger=cronTrigger.getTriggerBuilder()
 95                                     .withIdentity(triggerKey)
 96                                     .withSchedule(cronSchedule)
 97                                     .build();
 98 
 99                             //刷新調度器
100                             scheduler.rescheduleJob(triggerKey,cronTrigger);
101                         }
102                     }
103                 }
104             }
105         } catch (Exception e) {
106             e.printStackTrace();
107         }
108     }
109 
110     @Override
111     public int deleteByPrimaryKey(Integer id) {
112         return scheduleTriggerMapper.deleteByPrimaryKey(id);
113     }
114 
115     @Override
116     public int insert(ScheduleTrigger record) {
117         return scheduleTriggerMapper.insert(record);
118     }
119 
120     @Override
121     public int insertSelective(ScheduleTrigger record) {
122         return scheduleTriggerMapper.insertSelective(record);
123     }
124 
125     @Override
126     public ScheduleTrigger selectByPrimaryKey(Integer id) {
127         return scheduleTriggerMapper.selectByPrimaryKey(id);
128     }
129 
130     @Override
131     public int updateByPrimaryKeySelective(ScheduleTrigger record) {
132         return scheduleTriggerMapper.updateByPrimaryKeySelective(record);
133     }
134 
135     @Override
136     public int updateByPrimaryKey(ScheduleTrigger record) {
137         return scheduleTriggerMapper.updateByPrimaryKey(record);
138     }
139 
140     @Override
141     public List<ScheduleTrigger> queryScheduleTriggerLst() {
142         return scheduleTriggerMapper.queryScheduleTriggerLst();
143     }
144 }

ScheduleTriggerParamService

 1 package com.yuan.quartz02.service;
 2 
 3 import com.yuan.quartz02.model.ScheduleTriggerParam;
 4 
 5 import java.util.List;
 6 
 7 public interface ScheduleTriggerParamService {
 8 
 9     /**
10      * 查詢出當前任務類對應所需的參數
11      * @param triggerId
12      * @return
13      */
14     List<ScheduleTriggerParam> queryScheduleParamLst(Integer triggerId);
15 }

ScheduleTriggerParamServiceImpl

 1 package com.yuan.quartz02.service.impl;
 2 
 3 import com.yuan.quartz02.mapper.ScheduleTriggerParamMapper;
 4 import com.yuan.quartz02.model.ScheduleTriggerParam;
 5 import com.yuan.quartz02.service.ScheduleTriggerParamService;
 6 import org.springframework.beans.factory.annotation.Autowired;
 7 import org.springframework.stereotype.Service;
 8 
 9 import java.util.List;
10 
11 @Service
12 public class ScheduleTriggerParamServiceImpl implements ScheduleTriggerParamService {
13 
14     @Autowired
15     private ScheduleTriggerParamMapper scheduleTriggerParamMapper;
16 
17     @Override
18     public List<ScheduleTriggerParam> queryScheduleParamLst(Integer triggerId) {
19         return scheduleTriggerParamMapper.queryScheduleParamLst(triggerId);
20     }
21 }

讀取數據庫中表達式啟動定時任務

myjob

 1 package com.yuan.quartz02.quartz;
 2 
 3 import lombok.extern.slf4j.Slf4j;
 4 import org.quartz.Job;
 5 import org.quartz.JobExecutionContext;
 6 import org.quartz.JobExecutionException;
 7 import org.springframework.stereotype.Component;
 8 
 9 import java.util.Date;
10 
11 @Component
12 @Slf4j
13 public class MyJob implements Job {
14 
15     @Override
16     public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
17         System.out.println("MyJob是一個空的任務計划,時間："+new Date().toLocaleString());
18     }
19 }

Spring自帶定時任務每10s執行一次，查詢自定義觸發器表，

獲取到具體的作業類及任務表達式，quartz的任務為每5s執行一次，所以打印如上

更改定時任務狀態

更改數據庫調度器表t_schedule_trigger的state狀態

讀取數據庫中表達式啟動定時任務

數據庫表t_schedule_trigger配置

當禁用該觸發器時，那么程序只會執行spring自帶的定時任務，每10s執行一次查詢，所以打印語句如上。

MyJob1

 1 package com.yuan.quartz02.quartz;
 2 
 3 import com.yuan.quartz02.service.ScheduleTriggerParamService;
 4 import lombok.extern.slf4j.Slf4j;
 5 import org.quartz.*;
 6 import org.springframework.beans.factory.annotation.Autowired;
 7 import org.springframework.stereotype.Component;
 8 
 9 import java.util.Date;
10 
11 @Component
12 @Slf4j
13 public class MyJob1 implements Job {
14 
15     @Autowired
16     private ScheduleTriggerParamService scheduleTriggerParamService;
17 
18     @Override
19     public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
20         JobDetail jobDetail =
21                 jobExecutionContext.getJobDetail();
22         JobDataMap jobDataMap = jobDetail.getJobDataMap();
23         System.err.println(new Date().toLocaleString()+"-->攜帶參數個數:"+jobDataMap.size());
24     }
25 }

程序執行spring自帶的定時任務，每10s執行一次查詢，查詢t_schedule_trigger表，

調度器表中有兩個調度器，都是每5s執行一次，其中一個調度器是需要攜帶參數的，

攜帶的參數在t_schedule_trigger_param表中，所以一開始調度器啟動的時候需要查詢t_schedule_trigger_param表數據，最終打印語句如上。

更改定時任務規則

t_schedule_trigger

程序執行spring自帶的定時任務，每10s執行一次查詢，查詢t_schedule_trigger表

控制器
QuartzController

 1 package com.yuan.quartz02.controller;
 2 
 3 import com.yuan.quartz02.model.ScheduleTrigger;
 4 import com.yuan.quartz02.service.ScheduleTriggerService;
 5 import org.springframework.beans.factory.annotation.Autowired;
 6 import org.springframework.stereotype.Controller;
 7 import org.springframework.web.bind.annotation.PathVariable;
 8 import org.springframework.web.bind.annotation.RequestMapping;
 9 import org.springframework.web.bind.annotation.ResponseBody;
10 import org.springframework.web.servlet.ModelAndView;
11 
12 import java.util.List;
13 
14 @Controller
15 @RequestMapping("/quartz")
16 public class QuartzController {
17 
18     @Autowired
19     private ScheduleTriggerService scheduleTriggerService;
20 
21     @RequestMapping("/list")
22     public ModelAndView getAll(){
23         ModelAndView modelAndView = new ModelAndView();
24         List<ScheduleTrigger> list = scheduleTriggerService.queryScheduleTriggerLst();
25         modelAndView.addObject("quartzList",list);
26         modelAndView.setViewName("/index");
27         return modelAndView;
28     }
29 
30     @RequestMapping("/edit")
31     public String editStatus(ScheduleTrigger scheduleTrigger){
32         int n = scheduleTriggerService.updateByPrimaryKeySelective(scheduleTrigger);
33         return "redirect:/quartz/list";
34     }
35 
36     @RequestMapping("/proSave/{id}")
37     public ModelAndView proSave(@PathVariable(value = "id") Integer id){
38         ModelAndView modelAndView=new ModelAndView();
39         ScheduleTrigger scheduleTrigger = scheduleTriggerService.selectByPrimaryKey(id);
40         modelAndView.addObject("schedule",scheduleTrigger);
41         modelAndView.setViewName("/edit");
42         return modelAndView;
43     }
44 
45 }

頁面代碼

index.html

 1 <!DOCTYPE html>
 2 <html xmlns:th="http://www.thymeleaf.org">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>quartz定時任務管理</title>
 6 </head>
 7 <body>
 8 <h1 style="text-align: center">定時任務管理</h1>
 9 <table style="text-align: center" align="center" border="1px" width="80%">
10     <tr>
11         <td>任務id</td>
12         <td>任務表達式</td>
13         <td>任務狀態</td>
14         <td>job工作類</td>
15         <td>job分組</td>
16         <td>操作</td>
17     </tr>
18     <tr th:each="q : ${quartzList}">
19         <td th:text="${q.id}"></td>
20         <td th:text="${q.cron}"></td>
21         <td th:text="${q.status}"></td>
22         <td th:text="${q.job_name}"></td>
23         <td th:text="${q.job_group}"></td>
24         <td th:switch ="${q.status} == 0">
25             <a th:case="true" th:href="@{/quartz/edit(id=${q.id},status=1)}">啟動</a>
26             <a th:case="false" th:href="@{/quartz/edit(id=${q.id},status=0)}">停止</a>
27             <a th:href="@{'/quartz/proSave/'+${q.id}}">編輯</a>
28         </td>
29     </tr>
30 </table>
31 
32 
33 </body>
34 </html>

edit.html

 1 <!DOCTYPE html>
 2 <html xmlns:th="http://www.thymeleaf.org">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>編輯定時任務</title>
 6 </head>
 7 <body>
 8 <h1>編輯定時任務</h1>
 9 <form th:action="@{/quartz/edit}" method="post">
10     <input type="hidden" name="id" th:value="${schedule.id}" />
11     任務表達式： <input width="300px" type="text" name="cron" th:value="${schedule.cron}" /></br>
12     job工作類： <input width="300px" type="text" name="job_name" th:value="${schedule.job_name}" /></br>
13     job分組：<input width="300px" type="text" name="job_group" th:value="${schedule.job_group}" /></br>
14     <input type="submit" value="提交"/>
15 </form>
16 </body>
17 </html>

頁面效果

謝謝觀看！！！

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 SpringBoot+Quartz+數據庫存儲 SpringBoot+Quartz+數據庫存儲 SpringBoot+Quartz+數據庫存儲 SpringBoot+Quartz+數據庫存儲數據庫存儲 mysql 數據庫存儲結構 mysql 數據庫存儲路徑更改數據庫存儲時間的時區問題 iOS - OC SQLite 數據庫存儲 mysql數據庫存儲引擎及區別