Quartz 数据库存储和内存存储

内存存储

1，启动类开启定时任务

package com.lgs.code;

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

/**
 * @author lgs
 */
@SpringBootApplication
//EnableScheduling 开启定时任务
@EnableScheduling
public class Quartz02Application {

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

}

2，创建任务类MyJob

package com.lgs.code.job;

import com.lgs.code.util.MyJobFactory;
import org.apache.commons.logging.Log;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.Map;

/**
 * @author lgs
 * 任务类
 */
public class MyJob implements Job {

    @Autowired
    MyJobFactory factory;

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        Map data = context.getJobDetail().getJobDataMap();
        System.out.println(data.get("name")+"在"+data.get("loc")+"搞卫生");
    }
}

3，text

package com.lgs.code;

import com.lgs.code.job.MyJob;
import org.junit.jupiter.api.Test;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.scheduling.annotation.Scheduled;

import java.util.Date;

import static org.quartz.JobBuilder.newJob;

@SpringBootTest
class Quartz02ApplicationTests {

    @Test
    void contextLoads() throws Exception{
//  1,实例化调度器工厂
        SchedulerFactory factory = new StdSchedulerFactory();
//  2,得到调度器
        Scheduler scheduler = factory.getScheduler();
//  3,创建任务
        //  Job（模板） 和 JobDetail（实例）
        JobDetail jobDetail01 = newJob(MyJob.class)
                .withDescription("大扫除任务") //描述
                .withIdentity("a", "b") //任务id => ab
                .usingJobData("name","张三")
                .usingJobData("loc","阁-楼")
                .build(); //构建
        jobDetail01.getJobDataMap().put("name","张三");
        jobDetail01.getJobDataMap().put("loc","阁-楼");
//  4,创建触发器
        Trigger trigger = TriggerBuilder.newTrigger()
                .withDescription("创建触发器")
                .withIdentity("b", "c") // bc
                .withSchedule(CronScheduleBuilder.cronSchedule("* * * * * ?"))
                .build();
//  5,将触发器和任务绑定到调度器
        scheduler.scheduleJob(jobDetail01,trigger);
//  6,启动调度器
        scheduler.start();
        while (true){}
    }

}

数据库存储

1，创建模块：

2，下载 quartz调度框架 Quartz Enterprise Job Scheduler

下载之后运行SQL脚本

quartz-2.2.2-distribution->quartz-2.2.2->docs->dbTables->tables_mysql.sql

表quartz自己管理，不需要我们维护，如下是需要用到的表

qrtz_cron_triggers、qrtz_job_details、qrtz_triggers

我们把需要的定时任务交给quartz，quartz把任务放到对应表中，我们不修改quartz的内置表，新建两张任务表

任务表：

create table t_schedule_trigger
(
    id          bigint primary key auto_increment comment '触发器编号',
    cron        varchar(200) not null comment '触发器表达式',
    status      char(1)          not null comment '触发器状态: 禁用0 启用1',
    job_name    varchar(200) not null comment '任务名称: 存放的任务类的全路径',
    job_group   varchar(200) not null comment '任务所处分组',
    job_description varchar(200) not null comment '任务描述',
    trigger_description varchar(200) not null comment '触发器描述',
    unique index (job_name, job_group) comment '通过jobName和jobGroup来确定trigger的唯一性，所以这两列为联合唯一索引'
);

任务所需数据表：

create table t_schedule_trigger_data
(
    id         bigint primary key auto_increment comment '数据编号',
    name       varchar(200) not null comment '对应的数据名称',
    value      varchar(512) comment '对应的数据值',
    trigger_id bigint       not null comment '外键: 引用t_schedule_trigger(id)',
    foreign key (trigger_id) references t_schedule_trigger (id)
);

在t_schedule_trigger增加一个任务：

在t_schedule_trigger_data中建t_schedule_trigger表中任务数据：

目标：

程序启动后把我们所建表的数据读出来让quartz放到quartz所管理的表中去
任务表中有禁用和启动，当我们禁用时quartz需要把quartz所管理的表中的数据去除

