Quartz.数据库存储

最新推荐文章于 2024-02-19 15:38:12 发布
最新推荐文章于 2024-02-19 15:38:12 发布
阅读量1.3k 收藏
点赞数 1
文章标签： 数据库 database
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59025975/article/details/122884152
版权

建新模块：

一、回顾

1、启动类开启定时任务

2、创建任务类MyJob

package com.mwy.code;
import lombok.extern.slf4j.Slf4j;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import java.util.Map;
@Slf4j
public class MyJob implements Job {

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

 3、任务储存内存方式

package com.mwy.code;
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
//    @Scheduled(fixedRate = 5000)
//    @Scheduled(cron = "0/5 * * * * ?")
    void contextLoads() throws Exception{
//        调度器
        SchedulerFactory factory=new StdSchedulerFactory();
        Scheduler scheduler = factory.getScheduler();
//        任务
        JobDetail jobDetail=newJob(MyJob.class)
                .withIdentity("a", "b")
                .withDescription("搞卫生")
                .usingJobData("name", "张三")
                .usingJobData("loc", "走廊")
                .build();
        jobDetail.getJobDataMap().put("name","张三");
        jobDetail.getJobDataMap().put("loc","走廊");

//        触发器
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("a", "b")
                .withDescription("每节课搞一次卫生")
                .startAt(new Date())
                .withSchedule(
                        CronScheduleBuilder.cronSchedule("* * * * * ?")
                )
                .build();
//        将触发器和任务绑定到调度器
        scheduler.scheduleJob(jobDetail,trigger);
//        启动调度器
        scheduler.start();

    }
}

测试结果：

 二、数据库解析

Quartz官网：Quartz Enterprise Job Scheduler

我下载的是：quartz-2.2.2-distribution

1、操作：

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

②、运行①中的sql脚本

 运行后：

 ③、会用到的表

这几个表让quartz自己管理，不需要我们维护

qrtz_cron_triggers、qrtz_job_details、qrtz_triggers

我们只需要把定时任务交给quartz，quartz把任务放到对应表中

所以说这几张表我们不修改，但是我们需要知道有什么定时任务，因此，自己建两张表：

④、自己建两张表：

（1）、打开数据库控制台

 （2）运行sql语句

任务表：

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的唯一性，所以这两列为联合唯一索引'
);

t_schedule_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_data中建t_schedule_trigger表中任务数据：

主要目的：程序启动后把我们所建表的数据读出来让quartz放到quartz所管理的表中去

    任务 表中有禁用和启动，当我们禁用时quartz需要把quartz所管理的表中的数据去除  

 三、工具类解析

pom中所有依赖：

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

1、新建util软件包

①、包中新建DruidConnectionProvider类

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

package com.mwy.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扩展类
 *
 */
@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去为插件赋能，做到无限扩展的可能性

【https://www.jianshu.com/p/f9718de489f0】

package com.mwy.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;

@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);
    }

}

2、新建conf软件包

①、包中新建QuartzConfiguration类

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

package com.mwy.code.conf;

import com.mwy.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;

@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();
    }

}

3、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.mwy.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/quartz?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

4、application.yml

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/quartz?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: quartz02
  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

四、开始操作

主要目的：程序启动后把我们所建表的数据读出来让quartz放到quartz所管理的表中去

    任务 表中有禁用和启动，当我们禁用时quartz需要把quartz所管理的表中的数据去除  

1、读取t_schedule_trigger表和t_schedule_trigger_data表的数据

①、新建实体类

新建pojo软件包，

（1）包下新建ScheduleTrigger

package com.mwy.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;

@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;

}

（2）包下新建ScheduleTriggerData

package com.mwy.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;

@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包

（1）新建ScheduleTriggerMapper接口继承mapper<ScheduleTrigger>

提供查询所有的方法

package com.mwy.code.mapper;
import com.mwy.code.pojo.ScheduleTrigger;
import org.springframework.stereotype.Repository;
import tk.mybatis.mapper.common.Mapper;
@Repository
public interface ScheduleTriggerMapper extends Mapper<ScheduleTrigger> {
}

