spring boot+Quartz+数据库存储

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依赖

   <dependency>
     <groupId>com.alibaba</groupId>
     <artifactId>druid-spring-boot-starter</artifactId>
     <version>1.1.10</version>
    </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节点也没关系，因为他们共享数据库中的任务信息。

创建项目

自定义业务表

 -- 注意：job_name存放的任务类的全路径，在quartz中通过jobName和jobGroup来确定trigger的唯一性，所以这两列为联合唯一索引
 create table t_schedule_trigger
 (
   id int primary key auto_increment,                                -- ID
   cron varchar(200) not null,                                       -- 时间表达式
   status char(1) not null,                                          -- 使用状态 0：禁用   1：启用
   job_name varchar(200) not null,                                   -- 任务名称
   job_group varchar(200) not null,                                  -- 任务分组
   unique index(job_name,job_group)
 );

 -- 额外添加到任务中的参数
 create table t_schedule_trigger_param
 (
   param_id int primary key auto_increment,                                -- ID
   name varchar(200) not null,                                             -- 参数名
   value varchar(512),                                                     -- 参数值

   schedule_trigger_id int not null,                                       -- 外键：引用t_schedule_trigger(id)
   foreign key(schedule_trigger_id) references t_schedule_trigger(id)
 );

DruidConnectionProvider

 package com.yuan.quartz02.utils;

 import com.alibaba.druid.pool.DruidDataSource;
 import org.quartz.SchedulerException;
 import org.quartz.utils.ConnectionProvider;

 import java.sql.Connection;
 import java.sql.SQLException;

 /*
 #============================================================================
 # JDBC
 #============================================================================
 org.quartz.jobStore.driverDelegateClass:org.quartz.impl.jdbcjobstore.StdJDBCDelegate
 org.quartz.jobStore.useProperties:false
 org.quartz.jobStore.dataSource:qzDS
 #org.quartz.dataSource.qzDS.connectionProvider.class:org.quartz.utils.PoolingConnectionProvider
 org.quartz.dataSource.qzDS.connectionProvider.class:com.zking.q03.quartz.DruidConnectionProvider
 org.quartz.dataSource.qzDS.driver:com.mysql.jdbc.Driver
 org.quartz.dataSource.qzDS.URL:jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=UTF-8
 org.quartz.dataSource.qzDS.user:root
 org.quartz.dataSource.qzDS.password:root
 org.quartz.dataSource.qzDS.maxConnections:30
 org.quartz.dataSource.qzDS.validationQuery: select 0
 */

 /**
  * [Druid连接池的Quartz扩展类]
  *
  * @ProjectName: []
  * @Author: [xuguang]
  * @CreateDate: [2015/11/10 17:58]
  * @Update: [说明本次修改内容] BY[xuguang][2015/11/10]
  * @Version: [v1.0]
  */
 public class DruidConnectionProvider implements ConnectionProvider {

      /*
      * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      *
      * 常量配置，与quartz.properties文件的key保持一致(去掉前缀)，同时提供set方法，Quartz框架自动注入值。
      *
      * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      */

     //JDBC驱动
     public String driver;
     //JDBC连接串
     public String URL;
     //数据库用户名
     public String user;
     //数据库用户密码
     public String password;
     //数据库最大连接数
     public int maxConnection;
     //数据库SQL查询每次连接返回执行到连接池，以确保它仍然是有效的。
     public String validationQuery;

     private boolean validateOnCheckout;

     private int idleConnectionValidationSeconds;

     public String maxCachedStatementsPerConnection;

     private String discardIdleConnectionsSeconds;

     public static final int DEFAULT_DB_MAX_CONNECTIONS = 10;

     public static final int DEFAULT_DB_MAX_CACHED_STATEMENTS_PER_CONNECTION = 120;

     //Druid连接池
     private DruidDataSource datasource;

     /*
     * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     *
     * 接口实现
     *
     * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     */
     public Connection getConnection() throws SQLException {
         return datasource.getConnection();
     }

     public void shutdown() throws SQLException {
         datasource.close();
     }
     public void initialize() throws SQLException{
         if (this.URL == null) {
             throw new SQLException("DBPool could not be created: DB URL cannot be null");
         }

         if (this.driver == null) {
             throw new SQLException("DBPool driver could not be created: DB driver class name cannot be null!");
         }

         if (this.maxConnection < 0) {
             throw new SQLException("DBPool maxConnectins could not be created: Max connections must be greater than zero!");
         }

         datasource = new DruidDataSource();
         try{
             datasource.setDriverClassName(this.driver);
         } catch (Exception e) {
             try {
                 throw new SchedulerException("Problem setting driver class name on datasource: " + e.getMessage(), e);
             } catch (SchedulerException e1) {
             }
         }

         datasource.setUrl(this.URL);
         datasource.setUsername(this.user);
         datasource.setPassword(this.password);
         datasource.setMaxActive(this.maxConnection);
         datasource.setMinIdle(1);
         datasource.setMaxWait(0);
         datasource.setMaxPoolPreparedStatementPerConnectionSize(this.DEFAULT_DB_MAX_CACHED_STATEMENTS_PER_CONNECTION);

         if (this.validationQuery != null) {
             datasource.setValidationQuery(this.validationQuery);
             if(!this.validateOnCheckout)
                 datasource.setTestOnReturn(true);
             else
                 datasource.setTestOnBorrow(true);
             datasource.setValidationQueryTimeout(this.idleConnectionValidationSeconds);
         }
     }

     /*
     * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     *
     * 提供get set方法
     *
     * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     */
     public String getDriver() {
         return driver;
     }

     public void setDriver(String driver) {
         this.driver = driver;
     }

     public String getURL() {
         return URL;
     }

     public void setURL(String URL) {
         this.URL = URL;
     }

     public String getUser() {
         return user;
     }

     public void setUser(String user) {
         this.user = user;
     }

     public String getPassword() {
         return password;
     }

     public void setPassword(String password) {
         this.password = password;
     }

     public int getMaxConnection() {
         return maxConnection;
     }

     public void setMaxConnection(int maxConnection) {
         this.maxConnection = maxConnection;
     }

     public String getValidationQuery() {
         return validationQuery;
     }

     public void setValidationQuery(String validationQuery) {
         this.validationQuery = validationQuery;
     }

     public boolean isValidateOnCheckout() {
         return validateOnCheckout;
     }

     public void setValidateOnCheckout(boolean validateOnCheckout) {
         this.validateOnCheckout = validateOnCheckout;
     }

     public int getIdleConnectionValidationSeconds() {
         return idleConnectionValidationSeconds;
     }

     public void setIdleConnectionValidationSeconds(int idleConnectionValidationSeconds) {
         this.idleConnectionValidationSeconds = idleConnectionValidationSeconds;
     }

     public DruidDataSource getDatasource() {
         return datasource;
     }

     public void setDatasource(DruidDataSource datasource) {
         this.datasource = datasource;
     }
 }

