3、springBoot集成Quartz数据库持久化

怼烎@ 2022-05-29 12:27 347阅读 0赞

## 前言 ##

有时候，我们会将任务放到数据库中，等我们需要的是，自动从前台进行点击，然后开始执行任务。那么这个时候，就用到quartz。可以从数据库中直接读取，然后执行。非常的方便，可以说nice。

比如多点科技的试客任务，用户可以确定从几点到几点开始投放app，那么这里也可以用到，从几点开始到几点执行，无非就是加两条任务。一条是开始执行，一条是终止任务。

springBoot集成Quartz数据库持久化

那么首先，持久化，不是说我们将任务放到表里取出，就算持久化了，持久化，其实可以这样任务，我们上面说的只是方法的书写，也就是逻辑，真正持久化，应该是如果我们中间断掉服务器。任务还在为我们保存。并且在启动服务器之后可以自动执行

## 1、quartz持久化数据库表的创建 ##

> 打开网址 [http://www.quartz-scheduler.org/downloads/][http_www.quartz-scheduler.org_downloads]  
> 下载quartz，然后压缩之后打开里面的/docs/dbTables/  
> 根据我们所使用的数据库进行选择，这里我用的是 mysql，所以选择了数据库表为**tables\_mysql\_innodb.sql**

不想下载的直接复制哦

#
    # In your Quartz properties file, you'll need to set 
    # org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
    #
    #
    # By: Ron Cordell - roncordell
    #  I didn't see this anywhere, so I thought I'd post it here. This is the script from Quartz to create the tables in a MySQL database, modified to use INNODB instead of MYISAM.
    
    DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
    DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;
    DROP TABLE IF EXISTS QRTZ_LOCKS;
    DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;
    DROP TABLE IF EXISTS QRTZ_CALENDARS;
    
    CREATE TABLE QRTZ_JOB_DETAILS(
    SCHED_NAME VARCHAR(120) NOT NULL,
    JOB_NAME VARCHAR(200) NOT NULL,
    JOB_GROUP VARCHAR(200) NOT NULL,
    DESCRIPTION VARCHAR(250) NULL,
    JOB_CLASS_NAME VARCHAR(250) NOT NULL,
    IS_DURABLE VARCHAR(1) NOT NULL,
    IS_NONCONCURRENT VARCHAR(1) NOT NULL,
    IS_UPDATE_DATA VARCHAR(1) NOT NULL,
    REQUESTS_RECOVERY VARCHAR(1) NOT NULL,
    JOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP))
    ENGINE=InnoDB;
    
    CREATE TABLE QRTZ_TRIGGERS (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    JOB_NAME VARCHAR(200) NOT NULL,
    JOB_GROUP VARCHAR(200) NOT NULL,
    DESCRIPTION VARCHAR(250) NULL,
    NEXT_FIRE_TIME BIGINT(13) NULL,
    PREV_FIRE_TIME BIGINT(13) NULL,
    PRIORITY INTEGER NULL,
    TRIGGER_STATE VARCHAR(16) NOT NULL,
    TRIGGER_TYPE VARCHAR(8) NOT NULL,
    START_TIME BIGINT(13) NOT NULL,
    END_TIME BIGINT(13) NULL,
    CALENDAR_NAME VARCHAR(200) NULL,
    MISFIRE_INSTR SMALLINT(2) NULL,
    JOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
    REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP))
    ENGINE=InnoDB;
    
    CREATE TABLE QRTZ_SIMPLE_TRIGGERS (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    REPEAT_COUNT BIGINT(7) NOT NULL,
    REPEAT_INTERVAL BIGINT(12) NOT NULL,
    TIMES_TRIGGERED BIGINT(10) NOT NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
    ENGINE=InnoDB;
    
    CREATE TABLE QRTZ_CRON_TRIGGERS (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    CRON_EXPRESSION VARCHAR(120) NOT NULL,
    TIME_ZONE_ID VARCHAR(80),
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
    ENGINE=InnoDB;
    
    CREATE TABLE QRTZ_SIMPROP_TRIGGERS
      (          
        SCHED_NAME VARCHAR(120) NOT NULL,
        TRIGGER_NAME VARCHAR(200) NOT NULL,
        TRIGGER_GROUP VARCHAR(200) NOT NULL,
        STR_PROP_1 VARCHAR(512) NULL,
        STR_PROP_2 VARCHAR(512) NULL,
        STR_PROP_3 VARCHAR(512) NULL,
        INT_PROP_1 INT NULL,
        INT_PROP_2 INT NULL,
        LONG_PROP_1 BIGINT NULL,
        LONG_PROP_2 BIGINT NULL,
        DEC_PROP_1 NUMERIC(13,4) NULL,
        DEC_PROP_2 NUMERIC(13,4) NULL,
        BOOL_PROP_1 VARCHAR(1) NULL,
        BOOL_PROP_2 VARCHAR(1) NULL,
        PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
        FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP) 
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
    ENGINE=InnoDB;
    
    CREATE TABLE QRTZ_BLOB_TRIGGERS (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    BLOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    INDEX (SCHED_NAME,TRIGGER_NAME, TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
    ENGINE=InnoDB;
    
    CREATE TABLE QRTZ_CALENDARS (
    SCHED_NAME VARCHAR(120) NOT NULL,
    CALENDAR_NAME VARCHAR(200) NOT NULL,
    CALENDAR BLOB NOT NULL,
    PRIMARY KEY (SCHED_NAME,CALENDAR_NAME))
    ENGINE=InnoDB;
    
    CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP))
    ENGINE=InnoDB;
    
    CREATE TABLE QRTZ_FIRED_TRIGGERS (
    SCHED_NAME VARCHAR(120) NOT NULL,
    ENTRY_ID VARCHAR(95) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    INSTANCE_NAME VARCHAR(200) NOT NULL,
    FIRED_TIME BIGINT(13) NOT NULL,
    SCHED_TIME BIGINT(13) NOT NULL,
    PRIORITY INTEGER NOT NULL,
    STATE VARCHAR(16) NOT NULL,
    JOB_NAME VARCHAR(200) NULL,
    JOB_GROUP VARCHAR(200) NULL,
    IS_NONCONCURRENT VARCHAR(1) NULL,
    REQUESTS_RECOVERY VARCHAR(1) NULL,
    PRIMARY KEY (SCHED_NAME,ENTRY_ID))
    ENGINE=InnoDB;
    
    CREATE TABLE QRTZ_SCHEDULER_STATE (
    SCHED_NAME VARCHAR(120) NOT NULL,
    INSTANCE_NAME VARCHAR(200) NOT NULL,
    LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
    CHECKIN_INTERVAL BIGINT(13) NOT NULL,
    PRIMARY KEY (SCHED_NAME,INSTANCE_NAME))
    ENGINE=InnoDB;
    
    CREATE TABLE QRTZ_LOCKS (
    SCHED_NAME VARCHAR(120) NOT NULL,
    LOCK_NAME VARCHAR(40) NOT NULL,
    PRIMARY KEY (SCHED_NAME,LOCK_NAME))
    ENGINE=InnoDB;
    
    CREATE INDEX IDX_QRTZ_J_REQ_RECOVERY ON QRTZ_JOB_DETAILS(SCHED_NAME,REQUESTS_RECOVERY);
    CREATE INDEX IDX_QRTZ_J_GRP ON QRTZ_JOB_DETAILS(SCHED_NAME,JOB_GROUP);
    
    CREATE INDEX IDX_QRTZ_T_J ON QRTZ_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
    CREATE INDEX IDX_QRTZ_T_JG ON QRTZ_TRIGGERS(SCHED_NAME,JOB_GROUP);
    CREATE INDEX IDX_QRTZ_T_C ON QRTZ_TRIGGERS(SCHED_NAME,CALENDAR_NAME);
    CREATE INDEX IDX_QRTZ_T_G ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);
    CREATE INDEX IDX_QRTZ_T_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE);
    CREATE INDEX IDX_QRTZ_T_N_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP,TRIGGER_STATE);
    CREATE INDEX IDX_QRTZ_T_N_G_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP,TRIGGER_STATE);
    CREATE INDEX IDX_QRTZ_T_NEXT_FIRE_TIME ON QRTZ_TRIGGERS(SCHED_NAME,NEXT_FIRE_TIME);
    CREATE INDEX IDX_QRTZ_T_NFT_ST ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE,NEXT_FIRE_TIME);
    CREATE INDEX IDX_QRTZ_T_NFT_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME);
    CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_STATE);
    CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE_GRP ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_GROUP,TRIGGER_STATE);
    
    CREATE INDEX IDX_QRTZ_FT_TRIG_INST_NAME ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME);
    CREATE INDEX IDX_QRTZ_FT_INST_JOB_REQ_RCVRY ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME,REQUESTS_RECOVERY);
    CREATE INDEX IDX_QRTZ_FT_J_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
    CREATE INDEX IDX_QRTZ_FT_JG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_GROUP);
    CREATE INDEX IDX_QRTZ_FT_T_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP);
    CREATE INDEX IDX_QRTZ_FT_TG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);
    
    commit;