3、准备需要的工具和依赖

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>
    <groupId>com.lgs</groupId>
    <artifactId>code</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>quartz_02</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.4.1</spring-boot.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-freemarker</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.8</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.0.2</version>
        </dependency>
        <dependency>
            <groupId>javax.persistence</groupId>
            <artifactId>persistence-api</artifactId>
            <version>1.0</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.4.1</version>
                <configuration>
                    <mainClass>com.lgs.code.Quartz02Application</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

新建util软件包

包中新建DruidConnectionProvider类

DruidConnectionProvider类的作用：帮助quartz创建连接池，连接数据库

package com.lgs.code.util;

import com.alibaba.druid.pool.DruidDataSource;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.SneakyThrows;
import org.quartz.utils.ConnectionProvider;

import java.sql.Connection;

/*
#============================================================================
# JDBC
#============================================================================
org.quartz.jobqzDS.connectionProvider.class:com.zking.q03.quartz.DruidConnectionProvider
org.quartz.dataSourStore.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.ce.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扩展类  帮助Quartz连接Druid
 *
 * @author hgh
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
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;

    @Override
    @SneakyThrows
    public Connection getConnection() {
        return datasource.getConnection();
    }

    @Override
    public void shutdown() {
        datasource.close();
    }

    @Override
    @SneakyThrows
    public void initialize() {
        assert this.URL != null : "DB URL cannot be null";
        assert this.driver != null : "DB driver class name cannot be null!";
        assert this.maxConnection > 0 : "Max connections must be greater than zero!";

        datasource = new DruidDataSource();
        datasource.setDriverClassName(this.driver);
        datasource.setUrl(this.URL);
        datasource.setUsername(this.user);
        datasource.setPassword(this.password);
        datasource.setMaxActive(this.maxConnection);
        datasource.setMinIdle(1);
        datasource.setMaxWait(0);
        datasource.setMaxPoolPreparedStatementPerConnectionSize(DruidConnectionProvider.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);
        }
    }

}

包中新建MyJobFactory类

Spring 提供了一种机制，能够为第三方框架赋能，让Spring管理的Bean去装配和填充那些不被Spring托管的Bean，这种机制叫AutowireCapableBeanFactory。目前了解到的有两款著名的开源框架Junit与Quartz借用了这种机制为自己赋能，达到更好地与Spring契合协作的目的，也从他们的整合姿势中学习到，当我们需要设计一个框架，而且需要拥抱Spring生态，为框架使用者提供更便利的无缝整合，需以微内核 + 插件机制思想，由内核层想办法拿到AutowireCapableBeanFactory，并在构造插件的时候，借助AutowireCapableBeanFactory去为插件赋能，做到无限扩展的可能性

package com.lgs.code.util;

import lombok.SneakyThrows;
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;

/**
 * 具备操作spring的能力
 * 给第三方框架赋能
 *
 * @author hgh
 */
@Component
@Slf4j
public class MyJobFactory extends AdaptableJobFactory {

    private final AutowireCapableBeanFactory autowireCapableBeanFactory;

    @Autowired
    public MyJobFactory(AutowireCapableBeanFactory autowireCapableBeanFactory) {
        this.autowireCapableBeanFactory = autowireCapableBeanFactory;
    }

    /**
     * 重写创建Job任务的实例方法,解决Job任务无法使用Spring中的Bean问题
     */
    @Override
    @SneakyThrows
    protected Object createJobInstance(TriggerFiredBundle bundle) {
        Object jobInstance = super.createJobInstance(bundle);
        autowireCapableBeanFactory.autowireBean(jobInstance);
        return super.createJobInstance(bundle);
    }

}

新建conf软件包

包中新建QuartzConfiguration类

QuartzConfiguration是配置类，是为了让quartz和spring和数据库互通

package com.lgs.code.conf;

import com.lgs.code.util.MyJobFactory;
import lombok.SneakyThrows;
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.util.Properties;