quartz.properties

 #
 #============================================================================
 # Configure Main Scheduler Properties 调度器属性
 #============================================================================
 org.quartz.scheduler.instanceName: DefaultQuartzScheduler
 org.quartz.scheduler.instanceId = AUTO
 org.quartz.scheduler.rmi.export: false
 org.quartz.scheduler.rmi.proxy: false
 org.quartz.scheduler.wrapJobExecutionInUserTransaction: false
 org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
 org.quartz.threadPool.threadCount= 10
 org.quartz.threadPool.threadPriority: 5
 org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true
 org.quartz.jobStore.misfireThreshold: 60000
 #============================================================================
 # Configure JobStore
 #============================================================================
 #存储方式使用JobStoreTX，也就是数据库
 org.quartz.jobStore.class: org.quartz.impl.jdbcjobstore.JobStoreTX
 org.quartz.jobStore.driverDelegateClass:org.quartz.impl.jdbcjobstore.StdJDBCDelegate
 #使用自己的配置文件
 org.quartz.jobStore.useProperties:true
 #数据库中quartz表的表名前缀
 org.quartz.jobStore.tablePrefix:qrtz_
 org.quartz.jobStore.dataSource:qzDS
 #是否使用集群（如果项目只部署到 一台服务器，就不用了）
 org.quartz.jobStore.isClustered = true
 #============================================================================
 # Configure Datasources
 #============================================================================
 #配置数据库源（org.quartz.dataSource.qzDS.maxConnections: c3p0配置的是有s的，druid数据源没有s）
 org.quartz.dataSource.qzDS.connectionProvider.class:com.yuan.quartz02.utils.DruidConnectionProvider
 org.quartz.dataSource.qzDS.driver: com.mysql.jdbc.Driver
 org.quartz.dataSource.qzDS.URL: jdbc:mysql://localhost:3306/j2ee?useUnicode=true&characterEncoding=utf8
 org.quartz.dataSource.qzDS.user: root
 org.quartz.dataSource.qzDS.password: 12345
 org.quartz.dataSource.qzDS.maxConnection: 10