## 2、导入相关依赖 ##

> 1、其实接着之前的代码，pom依赖几已经具备了

<dependency>
    	<groupId>org.quartz-scheduler</groupId>
    	<artifactId>quartz-jobs</artifactId>
    	<version>2.2.1</version>
    </dependency>
    
    <dependency>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-starter-quartz</artifactId>
    </dependency>

> 2、整个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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    
    	<groupId>com.hlj.quartz</groupId>
    	<artifactId>com-hlj-quartz</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<packaging>jar</packaging>
    
    	<name>com-hlj-quartz</name>
    	<description>Demo project for Spring Boot</description>
    
    	<parent>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-parent</artifactId>
    		<version>2.0.0.RELEASE</version>
    		<relativePath/> 
    	</parent>
    
    	<properties>
    		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    		<java.version>1.8</java.version>
    	</properties>
    
    	<dependencies>
    
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-web</artifactId>
    		</dependency>
    
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-test</artifactId>
    			<scope>test</scope>
    		</dependency>
    
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-data-jpa</artifactId>
    		</dependency>
    
    		<dependency>
    			<groupId>mysql</groupId>
    			<artifactId>mysql-connector-java</artifactId>
    			<scope>runtime</scope>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>org.quartz-scheduler</groupId>
    			<artifactId>quartz-jobs</artifactId>
    			<version>2.2.1</version>
    		</dependency>
    
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-quartz</artifactId>
    		</dependency>
    
        </dependencies>
    
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    			</plugin>
    		</plugins>
    	</build>
    
    </project>