/**
 * 配置类  具备和spring交互的功能
 *
 * @author hgh
 */
@Configuration
public class QuartzConfiguration {

    private final MyJobFactory myJobFactory;

    @Autowired
    public QuartzConfiguration(MyJobFactory myJobFactory) {
        this.myJobFactory = myJobFactory;
    }

    /**
     * 创建调度器工厂
     */
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() {
        //1.创建SchedulerFactoryBean
        SchedulerFactoryBean factoryBean = new SchedulerFactoryBean();
        //2.加载自定义的quartz.properties配置文件
        factoryBean.setQuartzProperties(quartzProperties());
        //3.设置MyJobFactory
        factoryBean.setJobFactory(myJobFactory);
        return factoryBean;
    }

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

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

}

resources中新建quartz.properties 数据库存储

#
#============================================================================
# Configure Main Scheduler Properties \u8C03\u5EA6\u5668\u5C5E\u6027
#============================================================================
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
#============================================================================
#\u5B58\u50A8\u65B9\u5F0F\u4F7F\u7528JobStoreTX,\u4E5F\u5C31\u662F\u6570\u636E\u5E93
org.quartz.jobStore.class:org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass:org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#\u4F7F\u7528\u81EA\u5DF1,\u7684\u914D\u7F6E\u6587\u4EF6
org.quartz.jobStore.useProperties:true
#\u6570\u636E\u5E93\u4E2Dquartz\u8868\u7684\u8868\u540D\u524D\u7F00
org.quartz.jobStore.tablePrefix:qrtz_
org.quartz.jobStore.dataSource:qzDS
#\u662F\u5426\u4F7F\u7528\u96C6\u7FA4(\u5982\u679C\u9879\u76EE\u53EA\u90E8\u7F72\u5230 \u4E00\u53F0\u670D\u52A1\u5668,\u5C31\u4E0D\u7528\u4E86)
org.quartz.jobStore.isClustered=true
#============================================================================
# Configure Datasources
#============================================================================
#\u914D\u7F6E\u6570\u636E\u5E93\u6E90\uFF08org.quartz.dataSource.qzDS.maxConnections: c3p0\u914D\u7F6E\u7684\u662F\u6709s\u7684,druid\u6570\u636E\u6E90\u6CA1\u6709s\uFF09
org.quartz.dataSource.qzDS.connectionProvider.class:com.lgs.code.util.DruidConnectionProvider
org.quartz.dataSource.qzDS.driver:com.mysql.cj.jdbc.Driver
org.quartz.dataSource.qzDS.URL:jdbc:mysql://127.0.0.1:3306/boot?useUnicode=true&serverTimezone=Asia/Shanghai&useSSL=false&characterEncoding=utf-8
org.quartz.dataSource.qzDS.user:root
org.quartz.dataSource.qzDS.password:123456
org.quartz.dataSource.qzDS.maxConnection:10