MyJobFactory

 package com.yuan.quartz02.utils;

 import lombok.extern.slf4j.Slf4j;
 import org.quartz.spi.TriggerFiredBundle;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
 import org.springframework.scheduling.quartz.AdaptableJobFactory;
 import org.springframework.stereotype.Component;

 @Component
 @Slf4j
 public class MyJobFactory extends AdaptableJobFactory {

     //这个对象Spring会帮我们自动注入进来
     @Autowired
     private AutowireCapableBeanFactory autowireCapableBeanFactory;

     //重写创建Job任务的实例方法
     @Override
     protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
         Object jobInstance = super.createJobInstance(bundle);
         //通过以下方式，解决Job任务无法使用Spring中的Bean问题
         autowireCapableBeanFactory.autowireBean(jobInstance);
         return super.createJobInstance(bundle);
     }
 }

QuartzConfiguration.java（quartz调度框架与spring框架整合的配置类，主要是要将org.quartz.Scheduler交给spring进行管理）

 package com.yuan.quartz02.config;

 import com.yuan.quartz02.utils.MyJobFactory;
 import org.quartz.Scheduler;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.config.PropertiesFactoryBean;
 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 java.io.IOException;
 import java.util.Properties;

 @Configuration
 public class QuartzConfiguration {

     @Autowired
     private MyJobFactory myJobFactory;

     //创建调度器工厂
     @Bean
         public SchedulerFactoryBean schedulerFactoryBean(){
             //1.创建SchedulerFactoryBean
             //2.加载自定义的quartz.properties配置文件
             //3.设置MyJobFactory

             SchedulerFactoryBean factoryBean=new SchedulerFactoryBean();
             try {
                 factoryBean.setQuartzProperties(quartzProperties());
                 factoryBean.setJobFactory(myJobFactory);
                 return factoryBean;
             } catch (IOException e) {
                 throw new RuntimeException(e);
             }
     }

     @Bean
     public Properties quartzProperties() throws IOException {
         PropertiesFactoryBean propertiesFactoryBean=new PropertiesFactoryBean();
         propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
         propertiesFactoryBean.afterPropertiesSet();
         return propertiesFactoryBean.getObject();
     }

     @Bean(name="scheduler")
     public Scheduler scheduler(){
         return schedulerFactoryBean().getScheduler();
     }
 }

案例中需要观察表数据变化的表

 -- 自定义的业务表
 SELECT * FROM t_schedule_trigger;
 SELECT * FROM t_schedule_trigger_param;

 -- quartz调度框架自带的表
 SELECT * FROM qrtz_scheduler_state;
 SELECT * FROM qrtz_cron_triggers;
 SELECT * FROM qrtz_simple_triggers
 SELECT * FROM qrtz_triggers;
 SELECT * FROM qrtz_job_details;

项目目录结构

