建新模块：
一、回顾 1、启动类开启定时任务 2、创建任务类MyJobpackage 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中所有依赖：1、新建util软件包
org.springframework.boot
spring-boot-starter-quartz
org.springframework.boot
spring-boot-starter-freemarker
org.springframework.boot
spring-boot-starter-test
test
org.projectlombok
lombok
com.alibaba
druid-spring-boot-starter
1.2.8
org.springframework.boot
spring-boot-starter-web
tk.mybatis
mapper-spring-boot-starter
2.0.2
javax.persistence
persistence-api
1.0
compile
mysql
mysql-connector-java
①、包中新建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;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class DruidConnectionProvider implements ConnectionProvider {
public String driver;
public String URL;
public String user;
public String password;
public int maxConnection;
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;
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;
}
@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 u8C03u5EA6u5668u5C5Eu6027 #============================================================================ 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 #============================================================================ #u5B58u50A8u65B9u5F0Fu4F7Fu7528JobStoreTX,u4E5Fu5C31u662Fu6570u636Eu5E93 org.quartz.jobStore.class:org.quartz.impl.jdbcjobstore.JobStoreTX org.quartz.jobStore.driverDelegateClass:org.quartz.impl.jdbcjobstore.StdJDBCDelegate #u4F7Fu7528u81EAu5DF1,u7684u914Du7F6Eu6587u4EF6 org.quartz.jobStore.useProperties:true #u6570u636Eu5E93u4E2Dquartzu8868u7684u8868u540Du524Du7F00 org.quartz.jobStore.tablePrefix:qrtz_ org.quartz.jobStore.dataSource:qzDS #u662Fu5426u4F7Fu7528u96C6u7FA4(u5982u679Cu9879u76EEu53EAu90E8u7F72u5230 u4E00u53F0u670Du52A1u5668,u5C31u4E0Du7528u4E86) org.quartz.jobStore.isClustered=true #============================================================================ # Configure Datasources #============================================================================ #u914Du7F6Eu6570u636Eu5E93u6E90uFF08org.quartz.dataSource.qzDS.maxConnections: c3p0u914Du7F6Eu7684u662Fu6709su7684,druidu6570u636Eu6E90u6CA1u6709suFF09 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:104、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
提供查询所有的方法
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{ }
（2）新建ScheduleTriggerDataMapper接口继承mapper
提供根据触发器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{ }
③、新建service包
（1）新建ScheduleTriggerService接口
package com.mwy.code.service;
import com.mwy.code.pojo.ScheduleTrigger;
import java.util.List;
public interface ScheduleTriggerService {
// 查询所有的方法
List 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 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 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 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) 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目录下
| 表达式 | 名字(执行类名) | 分组 | 任务描述 | 触发器描述 | 状态 | 操作 |
| ${trigger.cron!""} | ${trigger.jobName!""} | ${trigger.jobGroup!""} | ${trigger.jobDescription!""} | ${trigger.triggerDescription!""} | ${(trigger.status=='0')?string("已禁用","启用中")} | 关闭 修改 |
查看结果
增加结果
还没写完！！修改和删除