application.yml

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/boot?useUnicode=true&serverTimezone=Asia/Shanghai&useSSL=false&characterEncoding=utf-8
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      initial-size: 5                                       # 初始化大小
      min-idle: 10                                          # 最小连接数
      max-active: 20                                        # 最大连接数
      max-wait: 60000                                       # 获取连接时的最大等待时间
      min-evictable-idle-time-millis: 300000                # 一个连接在池中最小生存的时间，单位是毫秒
      time-between-eviction-runs-millis: 60000              # 多久才进行一次检测需要关闭的空闲连接，单位是毫秒
      filters: stat                                         # 配置扩展插件：stat-监控统计，log4j-日志，wall-防火墙（防止SQL注入），去掉后，监控界面的sql无法统计   ,wall
      validation-query: SELECT 1                            # 检测连接是否有效的 SQL语句，为空时以下三个配置均无效
      test-on-borrow: true                                  # 申请连接时执行validationQuery检测连接是否有效，默认true，开启后会降低性能
      test-on-return: true                                  # 归还连接时执行validationQuery检测连接是否有效，默认false，开启后会降低性能
      test-while-idle: true                                 # 申请连接时如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效，默认false，建议开启，不影响性能
      stat-view-servlet:
        enabled: true                                       # 是否开启 StatViewServlet
        allow: 127.0.0.1                                    # 访问监控页面 白名单，默认127.0.0.1
        deny: 192.168.56.1                                  # 访问监控页面 黑名单
        login-username: admin                               # 访问监控页面 登陆账号
        login-password: 123                                 # 访问监控页面 登陆密码
      filter:
        stat:
          enabled: true                                     # 是否开启 FilterStat，默认true
          log-slow-sql: true                                # 是否开启 慢SQL 记录，默认false
          slow-sql-millis: 5000                             # 慢 SQL 的标准，默认 3000,单位：毫秒
          merge-sql: false                                  # 合并多个连接池的监控数据，默认false
  application:
    name: quartz_02
  freemarker:
    #指定HttpServletRequest的属性是否可以覆盖controller的model的同名项
    allow-request-override: false
    #req访问request
    request-context-attribute: req
    #后缀名freemarker默认后缀为.ftl，当然你也可以改成自己习惯的.html
    suffix: .ftl
    #设置响应的内容类型
    content-type: text/html;charset=utf-8
    #是否允许mvc使用freemarker
    enabled: true
    #是否开启template caching
    cache: false
    #设定模板的加载路径，多个以逗号分隔，默认: [“classpath:/templates/”]
    template-loader-path: classpath:/templates/
    #设定Template的编码
    charset: UTF-8
logging:
  level:
    com.yk.code.mapper: debug

二，实现数据库储存开发

读取t_schedule_trigger表和t_schedule_trigger_data表的数据

新建pojo软件包，包下新建ScheduleTrigger 包下新建ScheduleTriggerData

package com.lgs.code.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import tk.mybatis.mapper.annotation.KeySql;

import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.Table;

/**
 * @author hgh
 */
@AllArgsConstructor
@NoArgsConstructor
@Data
@Accessors(chain = true)
@Table(name = "t_schedule_trigger")
public class ScheduleTrigger {

    @Id
    @KeySql(useGeneratedKeys = true)
    @Column(name = "id")
    private Long id;

    @Column(name = "cron")
    private String cron;

    @Column(name = "status")
    private String status;

    @Column(name = "job_name")
    private String jobName;

    @Column(name = "job_group")
    private String jobGroup;

    @Column(name = "job_description")
    private String JobDescription;

    @Column(name = "trigger_description")
    private String triggerDescription;

}

package com.lgs.code.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import tk.mybatis.mapper.annotation.KeySql;

import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.Table;

/**
 * @author hgh
 */
@AllArgsConstructor
@NoArgsConstructor
@Data
@Accessors(chain = true)
@Table(name = "t_schedule_trigger_data")
public class ScheduleTriggerData {

    @Id
    @KeySql(useGeneratedKeys = true)
    @Column(name = "id", nullable = false)
    private Long id;

    @Column(name = "name")
    private String name;

    @Column(name = "value")
    private String value;

    @Column(name = "trigger_id")
    private Long triggerId;

}

新建mapper包都继承通用mapper

新建ScheduleTriggerMapper接口继承mapper<ScheduleTrigger> 查询所有

package com.lgs.code.mapper;

import com.lgs.code.pojo.ScheduleTrigger;
import org.springframework.stereotype.Repository;
import org.springframework.web.bind.annotation.RequestMapping;
import tk.mybatis.mapper.common.Mapper;

@Repository
public interface ScheduleTriggerMapper extends Mapper<ScheduleTrigger> {

//查询全部的方法

}

新建ScheduleTriggerDataMapper接口继承mapper<ScheduleTriggerData>根据触发器id查询

package com.lgs.code.mapper;

import com.lgs.code.pojo.ScheduleTriggerData;
import tk.mybatis.mapper.common.Mapper;

public interface ScheduleTriggerDataMapper extends Mapper<ScheduleTriggerData> {

//根据触发器id查询的方法

}