导入pom依赖

 <?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <parent>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-parent</artifactId>
         <version>2.2.1.RELEASE</version>
         <relativePath/> <!-- lookup parent from repository -->
     </parent>
     <groupId>com.yuan</groupId>
     <artifactId>quartz02</artifactId>
     <version>0.0.1-SNAPSHOT</version>
     <name>quartz02</name>
     <description>Demo project for Spring Boot</description>

     <properties>
         <java.version>1.8</java.version>
         <mysql.version>5.1.44</mysql.version>
     </properties>

     <dependencies>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-jdbc</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-quartz</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-thymeleaf</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-web</artifactId>
         </dependency>
         <dependency>
             <groupId>org.mybatis.spring.boot</groupId>
             <artifactId>mybatis-spring-boot-starter</artifactId>
             <version>2.1.1</version>
         </dependency>

         <dependency>
             <groupId>mysql</groupId>
             <artifactId>mysql-connector-java</artifactId>
             <version>${mysql.version}</version>
             <scope>runtime</scope>
         </dependency>
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
             <optional>true</optional>
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-test</artifactId>
             <scope>test</scope>
             <exclusions>
                 <exclusion>
                     <groupId>org.junit.vintage</groupId>
                     <artifactId>junit-vintage-engine</artifactId>
                 </exclusion>
             </exclusions>
         </dependency>

         <dependency>
             <groupId>com.alibaba</groupId>
             <artifactId>druid-spring-boot-starter</artifactId>
             <version>1.1.10</version>
         </dependency>
         <dependency>
             <groupId>org.quartz-scheduler</groupId>
             <artifactId>quartz-jobs</artifactId>
             <version>2.2.1</version>
         </dependency>

     </dependencies>

     <build>

         <resources>
             <resource>
                 <directory>src/main/resources</directory>
             </resource>
             <!--解决mybatis-generator-maven-plugin运行时没有将XxxMapper.xml文件放入target文件夹的问题-->
             <resource>
                 <directory>src/main/java</directory>
                 <includes>
                     <include>**/*.xml</include>
                 </includes>
             </resource>
             <!--解决mybatis-generator-maven-plugin运行时没有将jdbc.properites文件放入target文件夹的问题-->
             <resource>
                 <directory>src/main/resources</directory>
                 <includes>
                     <include>*.properties</include>
                     <include>*.xml</include>
                     <include>*.yml</include>
                 </includes>
             </resource>
         </resources>

         <plugins>
             <plugin>
                 <groupId>org.mybatis.generator</groupId>
                 <artifactId>mybatis-generator-maven-plugin</artifactId>
                 <version>1.3.2</version>
                 <dependencies>
                     <!--使用Mybatis-generator插件不能使用太高版本的mysql驱动 -->
                     <dependency>
                         <groupId>mysql</groupId>
                         <artifactId>mysql-connector-java</artifactId>
                         <version>${mysql.version}</version>
                     </dependency>
                 </dependencies>
                 <configuration>
                     <overwrite>true</overwrite>
                 </configuration>
             </plugin>

             <plugin>
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-maven-plugin</artifactId>
             </plugin>
         </plugins>
     </build>

 </project>

配置application.yml

 server:
   servlet:
     context-path: /quartz
 spring:
   datasource:
     #1.JDBC
     type: com.alibaba.druid.pool.DruidDataSource
     driver-class-name: com.mysql.jdbc.Driver
     url: jdbc:mysql://localhost:3306/j2ee?useUnicode=true&characterEncoding=utf8
     username: root
     password: 12345
     druid:
       #2.连接池配置
       #初始化连接池的连接数量 大小，最小，最大
       initial-size: 5
       min-idle: 5
       max-active: 20
       #配置获取连接等待超时的时间
       max-wait: 60000
       #配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
       time-between-eviction-runs-millis: 60000
       # 配置一个连接在池中最小生存的时间，单位是毫秒
       min-evictable-idle-time-millis: 30000
       validation-query: SELECT 1 FROM DUAL
       test-while-idle: true
       test-on-borrow: true
       test-on-return: false
       # 是否缓存preparedStatement，也就是PSCache  官方建议MySQL下建议关闭   个人建议如果想用SQL防火墙 建议打开
       pool-prepared-statements: true
       max-pool-prepared-statement-per-connection-size: 20
       # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
       filter:
         stat:
           merge-sql: true
           slow-sql-millis: 5000
       #3.基础监控配置
       web-stat-filter:
         enabled: true
         url-pattern: /*
         #设置不统计哪些URL
         exclusions: "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*"
         session-stat-enable: true
         session-stat-max-count: 100
       stat-view-servlet:
         enabled: true
         url-pattern: /druid/*
         reset-enable: true
         #设置监控页面的登录名和密码
         login-username: admin
         login-password: admin
         allow: 127.0.0.1
         #deny: 192.168.1.100

 #显示日志
 logging:
   level:
     com.yuan.quartz02.mapper: debug

Quartz02Application

 package com.yuan.quartz02;

 import org.mybatis.spring.annotation.MapperScan;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.scheduling.annotation.EnableScheduling;
 import org.springframework.transaction.annotation.EnableTransactionManagement;

 @MapperScan("com.yuan.quartz02.mapper")
 @EnableTransactionManagement
 @EnableScheduling
 @SpringBootApplication
 public class Quartz02Application {

     public static void main(String[] args) {
         SpringApplication.run(Quartz02Application.class, args);
     }

 }

添加逆向生成代码generatorConfig.xml

 <?xml version="1.0" encoding="UTF-8" ?>
 <!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
         "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd" >
 <generatorConfiguration>
     <!-- 引入配置文件 -->
     <properties resource="jdbc.properties"/>

     <!--指定数据库jdbc驱动jar包的位置-->
     <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"/>

     <!-- 一个数据库一个context -->
     <context id="infoGuardian">
         <!-- 注释 -->
         <commentGenerator>
             <property name="suppressAllComments" value="true"/><!-- 是否取消注释 -->
             <property name="suppressDate" value="true"/> <!-- 是否生成注释代时间戳 -->
         </commentGenerator>

         <!-- jdbc连接 -->
         <jdbcConnection driverClass="${jdbc.driver}"
                         connectionURL="${jdbc.url}" userId="${jdbc.username}" password="${jdbc.password}"/>

         <!-- 类型转换 -->
         <javaTypeResolver>
             <!-- 是否使用bigDecimal， false可自动转化以下类型（Long, Integer, Short, etc.） -->
             <property name="forceBigDecimals" value="false"/>
         </javaTypeResolver>

         <!-- 01 指定javaBean生成的位置 -->
         <!-- targetPackage：指定生成的model生成所在的包名 -->
         <!-- targetProject：指定在该项目下所在的路径  -->
         <javaModelGenerator targetPackage="com.yuan.quartz02.model"
                             targetProject="src/main/java">
             <!-- 是否允许子包，即targetPackage.schemaName.tableName -->
             <property name="enableSubPackages" value="false"/>
             <!-- 是否对model添加构造函数 -->
             <property name="constructorBased" value="true"/>
             <!-- 是否针对string类型的字段在set的时候进行trim调用 -->
             <property name="trimStrings" value="false"/>
             <!-- 建立的Model对象是否 不可改变  即生成的Model对象不会有 setter方法，只有构造方法 -->
             <property name="immutable" value="false"/>
         </javaModelGenerator>

         <!-- 02 指定sql映射文件生成的位置 -->
         <sqlMapGenerator targetPackage="com.yuan.quartz02.mapper"
                          targetProject="src/main/java">
             <!-- 是否允许子包，即targetPackage.schemaName.tableName -->
             <property name="enableSubPackages" value="false"/>
         </sqlMapGenerator>

         <!-- 03 生成XxxMapper接口 -->
         <!-- type="ANNOTATEDMAPPER",生成Java Model 和基于注解的Mapper对象 -->
         <!-- type="MIXEDMAPPER",生成基于注解的Java Model 和相应的Mapper对象 -->
         <!-- type="XMLMAPPER",生成SQLMap XML文件和独立的Mapper接口 -->
         <javaClientGenerator targetPackage="com.yuan.quartz02.mapper"
                              targetProject="src/main/java" type="XMLMAPPER">
             <!-- 是否在当前路径下新加一层schema,false路径com.oop.eksp.user.model， true:com.oop.eksp.user.model.[schemaName] -->
             <property name="enableSubPackages" value="false"/>
         </javaClientGenerator>

         <!-- 配置表信息 -->
         <table schema="" tableName="t_schedule_trigger" domainObjectName="ScheduleTrigger"
                enableCountByExample="false" enableDeleteByExample="false"
                enableSelectByExample="false" enableUpdateByExample="false">
             <property name="useActualColumnNames" value="true" />
         </table>
         <table schema="" tableName="t_schedule_trigger_param" domainObjectName="ScheduleTriggerParam"
                enableCountByExample="false" enableDeleteByExample="false"
                enableSelectByExample="false" enableUpdateByExample="false">
             <property name="useActualColumnNames" value="true" />
         </table>

     </context>
 </generatorConfiguration>

jdbc.properties

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

ScheduleTriggerMapper

 package com.yuan.quartz02.mapper;

 import com.yuan.quartz02.model.ScheduleTrigger;
 import org.springframework.stereotype.Repository;

 import java.util.List;

 @Repository
 public interface ScheduleTriggerMapper {
     int deleteByPrimaryKey(Integer id);

     int insert(ScheduleTrigger record);

     int insertSelective(ScheduleTrigger record);

     ScheduleTrigger selectByPrimaryKey(Integer id);

     int updateByPrimaryKeySelective(ScheduleTrigger record);

     int updateByPrimaryKey(ScheduleTrigger record);

     /**
      * 查询触发器中包含的所有任务
      * @return
      */
     List<ScheduleTrigger> queryScheduleTriggerLst();
 }

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

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