## 3、开始配置quartz关于持久化存储的位置 ##

> resource 下 新建配置文件 quartz.properties

1、主要是观察下main的`org.quartz.jobStore.class`，从上一节的`org.quartz.simpl.RAMJobStore`变成了下面的`bStore`变成了下面的`org.quartz.impl.jdbcjobstor`

#job存储方式，RAMJobStore是使用JobStore最简单的一种方式，它也是性能最高效的，顾名思义，JobStore是把它的数据都存储在RAM中，
    # 这也是它的快速和简单配置的原因；JDBCJobStore也是一种相当有名的JobStore，它通过JDBC把数据都保存到数据库中，
    # 所以在配置上会比RAMJobStore复杂一些，而且不像RAMJobStore那么快

2、这里虽然在配置中添加了集群属性，但其实没有，下一章节，我将会介绍集群的

3、配置文件全部内容如下

#使用自己的配置文件
    org.quartz.jobStore.useProperties:true
    
    #默认或是自己改名字都行
    org.quartz.scheduler.instanceName: DefaultQuartzScheduler
    #如果使用集群，instanceId必须唯一，设置成AUTO
    org.quartz.scheduler.instanceId = AUTO
    
    
    org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
    org.quartz.threadPool.threadCount: 10
    org.quartz.threadPool.threadPriority: 5
    org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true
    
    
    #存储方式使用JobStoreTX，也就是数据库
    org.quartz.jobStore.class:org.quartz.impl.jdbcjobstore.JobStoreTX
    org.quartz.jobStore.driverDelegateClass:org.quartz.impl.jdbcjobstore.StdJDBCDelegate
    #是否使用集群（如果项目只部署到 一台服务器，就不用了）
    org.quartz.jobStore.isClustered = true
    org.quartz.jobStore.clusterCheckinInterval=20000
    org.quartz.jobStore.tablePrefix = QRTZ_
    org.quartz.jobStore.dataSource = myDS
    
    #配置数据源
    #数据库中quartz表的表名前缀
    
    org.quartz.dataSource.myDS.driver = com.mysql.jdbc.Driver
    org.quartz.dataSource.myDS.URL = jdbc:mysql://localhost:3306/com_hlj_quartz?characterEncoding=utf-8
    org.quartz.dataSource.myDS.user = root
    org.quartz.dataSource.myDS.password = 123456
    org.quartz.dataSource.myDS.maxConnections = 5