新建service包新建ScheduleTriggerService接口

package com.lgs.code.service;

import com.lgs.code.pojo.ScheduleTrigger;

import java.util.List;

public interface ScheduleTriggerService {

    List<ScheduleTrigger> find();

    //    增加的方法
    int insert(ScheduleTrigger trigger);

}

ScheduleTriggerServiceImpl实现ScheduleTriggerService接口

package com.lgs.code.service;

import com.lgs.code.mapper.ScheduleTriggerDataMapper;
import com.lgs.code.mapper.ScheduleTriggerMapper;
import com.lgs.code.pojo.ScheduleTrigger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class ScheduleTriggerServiceImpl implements ScheduleTriggerService {

    @Autowired
    private ScheduleTriggerMapper mapper;

    @Override
    public List<ScheduleTrigger> find() {
        return mapper.selectAll();
    }

    @Override
    public int insert(ScheduleTrigger trigger) {
        return mapper.insert(trigger);
    }

}

新建ScheduleTriggerDataService接口

package com.lgs.code.service;

import com.lgs.code.pojo.ScheduleTrigger;
import com.lgs.code.pojo.ScheduleTriggerData;

import java.util.List;

public interface ScheduleTriggerDataService {

    List<ScheduleTriggerData> find(Long triggerId);

    //    增加
    int insert(ScheduleTriggerData data);

}

ScheduleTriggerDataServiceImpl实现ScheduleTriggerDataService接口

package com.lgs.code.service;

import com.lgs.code.mapper.ScheduleTriggerDataMapper;
import com.lgs.code.pojo.ScheduleTriggerData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import tk.mybatis.mapper.entity.Example;

import java.util.List;

@Service
public class ScheduleTriggerDataServiceImpl implements ScheduleTriggerDataService {

    @Autowired
    private ScheduleTriggerDataMapper mapper;

    @Override
    public List<ScheduleTriggerData> find(Long triggerId) {
//      根据外键查询
        Example example = new Example(ScheduleTriggerData.class);
        example.createCriteria().andEqualTo("triggerId",triggerId);
        return mapper.selectByExample(example);
    }

    @Override
    public int insert(ScheduleTriggerData data) {
        return mapper.insert(data);
    }

}

启动类加载mapper包下的类

package com.lgs.code;

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

/**
 * @author lgs
 */
@SpringBootApplication
//EnableScheduling 开启定时任务
@EnableScheduling
@MapperScan("com.lgs.code.mapper")
public class Quartz02Application {

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

}

util中新建QuartzTask任务类

package com.lgs.code.util;

import com.lgs.code.job.MyJob;
import com.lgs.code.pojo.ScheduleTrigger;
import com.lgs.code.pojo.ScheduleTriggerData;
import com.lgs.code.service.ScheduleTriggerDataService;
import com.lgs.code.service.ScheduleTriggerService;
import lombok.SneakyThrows;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import static org.quartz.JobBuilder.newJob;

/**
 * 任务类
 *
 * @author lgs
 */
@Component
public class QuartzTask {

    private ScheduleTriggerDataService dataService;
    private ScheduleTriggerService triggerService;
    private Scheduler scheduler;

    @Autowired
    public QuartzTask(ScheduleTriggerDataService dataService, ScheduleTriggerService triggerService ,Scheduler scheduler) {
        this.dataService = dataService;
        this.triggerService = triggerService;
        this.scheduler = scheduler;
    }

