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 {@AutowiredMyJobFactory factory;@Overridepublic 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 {@Testvoid 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@SneakyThrowspublic Connection getConnection() {return datasource.getConnection();}@Overridepublic void shutdown() {datasource.close();}@Override@SneakyThrowspublic 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;@Autowiredpublic MyJobFactory(AutowireCapableBeanFactory autowireCapableBeanFactory) {this.autowireCapableBeanFactory = autowireCapableBeanFactory;}/*** 重写创建Job任务的实例方法,解决Job任务无法使用Spring中的Bean问题*/@Override@SneakyThrowsprotected 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;@Autowiredpublic QuartzConfiguration(MyJobFactory myJobFactory) {this.myJobFactory = myJobFactory;}/*** 创建调度器工厂*/@Beanpublic SchedulerFactoryBean schedulerFactoryBean() {//1.创建SchedulerFactoryBeanSchedulerFactoryBean factoryBean = new SchedulerFactoryBean();//2.加载自定义的quartz.properties配置文件factoryBean.setQuartzProperties(quartzProperties());//3.设置MyJobFactoryfactoryBean.setJobFactory(myJobFactory);return factoryBean;}@Bean@SneakyThrowspublic Properties quartzProperties() {PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));propertiesFactoryBean.afterPropertiesSet();return propertiesFactoryBean.getObject();}@Beanpublic 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-8username: rootpassword: 123456driver-class-name: com.mysql.cj.jdbc.Drivertype: com.alibaba.druid.pool.DruidDataSourcedruid: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无法统计   ,wallvalidation-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                                       # 是否开启 StatViewServletallow: 127.0.0.1                                    # 访问监控页面 白名单，默认127.0.0.1deny: 192.168.56.1                                  # 访问监控页面 黑名单login-username: admin                               # 访问监控页面 登陆账号login-password: 123                                 # 访问监控页面 登陆密码filter:stat:enabled: true                                     # 是否开启 FilterStat，默认truelog-slow-sql: true                                # 是否开启 慢SQL 记录，默认falseslow-sql-millis: 5000                             # 慢 SQL 的标准，默认 3000,单位：毫秒merge-sql: false                                  # 合并多个连接池的监控数据，默认falseapplication:name: quartz_02freemarker:#指定HttpServletRequest的属性是否可以覆盖controller的model的同名项allow-request-override: false#req访问requestrequest-context-attribute: req#后缀名freemarker默认后缀为.ftl，当然你也可以改成自己习惯的.htmlsuffix: .ftl#设置响应的内容类型content-type: text/html;charset=utf-8#是否允许mvc使用freemarkerenabled: true#是否开启template cachingcache: 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 {@Autowiredprivate ScheduleTriggerMapper mapper;@Overridepublic List<ScheduleTrigger> find() {return mapper.selectAll();}@Overridepublic 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 {@Autowiredprivate ScheduleTriggerDataMapper mapper;@Overridepublic List<ScheduleTriggerData> find(Long triggerId) {
//      根据外键查询Example example = new Example(ScheduleTriggerData.class);example.createCriteria().andEqualTo("triggerId",triggerId);return mapper.selectByExample(example);}@Overridepublic 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;@Autowiredpublic QuartzTask(ScheduleTriggerDataService dataService, ScheduleTriggerService triggerService ,Scheduler scheduler) {this.dataService = dataService;this.triggerService = triggerService;this.scheduler = scheduler;}@Scheduled(cron = "0/10 * * * * ?")@SneakyThrowspublic 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 和禁用1if("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;@Autowiredpublic 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！到这就结束了，希望能帮到你！！！

Quartz 数据库存储和内存存储相关推荐

如何为数据库服务器配置存储和内存(转载)
随着服务器硬件的功能变得越来越强大,而价格一路急剧下跌,许多公司(尤其是小公司)发现如今购买数据库服务器面临众多选择.这意味着,经验相对欠缺的数据库管理员们也被要求设计功能越来越强大的系统. ...
简单数据库实现——Part3 - 一个内存存储-只可追加-单数据表的数据库
Part3 - 一个内存存储-只可追加-单数据表的数据库我们将先实现一个小规模的数据库.它现在可以做到: 支持两种操作:插入一行和打印所有行仅驻留在内存中(没有磁盘永久性) 支持单个硬编码(har ...
SpringBoot+Quartz+数据库存储（附完整代码和数据库脚本）
目录 1.pom文件依赖 2.Druid连接池的Quartz扩展类 3 .application.yml文件 4 .修改quartz.properties配置 5 . 在数据库中创建quartz相关的 ...
Linux实战教学笔记45：NoSQL数据库之redis持久化存储（一）
第1章 redis存储系统 1.1 redis概述 REmote DIctionary Server(Redis)是一个基于key-value键值对的持久化数据库存储系统.redis和大名鼎鼎的Mem ...
ext store 数据修改_Go 数据存储篇（一）：基于内存存储实现数据增删改查功能...
在 Web 编程中,经常需要处理用户请求数据,而用户请求数据的处理往往又涉及到数据存储与获取,支持存储数据的媒介很多,包括内存.文件系统.数据库等,接下来,学院君将花几个篇幅的教程来系统介绍 Go W ...
怎么用mysql存储系统数据库_mysql数据库之基本操作和存储引擎
一.知识储备数据库服务器:一台计算机(对内存要求比较高) 数据库管理系统:如mysql,是一个软件数据库:oldboy_stu,相当于文件夹表:student,scholl,class_list ...
数据库存储模型-数据存储
按照存储模型来说分为以下4类. 键值存储列式存储文档存储图形存储键值模型键值数据模型的主要思想来自于哈希表:在哈希表中有一个特定的key和一个value指针,指向特定的数据.键值模型对于海量 ...
数据库 - 库表操作 - 存储引擎
一.库操作: mysql> show databases; +--------------------+ | Database | +--------------------+ | inform ...
mysql数据库应用模式与特点_MySQL存储引擎的实际应用以及对MySQL数据库中各主要存储引擎的独特特点的描述...
MySQL存储引擎的实际应用以及对MySQL数据库中各主要存储引擎的独特特点的描述: 1.MySQL有多种存储引擎: MyISAM.InnoDB.MERGE.MEMORY(HEAP).BDB(Berk ...

Quartz 数据库存储和内存存储

Quartz 数据库存储和内存存储相关推荐

最新文章

热门文章

Quartz 数据库存储 和 内存存储

Quartz 数据库存储 和 内存存储相关推荐

最新文章

热门文章

Quartz 数据库存储和内存存储

Quartz 数据库存储和内存存储相关推荐