## 3、定义任务存储类 ##

> 一个任务，主要是有任务名称，任务分组。名称和分组都用来干嘛，哈哈，一开始我也脑子不好使现在突然明白了
> 
> 就好比一个任务它要停止吧，停止了，再怎么关闭呢。那这就是两个任务名称喽，那它应该在同一个组中吧
> 
> 我这里其实将任务名称作为一个工作的包和类名去存储了。`com.hlj.quartz.quartz.Job .MaTsk`因为确实一个工作的类，才是一个任务。如果看不出来这是干啥的，可以再多加几个字段，进行备注。

> 真实项目中，可以将工作类名和工作名字分开写，这样方便观察和配合实际逻辑

INSERT INTO `c_schedule_triggers` VALUES ('1', '0/1 * * * * ?', 'group1', 'com.hlj.quartz.quartz.Job.MyTask', '1');
    COMMIT;

package com.hlj.quartz.quartz.Bean;
    
    
    
    import javax.persistence.*;
    
    /**
     * @Description
     * @Author HealerJean
     * @Date 2018/3/23  下午4:11.
     */
    
    
    @Entity
    @Table(name = "c_schedule_triggers")
    public class CScheduleTrigger {
    
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
    
        private String cron;  //时间表达式
    
        private String status; //使用状态 0：禁用   1：启用
    
        private String jobName; //任务名称
    
        private String jobGroup; //任务分组
    
        public Long getId() {
            return id;
        }
    
        public void setId(Long id) {
            this.id = id;
        }
    
        public String getCron() {
            return cron;
        }
    
        public void setCron(String cron) {
            this.cron = cron;
        }
    
        public String getStatus() {
            return status;
        }
    
        public void setStatus(String status) {
            this.status = status;
        }
    
        public String getJobName() {
            return jobName;
        }
    
        public void setJobName(String jobName) {
            this.jobName = jobName;
        }
    
        public String getJobGroup() {
            return jobGroup;
        }
    
        public void setJobGroup(String jobGroup) {
            this.jobGroup = jobGroup;
        }
    }

## 4、配置定时器吧，朋友 ##

### 4.1、工作工厂    ###

package com.hlj.quartz.quartz.config;
    
    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;
    
    /**
     * @Description
     * @Author HealerJean
     * @Date 2018/3/22  下午3:43.
     */
    @Component
    public class JobFactory extends AdaptableJobFactory {
        @Autowired
        private AutowireCapableBeanFactory capableBeanFactory;
    
        @Override
        protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
            //调用父类的方法
            Object jobInstance = super.createJobInstance(bundle);
            //进行注入
            capableBeanFactory.autowireBean(jobInstance);
            return jobInstance;
        }
    }

### 4.2、读取配置文件和生成定时器 ###