ScheduleTriggerParamMapper

 package com.yuan.quartz02.mapper;

 import com.yuan.quartz02.model.ScheduleTriggerParam;
 import org.springframework.stereotype.Repository;

 import java.util.List;

 @Repository
 public interface ScheduleTriggerParamMapper {
     int deleteByPrimaryKey(Integer param_id);

     int insert(ScheduleTriggerParam record);

     int insertSelective(ScheduleTriggerParam record);

     ScheduleTriggerParam selectByPrimaryKey(Integer param_id);

     int updateByPrimaryKeySelective(ScheduleTriggerParam record);

     int updateByPrimaryKey(ScheduleTriggerParam record);

     /**
      * 查询出当前任务类对应所需的参数
      * @param triggerId
      * @return
      */
     List<ScheduleTriggerParam> queryScheduleParamLst(Integer triggerId);
 }

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

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

service层

ScheduleTriggerService

 package com.yuan.quartz02.service;

 import com.yuan.quartz02.model.ScheduleTrigger;

 import java.util.List;
 public interface ScheduleTriggerService {
     int deleteByPrimaryKey(Integer id);

     int insert(ScheduleTrigger record);

     int insertSelective(ScheduleTrigger record);

     ScheduleTrigger selectByPrimaryKey(Integer id);

     int updateByPrimaryKeySelective(ScheduleTrigger record);

     int updateByPrimaryKey(ScheduleTrigger record);

     /**
      * 查询触发器中包含的所有任务
      * @return
      */
     List<ScheduleTrigger> queryScheduleTriggerLst();

 }