（2）新建ScheduleTriggerDataMapper接口继承mapper<ScheduleTriggerData>

提供根据触发器id查询的方法

package com.mwy.code.mapper;
import com.mwy.code.pojo.ScheduleTrigger;
import com.mwy.code.pojo.ScheduleTriggerData;
import org.springframework.stereotype.Repository;
import tk.mybatis.mapper.common.Mapper;
@Repository
public interface ScheduleTriggerDataMapper extends Mapper<ScheduleTriggerData> {
}

③、新建service包

（1）新建ScheduleTriggerService接口

package com.mwy.code.service;
import com.mwy.code.pojo.ScheduleTrigger;
import java.util.List;
public interface ScheduleTriggerService {

//    查询所有的方法
    List<ScheduleTrigger> find();

}

（1.2）ScheduleTriggerServiceImpl实现ScheduleTriggerService接口

package com.mwy.code.service;
import com.mwy.code.mapper.ScheduleTriggerMapper;
import com.mwy.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();
    }
}

（2）新建ScheduleTriggerDataService接口

package com.mwy.code.service;
import com.mwy.code.pojo.ScheduleTriggerData;
import java.util.List;
public interface ScheduleTriggerDataService {

//    根据触发器id查询的方法
    List<ScheduleTriggerData> find(Long triggerId);

}

（2.2）ScheduleTriggerDataServiceImpl实现ScheduleTriggerDataService接口

package com.mwy.code.service;
import com.mwy.code.mapper.ScheduleTriggerDataMapper;
import com.mwy.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);
    }
}

2、启动类加载mapper包下的类

@MapperScan("com.mwy.code.mapper")

 现在已经能查到所有的数据了，

五、数据库储存开发

现在想怎么把数据quartz中去

1、新建quartz任务类

util中新建QuartzTask

package com.mwy.code.util;
import com.mwy.code.pojo.ScheduleTrigger;
import com.mwy.code.pojo.ScheduleTriggerData;
import com.mwy.code.service.ScheduleTriggerDataService;
import com.mwy.code.service.ScheduleTriggerService;
import lombok.SneakyThrows;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.util.Date;
import static org.quartz.JobBuilder.newJob;

@Component
public class QuartzTask {

//    触发任务数据的service
    private ScheduleTriggerService triggerService;
    private ScheduleTriggerDataService dataService;
//    调度器
    private Scheduler scheduler;


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

//    每隔10秒看看去数据库的我的那两张表有没有什么变化
    @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，去调度器中那对应的元素(强转为Cron触发器)
            CronTrigger trigger = (CronTrigger)scheduler.getTrigger(TriggerKey.triggerKey(jobName, jobGroup));
//           在我的表中有但是quartz没有管理
            if(trigger==null){
//                禁用
                if("0".equals(t.getStatus())){
                    continue;   //跳过
                }
//                新建（将任务放到Quartz里面）
                JobDetail jobDetail=newJob((Class<? extends Job>) Class.forName(jobName))
                        .withIdentity(jobName,jobGroup)
                        .withDescription(jobDescription)
                        .build();
//                读取任务所需要的数据
                for (ScheduleTriggerData data : dataService.find(t.getId())) {
//                    将所需要的任务数据放到任务中
                    jobDetail.getJobDataMap().put(data.getName(),data.getValue());
                }
//        触发器
                trigger = TriggerBuilder.newTrigger()
                        .withIdentity(jobName,jobGroup)
                        .withDescription(triggerDescription)
                        .startAt(new Date())
                        .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)) {
//                不等于就进到表达式里面来
//              触发器
                trigger = TriggerBuilder.newTrigger()
                        .withIdentity(jobName,jobGroup)
                        .withDescription(triggerDescription)
                        .startAt(new Date())
                        .withSchedule(
                                CronScheduleBuilder.cronSchedule(cron)
                        )
                        .build();
//                让调度器更换触发器
                scheduler.rescheduleJob(TriggerKey.triggerKey(jobName, jobGroup),trigger);
            }

        }
    }
}

2、测试查看结果

①、首先查看qrtz_cron_triggers、qrtz_job_details、qrtz_triggers并没有数据