    @Scheduled(cron = "0/10 * * * * ?")
    @SneakyThrows
    public void register(){
//      去数据库查看两张表有没有变化
//      查询数据库中所有任务
        for (ScheduleTrigger t : triggerService.find()) {
//          判断这个任务是否已经被quartz管理
//          拿到这个任务的名字和分组
            String jobName = t.getJobName();
            String jobGroup = t.getJobGroup();
            String jobDescription = t.getJobDescription();
            String triggerDescription = t.getTriggerDescription();
            String cron = t.getCron();
//          生成一个key 去调度器中拿对应的元素
            CronTrigger trigger = (CronTrigger)scheduler.getTrigger(TriggerKey.triggerKey(jobName, jobGroup));
            if(trigger==null){ //在我的表里有，但是quartz没有管理它
//          没有则加到quartz里面去，其中还要考虑两种可能，新建0 和禁用1
                if("0".equals(t.getStatus())){
                    continue;
                }
//          新建，将任务放到quartz里面  创建任务
                JobDetail jobDetail = newJob((Class<? extends Job>) Class.forName(jobName))
                        //描述
                        .withDescription(jobDescription)
                        .withIdentity(jobName, jobGroup)
                        //构建
                        .build();
//              读取任务所需要的数据
                for (ScheduleTriggerData data : dataService.find(t.getId())) {
//                  将所需要的任务数据放到任务中
                    jobDetail.getJobDataMap().put(data.getName(),data.getValue());
                }
//          创建触发器
                trigger = TriggerBuilder.newTrigger()
                        .withDescription(triggerDescription)
                        .withIdentity(jobName, jobGroup)
                        .withSchedule(CronScheduleBuilder.cronSchedule(cron))
                        .build();
//          分配调度器
                scheduler.scheduleJob(jobDetail,trigger);
                continue;
            }
//          任务已经在quartz已经有了
            if("0".equals(t.getStatus())){
//             在quartz中删除任务
                scheduler.deleteJob(JobKey.jobKey(jobName,jobGroup));
                continue;
            }
//          任务存在 而且不是禁用状态
//          判断表达式是否修改了
            if(!trigger.getCronExpression().equals(cron)){
//          新建，将任务放到quartz里面  创建任务
                JobDetail jobDetail = newJob((Class<? extends Job>) Class.forName(jobName))
                        //描述
                        .withDescription(jobDescription)
                        .withIdentity(jobName, jobGroup)
                        //构建
                        .build();
//              读取任务所需要的数据
                for (ScheduleTriggerData data : dataService.find(t.getId())) {
//                  将所需要的任务数据放到任务中
                    jobDetail.getJobDataMap().put(data.getName(),data.getValue());
                }
//          创建触发器
                trigger = TriggerBuilder.newTrigger()
                        .withDescription(triggerDescription)
                        .withIdentity(jobName, jobGroup)
                        .withSchedule(CronScheduleBuilder.cronSchedule(cron))
                        .build();
//          让调度器更换触发器
                scheduler.rescheduleJob(TriggerKey.triggerKey(jobName, jobGroup),trigger);
            }

        }
    }

}

运行测试：

其中如上代码中还存在一些bag，问题如下

但我们删除了自己建的表 t_schedule_trigger 中的数据，同时程序依旧在运行，只有删除 quartz 中qrtz_cron_triggers 中表的数据才会停止。

解决：不可能什么都在数据库中操作，因此写一个界面（index.ftl）

解决方法：

1，新建controller软件包

controller包下新建QuartzController

package com.lgs.code.controller;
 
import com.lgs.code.pojo.ScheduleTrigger;
import com.lgs.code.pojo.ScheduleTriggerData;
import com.lgs.code.service.ScheduleTriggerDataService;
import com.lgs.code.service.ScheduleTriggerService;
import lombok.SneakyThrows;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import javax.servlet.http.HttpServletRequest;
 
@Controller
public class QuartzController {
    private ScheduleTriggerService triggerService;
    private ScheduleTriggerDataService dataService;
    private Scheduler scheduler;
 
    @Autowired
    public QuartzController(ScheduleTriggerService triggerService, ScheduleTriggerDataService dataService, Scheduler scheduler) {
        this.triggerService = triggerService;
        this.dataService = dataService;
        this.scheduler = scheduler;
    }
 
    @GetMapping("/")
    public String index(Model model){
        model.addAttribute("triggers",triggerService.find());
        return "index";
    }
 