ScheduleTriggerServiceImpl

 package com.yuan.quartz02.service.impl;

 import com.yuan.quartz02.mapper.ScheduleTriggerMapper;
 import com.yuan.quartz02.mapper.ScheduleTriggerParamMapper;
 import com.yuan.quartz02.model.ScheduleTrigger;
 import com.yuan.quartz02.model.ScheduleTriggerParam;
 import com.yuan.quartz02.service.ScheduleTriggerService;
 import org.quartz.*;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Service;

 import java.util.List;

 @Service
 public class ScheduleTriggerServiceImpl implements ScheduleTriggerService {

     @Autowired
     private ScheduleTriggerMapper scheduleTriggerMapper;

     @Autowired
     private ScheduleTriggerParamMapper scheduleTriggerParamMapper;

     @Autowired
     private Scheduler scheduler;

     @Scheduled(cron = "0/10 * * * * ?")
     public void refreshScheduler(){
         try {
             List<ScheduleTrigger> scheduleTriggers =
                     scheduleTriggerMapper.queryScheduleTriggerLst();
             if(null!=scheduleTriggers){
                 for (ScheduleTrigger scheduleTrigger : scheduleTriggers) {
                     String cron = scheduleTrigger.getCron();  //表达式
                     String jobName = scheduleTrigger.getJob_name(); //任务名称
                     String jobGroup = scheduleTrigger.getJob_group(); //任务分组
                     String status = scheduleTrigger.getStatus();  //任务状态

                     //JobName+JobGroup=Primary Key
                     //根据jobName和jobGroup生成TriggerKey
                     TriggerKey triggerKey =
                             TriggerKey.triggerKey(jobName, jobGroup);
                     //根据TriggerKey到Scheduler调度器中获取触发器
                     CronTrigger cronTrigger = (CronTrigger)
                             scheduler.getTrigger(triggerKey);

                     if(null==cronTrigger){
                         if(status.equals("0"))
                             continue;
                         System.out.println("创建调度器");
                         //创建任务详情
                         JobDetail jobDetail=
                                 JobBuilder.newJob((Class<? extends Job>) Class.forName(jobName))
                                 .withIdentity(jobName,jobGroup)
                                 .build();

                         //往Job任务中传递参数
                         JobDataMap jobDataMap = jobDetail.getJobDataMap();
                         List<ScheduleTriggerParam> params =
                                 scheduleTriggerParamMapper.queryScheduleParamLst(scheduleTrigger.getId());
                         for (ScheduleTriggerParam param : params) {
                             jobDataMap.put(param.getName(),param.getValue());
                         }

                         //创建表达式调度器
                         CronScheduleBuilder cronSchedule =
                                 CronScheduleBuilder.cronSchedule(cron);

                         //创建Trigger
                         cronTrigger=TriggerBuilder.newTrigger()
                                     .withIdentity(jobName,jobGroup)
                                     .withSchedule(cronSchedule)
                                     .build();

                         //将jobDetail和Trigger注入到scheduler调度器中
                         scheduler.scheduleJob(jobDetail,cronTrigger);
                     }else{
                         //System.out.println("Quartz 调度任务中已存在该任务");
                         if(status.equals("0")){
                             JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
                             scheduler.deleteJob(jobKey);
                             continue;
                         }
                         //调度器中的表达式
                         String cronExpression =
                                 cronTrigger.getCronExpression();

                         if(!cron.equals(cronExpression)){
                             //创建表达式调度器
                             CronScheduleBuilder cronSchedule =
                                     CronScheduleBuilder.cronSchedule(cron);

                             //重构
                             cronTrigger=cronTrigger.getTriggerBuilder()
                                     .withIdentity(triggerKey)
                                     .withSchedule(cronSchedule)
                                     .build();

                             //刷新调度器
                             scheduler.rescheduleJob(triggerKey,cronTrigger);
                         }
                     }
                 }
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
     }

     @Override
     public int deleteByPrimaryKey(Integer id) {
         return scheduleTriggerMapper.deleteByPrimaryKey(id);
     }

     @Override
     public int insert(ScheduleTrigger record) {
         return scheduleTriggerMapper.insert(record);
     }

     @Override
     public int insertSelective(ScheduleTrigger record) {
         return scheduleTriggerMapper.insertSelective(record);
     }

     @Override
     public ScheduleTrigger selectByPrimaryKey(Integer id) {
         return scheduleTriggerMapper.selectByPrimaryKey(id);
     }

     @Override
     public int updateByPrimaryKeySelective(ScheduleTrigger record) {
         return scheduleTriggerMapper.updateByPrimaryKeySelective(record);
     }

     @Override
     public int updateByPrimaryKey(ScheduleTrigger record) {
         return scheduleTriggerMapper.updateByPrimaryKey(record);
     }

     @Override
     public List<ScheduleTrigger> queryScheduleTriggerLst() {
         return scheduleTriggerMapper.queryScheduleTriggerLst();
     }
 }

ScheduleTriggerParamService

 package com.yuan.quartz02.service;

 import com.yuan.quartz02.model.ScheduleTriggerParam;

 import java.util.List;

 public interface ScheduleTriggerParamService {

     /**
      * 查询出当前任务类对应所需的参数
      * @param triggerId
      * @return
      */
     List<ScheduleTriggerParam> queryScheduleParamLst(Integer triggerId);
 }

ScheduleTriggerParamServiceImpl

 package com.yuan.quartz02.service.impl;

 import com.yuan.quartz02.mapper.ScheduleTriggerParamMapper;
 import com.yuan.quartz02.model.ScheduleTriggerParam;
 import com.yuan.quartz02.service.ScheduleTriggerParamService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;

 import java.util.List;

 @Service
 public class ScheduleTriggerParamServiceImpl implements ScheduleTriggerParamService {

     @Autowired
     private ScheduleTriggerParamMapper scheduleTriggerParamMapper;

     @Override
     public List<ScheduleTriggerParam> queryScheduleParamLst(Integer triggerId) {
         return scheduleTriggerParamMapper.queryScheduleParamLst(triggerId);
     }
 }

读取数据库中表达式启动定时任务

myjob

 package com.yuan.quartz02.quartz;

 import lombok.extern.slf4j.Slf4j;
 import org.quartz.Job;
 import org.quartz.JobExecutionContext;
 import org.quartz.JobExecutionException;
 import org.springframework.stereotype.Component;

 import java.util.Date;

 @Component
 @Slf4j
 public class MyJob implements Job {

     @Override
     public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
         System.out.println("MyJob是一个空的任务计划,时间："+new Date().toLocaleString());
     }
 }

Spring自带定时任务每10s执行一次，查询自定义触发器表，

获取到具体的作业类及任务表达式，quartz的任务为每5s执行一次，所以打印如上

更改定时任务状态

更改数据库调度器表t_schedule_trigger的state状态

读取数据库中表达式启动定时任务

数据库表t_schedule_trigger配置

当禁用该触发器时，那么程序只会执行spring自带的定时任务，每10s执行一次查询，所以打印语句如上。

MyJob1

 package com.yuan.quartz02.quartz;

 import com.yuan.quartz02.service.ScheduleTriggerParamService;
 import lombok.extern.slf4j.Slf4j;
 import org.quartz.*;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;

 import java.util.Date;

 @Component
 @Slf4j
 public class MyJob1 implements Job {

     @Autowired
     private ScheduleTriggerParamService scheduleTriggerParamService;

     @Override
     public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
         JobDetail jobDetail =
                 jobExecutionContext.getJobDetail();
         JobDataMap jobDataMap = jobDetail.getJobDataMap();
         System.err.println(new Date().toLocaleString()+"-->携带参数个数:"+jobDataMap.size());
     }
 }