package com.hlj.quartz.quartz.config;
    
    import org.quartz.Scheduler;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.config.PropertiesFactoryBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.io.ClassPathResource;
    import org.springframework.scheduling.quartz.SchedulerFactoryBean;
    
    import java.io.IOException;
    import java.util.Properties;
    
    
    /**
     * @Description
     * @Author HealerJean
     * @Date 2018/3/22  下午3:45.
     */
    @Configuration
    public class QuartzConfig {
    
        @Autowired
        private JobFactory jobFactory;
    
        @Bean
        public Properties quartzProperties() throws IOException {
            PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
            propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
            propertiesFactoryBean.afterPropertiesSet();
            return propertiesFactoryBean.getObject();
        }
    
    
        @Bean
        public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
            SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
    
            schedulerFactoryBean.setOverwriteExistingJobs(true);
            schedulerFactoryBean.setQuartzProperties(quartzProperties());
            schedulerFactoryBean.setJobFactory(jobFactory);
    
            return schedulerFactoryBean;
        }
    
    
    
        // 创建schedule
        @Bean(name = "scheduler")
        public Scheduler scheduler() throws IOException {
            return schedulerFactoryBean().getScheduler();
        }
    }

## 5、编辑一个工作任务 ##

> 工作任务中，还有可以获取任务的很多信息，触发规则，工作名字，工作组等信息

package com.hlj.quartz.quartz.Job;
    
    import com.hlj.quartz.quartz.Repository.CScheduleTriggerRepository;
    import org.quartz.CronTrigger;
    import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    /**
     * @Description
     * @Author HealerJean
     * @Date 2018/3/23  下午4:19.
     */
    
    @Component
    public class MyTask implements Job {
    
        //这里就可以通过spring注入bean了
        @Autowired
        private CScheduleTriggerRepository jobRepository;
    
        @Override
        public void execute(JobExecutionContext context) throws JobExecutionException {
    
            boolean isExecute = false;  //是否已执行业务逻辑
            boolean flag = false;  //业务逻辑执行后返回结果
            try {
                //可以通过context拿到执行当前任务的quartz中的很多信息，如当前是哪个trigger在执行该任务
                CronTrigger trigger = (CronTrigger) context.getTrigger();
                String corn = trigger.getCronExpression();
                String jobName = trigger.getKey().getName();
                String jobGroup = trigger.getKey().getGroup();
                System.out.println("corn:"+corn);
                System.out.println("jobName:"+jobName);
                System.out.println("jobGroup:"+jobGroup);
            }catch (Exception e){
                e.printStackTrace();
            }
            System.out.println("执行任务中");
        }
    }

## 6、开始执行工作任务 ##

1、 可以添加自定义的注解进行让任务定时执行，就又回到了springBOOt 的定时器了哦，哈哈当然，这里不要了，因为我想调用让它执行

@Scheduled(cron = "0/1 * * * * ?")  //每天晚上11点调用这个方法来更新quartz中的任务

2、剩下的其实和上一讲的东西差不多，无非就是添加了判断和检测是否任务发送变化，然后重新执行