    @PostMapping("/insert")
    public String insert(ScheduleTrigger trigger, HttpServletRequest request){
        int i=triggerService.insert(trigger);
        if(i>0){
            request.getParameterMap().forEach((a,b)->{
                try {
//                    判断是否是类的属性
                    ScheduleTrigger.class.getDeclaredField(a);
                }catch (NoSuchFieldException e){
                    ScheduleTriggerData data=
                            new ScheduleTriggerData()
                            .setName(a)
                            .setValue(b[0])
                            .setTriggerId(trigger.getId());
                    dataService.insert(data);
                }
            });
        }
        return "redirect:/";
    }
    
}

2，在service中写方法，如上代码中有

3、resources下新建，目录 templates index.ftl 文件放在 templates 目录下

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title></title>
    <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/3.4.1/css/bootstrap.min.css">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/3.4.1/css/bootstrap-theme.min.css">
    <script src="https://stackpath.bootstrapcdn.com/bootstrap/3.4.1/js/bootstrap.min.js"></script>
</head>
<body class="container">
<h1>定时任务情况</h1>
<table class="table table-condensed">
    <tr>
        <td>表达式</td>
        <td>名字(执行类名)</td>
        <td>分组</td>
        <td>任务描述</td>
        <td>触发器描述</td>
        <td>状态</td>
        <td>操作</td>
    </tr>
    <#list triggers as trigger>
        <tr>
            <td>${trigger.cron!""}</td>
            <td>${trigger.jobName!""}</td>
            <td>${trigger.jobGroup!""}</td>
            <td>${trigger.jobDescription!""}</td>
            <td>${trigger.triggerDescription!""}</td>
            <td>${(trigger.status=='0')?string("已禁用","启用中")}</td>
            <td>
                <a href="/delete?triggerId=${trigger.id}" class="btn btn-danger">关闭</a>
                <a class="btn btn-warning">修改</a>
            </td>
        </tr>
    </#list>
</table>
<div class="jumbotron">
    <h2>新增定时任务</h2>
    <form method="post" action="insert">
        <div class="form-group">
            <label for="jobName">任务名称(执行类名)</label>
            <input class="form-control" id="jobName" name="jobName" value="com.mwy.code.job.Job01">
        </div>
        <div class="form-group">
            <label for="jobGroup">任务分组</label>
            <input class="form-control" id="jobGroup" name="jobGroup">
        </div>
        <div class="form-group">
            <label for="cron">任务表达式</label>
            <input class="form-control" id="cron" name="cron" value="* * * * * ?">
        </div>
        <div class="form-group">
            <label for="jobDescription">任务描述</label>
            <input class="form-control" id="jobDescription" name="jobDescription">
        </div>
        <div class="form-group">
            <label for="triggerDescription">触发器描述</label>
            <input class="form-control" id="triggerDescription" name="triggerDescription">
        </div>
        <div style="border: 1px solid black;border-radius: 10px;padding: 20px;margin-bottom: 10px;">
            <h3>任务参数</h3>
            <div id="ps"></div>
            <br>
            <button type="button" onclick="insert_attr()" class="btn btn-primary">增加</button>
        </div>
        <div class="form-group">
            <label class="radio-inline">
                <input type="radio" name="status" value="0" checked> 禁用
            </label>
            <label class="radio-inline">
                <input type="radio" name="status" value="1"> 启用
            </label>
        </div>
        <button type="submit" class="btn btn-default">确定</button>
    </form>
    <script>
 
        let node_text =
            `<div class="form-inline" style="margin: 3px 0px;">
                <div class="form-group">
                    <input class="form-control" onchange="setAttrName(this)" placeholder="attribute">
                </div>
                <div class="form-group">
                    <input class="form-control" placeholder="value">
                </div>
            </div>`;
 
        function insert_attr() {
            $("#ps").append(node_text);
        }
 
        function setAttrName(obj) {
            $(obj).parents(".form-inline").find("input").eq(1).attr("name", obj.value)
        }
 
    </script>
</div>
</body>
</html>

测试结果：

OK！到这就结束了，希望能帮到你！！！

原文链接：https://blog.csdn.net/m0_58525944/article/details/122900620