程序执行spring自带的定时任务，每10s执行一次查询，查询t_schedule_trigger表，

调度器表中有两个调度器，都是每5s执行一次，其中一个调度器是需要携带参数的，

携带的参数在t_schedule_trigger_param表中，所以一开始调度器启动的时候需要查询t_schedule_trigger_param表数据，最终打印语句如上。

更改定时任务规则

t_schedule_trigger

程序执行spring自带的定时任务，每10s执行一次查询，查询t_schedule_trigger表

控制器
QuartzController

 package com.yuan.quartz02.controller;

 import com.yuan.quartz02.model.ScheduleTrigger;
 import com.yuan.quartz02.service.ScheduleTriggerService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.ResponseBody;
 import org.springframework.web.servlet.ModelAndView;

 import java.util.List;

 @Controller
 @RequestMapping("/quartz")
 public class QuartzController {

     @Autowired
     private ScheduleTriggerService scheduleTriggerService;

     @RequestMapping("/list")
     public ModelAndView getAll(){
         ModelAndView modelAndView = new ModelAndView();
         List<ScheduleTrigger> list = scheduleTriggerService.queryScheduleTriggerLst();
         modelAndView.addObject("quartzList",list);
         modelAndView.setViewName("/index");
         return modelAndView;
     }

     @RequestMapping("/edit")
     public String editStatus(ScheduleTrigger scheduleTrigger){
         int n = scheduleTriggerService.updateByPrimaryKeySelective(scheduleTrigger);
         return "redirect:/quartz/list";
     }

     @RequestMapping("/proSave/{id}")
     public ModelAndView proSave(@PathVariable(value = "id") Integer id){
         ModelAndView modelAndView=new ModelAndView();
         ScheduleTrigger scheduleTrigger = scheduleTriggerService.selectByPrimaryKey(id);
         modelAndView.addObject("schedule",scheduleTrigger);
         modelAndView.setViewName("/edit");
         return modelAndView;
     }

 }