②、运行启动器类

这时qrtz_cron_triggers的数据同步了

 六、Bug

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

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

1、新建controller软件包

①、controller包下新建QuartzController 

package com.mwy.code.controller;

import com.mwy.code.pojo.ScheduleTrigger;
import com.mwy.code.pojo.ScheduleTriggerData;
import com.mwy.code.service.ScheduleTriggerDataService;
import com.mwy.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:/";
    }


}

 ②、新增增加的方法

ScheduleTriggerService
//    增加的方法
    int insert(ScheduleTrigger trigger);
ScheduleTriggerServiceImpl
@Override
public int insert(ScheduleTrigger trigger) {
    return mapper.insert(trigger);
}
ScheduleTriggerDataService
//    增加
    int insert(ScheduleTriggerData data);
ScheduleTriggerDataServiceImpl
@Override
public int insert(ScheduleTriggerData data) {
    return mapper.insert(data);
}

2、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>

3、测试结果

查看结果 

  增加结果

 

 

 

还没写完！！修改和删除

@十九.
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
quartZ定时任务.zip
09-23
数据库存储定时任务，springboot启动后主动加载 创建定时任务及停止、删除定时任务，可根据业务需求创建cron表达式设置执行周期
Quartz学习
IT Lover
12-15 204
Quartz学习 介绍Quartz  Quartz是一个开源的任务调度系统，它能用来调度很多任务的执行。 运行环境Quartz 能嵌入在其他应用程序里运行。 Quartz 能在一个应用服务器里被实例化(或servlet容器), 并且参与XA事务 Quartz能独立运行（通过JVM）,或者通过RMI Quartz能被集群实例化 任务调度当一个指定给任务的触发器发生时,任务就被调度执行. 触发器...
Quartz数据库表分析
庖丁解牛
04-23 5062
前言 上一篇文章Spring整合Quartz分布式调度介绍了Quartz通过数据库的方式来实现分布式调度，通过使用数据库来存储trigger，job等信息，可以在停服重启的时候重新加载上次trigger的状态，保证了完整性；另一方面通过数据库来实现锁机制来实现分布式调度；Quartz默认提供了11张表，本文将对这几张表做简要的分析。 表信息 1.qrtz_b...
Quartz---Springboot项目整合Quartz---实现内存、数据库持久化
最新发布
weixin_53333436的博客
02-19 1423
Quartz的内存持久化是指Quartz框架在默认情况下将任务调度的运行信息保存在内存中。这种方式的优点是可以提供最佳的性能，因为内存中数据访问最快。然而，内存持久化的缺点是缺乏数据的持久性。当程序停止或系统崩溃时，所有运行的信息都会丢失。
Quartz定时任务数据库表字段说明
Edwardliuy的博客
10-11 6962
Quartz配置定时任务持久化，11张自带数据库表的说明。
Quartz手动修改数据库cron表达式（无须重启服务器即可更改定时时间）
qq_39788123的博客
11-08 1983
Quartz手动修改数据库cron表达式，无需重启服务
Quartz所使用的表的说明
anyuta5577的博客
02-03 360
Quartz将Job保存在数据库中所需表的说明 QRTZ_CALENDARS 以 Blob 类型存储 Quartz 的 Calendar 信息 QRTZ_CRON_TRIGGERS 存储 Cron Trigger，包括 Cron表达式和时区信息 QRTZ_FIRED_TRIGGERS 存储与已触发的 Trigger 相关的状态信息，以及相联 Job的执行信息 QRTZ...
quartz集群模式下qrtz_triggers表trigger_state变ERROR分析
Marshall_Ma的博客
07-30 7876
quartz集群模式下qrtz_triggers表trigger_state变ERROR分析
Quartz调度框架预研.docx
05-14
Quartz是一个开源的任务调度框架。...它支持将数据存储到数据库中以实现持久化，并支持绝大多数的数据库。它将任务与触发设计为松耦合，即一个任务可以对应多个触发器，这样能够轻松构造出极为复杂的触发策略。
quartz2.0 数据库持久化 图形化管理界面代码示例
08-26
使用quartz2.0，开发了一套管理界面，采用数据库存储任务信息. 动态修改触发器.
Quartz开源作业调度库-其他
06-12
2、通过使用随附的JDBCJobStore，所有配置为“非易失性”的作业和触发器都将通过JDBC存储在关系数据库中。 3、通过使用随附的RAMJobStore，所有作业和触发器都存储在RAM中，因此不会在程序执行之间持久存在-但这具有...
spring-boot-quartz-demo：Spring Boot + Quartz + Angular2演示应用程序。 它说明了如何安排cron作业，如何暂停作业，恢复作业，编辑石英作业等。它使用PostgreSQL作为存储石英作业和触发器的数据库
01-30
弹簧启动石英演示 ...它使用PostgreSQL作为存储石英作业和触发器的数据库。 详细说明： : 它包含基于Angular2构建的用于计划作业的UI应用程序。 它还有助于编辑作业，您也可以暂停作业，恢复作业，删除作业等。
Quartz的持久化数据库(九)
两个蝴蝶飞
04-30 3012
> 勿以恶小而为之，勿以善小而不为--------------------------刘备 > 劝诸君，多行善事积福报，莫作恶 主要内容: Quartz的持久化和动态添加任务
SpringBoot整合Quartz 实现分布式定时任务调度
askuld的博客
04-07 2572
在上篇文章中，我们详细的介绍了 Quartz 的单体应用实践，如果只在单体环境中应用，Quartz 未必是最好的选择，例如Spring Scheduled一样也可以实现任务调度，并且与SpringBoot无缝集成，支持注解配置，非常简单，但是它有个缺点就是在集群环境下，会导致任务被重复调度！我选择的是quartz-2.3.0-distribution.tar.gz，下载完成之后将其解压，在文件中搜索sql，在里面选择适合当前环境的数据库脚本文件，然后将其初始化到数据库中即可！一、Quartz 集群架构。
【开发经验】quartz表结构说明(字段说明)
热门推荐
叁滴水 的博客
01-06 1万+
quartz表结构说明,包含大部分字段说明，请大家参考。
【SpringBoot】quartz简单定时任务(内存持久化)
Robin的博客
02-16 421
在 springboot2.0 后官方添加了 Quartz 框架的依赖，所以只需要在 pom 文件当中引入
quartz各表作用讲解
小坏蛋的博客
08-22 5743
一、表信息解析： 1.1.qrtz_blob_triggers : 以Blob 类型存储的触发器。  1.2.qrtz_calendars：存放日历信息， quartz可配置一个日历来指定一个时间范围。  1.3.qrtz_cron_triggers：存放cron类型的触发器。  1.4.qrtz_fired_triggers：存放已触发的触发器。  1.5.qrtz_job_deta
Quartz：老而弥坚的开源任务调度框架，用起来够丝滑
沉默王二
06-08 4643
SpringBoot官方支持任务调度框架，轻量级用起来也挺香！
【Quartz】(一)定时框架Quartz的持久化配置
JeffHan^_^的博客
06-16 3382
1. 使用背景 当前，越来越多的场景下面需要使用到定时任务，比如报表的生成，每月或者每年进行一次某些数据的统计等等，使用Springboot中的@Scheduled注解固然也可以实现，只不过，如果要改定时的时间，控制定时的开关，都需要直接操作项目的代码，如果是线上环境的，还得需要把项目 停下来，代价太大，那到底有没有一种框架可以实现我们对于定时任务的增删查改，可以修改定时的时间，启动以及暂定定时任务呢，答案是有的，目前定时任务的框架有很多，比如我们今天要说的Quartz，分布式定时任务xxl-job等等。
org.quartz.jobStore.driverDelegateClass:org.quartz.impl.jdbcjobstore.StdJDBCDelegate
07-13
StdJDBCDelegate是Quartz提供的标准JDBC驱动程序委托实现之一，它与大多数常见的数据库兼容，并提供了必要的方法来执行与作业存储相关的操作，如存储和检索作业信息、触发器信息等。该属性的设置将确保Quartz使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值