package com.hlj.quartz.quartz.service;
    
    import java.util.List;
    
    import com.hlj.quartz.quartz.Bean.CScheduleTrigger;
    import com.hlj.quartz.quartz.Repository.CScheduleTriggerRepository;
    import org.quartz.CronScheduleBuilder;
    import org.quartz.CronTrigger;
    import org.quartz.Job;
    import org.quartz.JobBuilder;
    import org.quartz.JobDetail;
    import org.quartz.JobKey;
    import org.quartz.Scheduler;
    
    import org.quartz.TriggerBuilder;
    import org.quartz.TriggerKey;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    
    
    /**
     * @Description
     * @Author HealerJean
     * @Date 2018/3/23  下午4:16.
     */
    
    
    @Service
    public class ScheduleTriggerService {
        private static final Logger logger = LoggerFactory.getLogger(ScheduleTriggerService.class);
        @Autowired
        private Scheduler scheduler;
    
        @Autowired
        private CScheduleTriggerRepository triggerRepository;
    
    
    //    @Scheduled(cron = "0/1 * * * * ?")  //每天晚上11点调用这个方法来更新quartz中的任务
        public void refreshTrigger() {
            try {
                //查询出数据库中所有的定时任务
                List<CScheduleTrigger> jobList = triggerRepository.findAll();
                if (jobList != null) {
                    for (CScheduleTrigger scheduleJob : jobList) {
                        String status = scheduleJob.getStatus(); //该任务触发器目前的状态
                        TriggerKey triggerKey = TriggerKey.triggerKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
                        CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
                        //说明本条任务还没有添加到quartz中
                        if (null == trigger) {
                            if (status.equals("0")) { //如果是禁用，则不用创建触发器
                                continue;
                            }
    
                            JobDetail jobDetail = null;
                            try {
                                //创建JobDetail（数据库中job_name存的任务全路径，这里就可以动态的把任务注入到JobDetail中）
                                jobDetail = JobBuilder.newJob((Class<? extends Job>) Class.forName(scheduleJob.getJobName())).withIdentity(scheduleJob.getJobName(), scheduleJob.getJobGroup()).build();
    
                                //表达式调度构建器
                                CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCron());
                                ///设置定时任务的时间触发规则
                                trigger = TriggerBuilder.newTrigger().withIdentity(scheduleJob.getJobName(), scheduleJob.getJobGroup()).withSchedule(scheduleBuilder).build();
                                //把trigger和jobDetail注入到调度器
                                scheduler.scheduleJob(jobDetail, trigger);
                            } catch (ClassNotFoundException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            }
    
                        } else {  //说明查出来的这条任务，已经设置到quartz中了
                            // Trigger已存在，先判断是否需要删除，如果不需要，再判定是否时间有变化
                            if (status.equals("0")) { //如果是禁用，从quartz中删除这条任务
                                JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
                                scheduler.deleteJob(jobKey);
                                continue;
                            }
                            String searchCron = scheduleJob.getCron(); //获取数据库的
                            String currentCron = trigger.getCronExpression();
                            if (!searchCron.equals(currentCron)) {  //说明该任务有变化，需要更新quartz中的对应的记录
                                //表达式调度构建器
                                CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(searchCron);
    
                                //按新的cronExpression表达式重新构建trigger
                                trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
    
                                //按新的trigger重新设置job执行
                                scheduler.rescheduleJob(triggerKey, trigger);
                            }
                        }
                    }
                }
            } catch (Exception e) {
                logger.error("定时任务每日刷新触发器任务异常，在ScheduleTriggerServiceImpl的方法refreshTrigger中，异常信息：", e);
            }
        }
    }

## 7、controller，开始执行测试 ##

package com.hlj.quartz.controller;
    
    
    import com.hlj.quartz.quartz.service.ScheduleTriggerService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    
    /**
     * @Description
     * @Author HealerJean
     * @Date 2018/3/22  下午4:47.
     */
    @RestController
    public class QuartzController {
    
    
        @Autowired
        private ScheduleTriggerService scheduleTriggerService;
    
    
        @GetMapping("quartzStart")
        public String startNNoQuartz(){
            scheduleTriggerService.refreshTrigger();
    
            return "定时器任务开始执行，请注意观察控制台";
        }
    
    }

### 7.1、浏览器打开 ###

[http://localhost:8080/quartzStart][http_localhost_8080_quartzStart]

1、观察控制台

![WX20180323-182150][]

2、这个时候，关闭端口，然后重新启动项目，会发现，这个时候，不需要重新开始调用，任务还在执行，那么这就是持久化，将任务放到了数据库中，启动后自动去执行任务

![WX20180323-182224][]

## 8、观察数据库 表 ##

> 发现里面有了数据，哈哈，这就是持久化，明白了吧。具体数据就不给大家截图了，自己好好运行吧，下面有代码

## [代码下载][Link 1] ##

![ContactAuthor][]

[http_www.quartz-scheduler.org_downloads]: http://www.quartz-scheduler.org/downloads/
[http_localhost_8080_quartzStart]: http://localhost:8080/quartzStart
[WX20180323-182150]: /images/20220529/259552a7e46d4b8793c49bed5f5f8185.png
[WX20180323-182224]: /images/20220529/b5d8f7cece5b4a20ba736bd817298728.png
[Link 1]: https://gitee.com/HealerJean/CodeDownLoad/blob/master/2018_03_23_3_springBoot%E9%9B%86%E6%88%90Quartz%E6%95%B0%E6%8D%AE%E5%BA%93%E6%8C%81%E4%B9%85%E5%8C%96/com-hlj-quartz.zip
[ContactAuthor]: /images/20220529/d571677e490741d5b05b9164ac06c19c.png