页面代码

index.html

 <!DOCTYPE html>
 <html xmlns:th="http://www.thymeleaf.org">
 <head>
     <meta charset="UTF-8">
     <title>quartz定时任务管理</title>
 </head>
 <body>
 <h1 style="text-align: center">定时任务管理</h1>
 <table style="text-align: center" align="center" border="1px" width="80%">
     <tr>
         <td>任务id</td>
         <td>任务表达式</td>
         <td>任务状态</td>
         <td>job工作类</td>
         <td>job分组</td>
         <td>操作</td>
     </tr>
     <tr th:each="q : ${quartzList}">
         <td th:text="${q.id}"></td>
         <td th:text="${q.cron}"></td>
         <td th:text="${q.status}"></td>
         <td th:text="${q.job_name}"></td>
         <td th:text="${q.job_group}"></td>
         <td th:switch ="${q.status} == 0">
             <a th:case="true" th:href="@{/quartz/edit(id=${q.id},status=1)}">启动</a>
             <a th:case="false" th:href="@{/quartz/edit(id=${q.id},status=0)}">停止</a>
             <a th:href="@{'/quartz/proSave/'+${q.id}}">编辑</a>
         </td>
     </tr>
 </table>

 </body>
 </html>

edit.html

 <!DOCTYPE html>
 <html xmlns:th="http://www.thymeleaf.org">
 <head>
     <meta charset="UTF-8">
     <title>编辑定时任务</title>
 </head>
 <body>
 <h1>编辑定时任务</h1>
 <form th:action="@{/quartz/edit}" method="post">
     <input type="hidden" name="id" th:value="${schedule.id}" />
     任务表达式： <input width="300px" type="text" name="cron" th:value="${schedule.cron}" /></br>
     job工作类： <input width="300px" type="text" name="job_name" th:value="${schedule.job_name}" /></br>
     job分组：<input width="300px" type="text" name="job_group" th:value="${schedule.job_group}" /></br>
     <input type="submit" value="提交"/>
 </form>
 </body>
 </html>

页面效果

谢谢观看！！！