SpringBoot 整合 Quartz

1. 先说为什么会用Quartz吧, 业务需求是在一个时间段比如 12:00---16:00,开始前一个小时需要提醒一次用户,结束前一个小时需要用户,12:00整的时候也需要提醒一次用户,并且可能多个存在多个这样相同的任务.(所以就需要一个任务时间不会错乱的,timertask可能会导致任务时间错乱,所以首先就排除,quartz每一个任务都是一个新的线程,因为使用到了线程池 时间轮),整合如下:

1.导入依赖

1.  
   <!--spring与quartz依赖-->
2.  
   <dependency>
3.  
   <groupId>org.springframework.boot</groupId>
4.  
   <artifactId>spring-boot-starter-quartz</artifactId>
5.  
   <version>2.6.6</version>
6.  
   </dependency>

2. 因为这里我选择了把任务持久化到数据库,防止宕机过后任务丢失(记得更换自己的数据库账号密码)

1.  
   #调度配置
2.  
   #调度器实例名称
3.  
   org.quartz.scheduler.instanceName=SsmScheduler
4.  
   #调度器实例编号自动生成
5.  
   org.quartz.scheduler.instanceId=AUTO
6.  
   #是否在Quartz执行一个job前使用UserTransaction
7.  
   org.quartz.scheduler.wrapJobExecutionInUserTransaction=false
8.  
    
9.  
   #线程池配置
10.  
    #线程池的实现类
11.  
    org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
12.  
    #线程池中的线程数量
13.  
    org.quartz.threadPool.threadCount=10
14.  
    #线程优先级
15.  
    org.quartz.threadPool.threadPriority=5
16.  
    #配置是否启动自动加载数据库内的定时任务，默认true
17.  
    org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread=true
18.  
    #是否设置为守护线程，设置后任务将不会执行
19.  
    #org.quartz.threadPool.makeThreadsDaemons=true
20.  
     
21.  
    #持久化方式配置
22.  
    #JobDataMaps是否都为String类型
23.  
    org.quartz.jobStore.useProperties=true
24.  
    #数据表的前缀，默认QRTZ_
25.  
    org.quartz.jobStore.tablePrefix=qrtz_
26.  
    #最大能忍受的触发超时时间
27.  
    org.quartz.jobStore.misfireThreshold=60000
28.  
    #是否以集群方式运行
29.  
    org.quartz.jobStore.isClustered=true
30.  
    #调度实例失效的检查时间间隔，单位毫秒
31.  
    org.quartz.jobStore.clusterCheckinInterval=2000
32.  
    #数据保存方式为数据库持久化
33.  
    org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
34.  
    #数据库代理类，一般org.quartz.impl.jdbcjobstore.StdJDBCDelegate可以满足大部分数据库
35.  
    org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
36.  
    #数据库别名 随便取
37.  
    org.quartz.jobStore.dataSource=qzDS
38.  
     
39.  
    #数据库连接池，将其设置为druid
40.  
    org.quartz.dataSource.qzDS.connectionProvider.class=com.ruoyi.system.config.DruidConnectionProvider
41.  
    #数据库引擎
42.  
    org.quartz.dataSource.qzDS.driver=com.mysql.cj.jdbc.Driver
43.  
    #数据库连接
44.  
    org.quartz.dataSource.qzDS.URL=jdbc:mysql://127.0.0.1:3306/ry-cloud?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
45.  
    #数据库用户
46.  
    org.quartz.dataSource.qzDS.user=root
47.  
    #数据库密码
48.  
    org.quartz.dataSource.qzDS.password=abc123
49.  
    #允许最大连接
50.  
    org.quartz.dataSource.qzDS.maxConnection=5
51.  
    #验证查询sql,可以不设置
52.  
    #org.quartz.dataSource.qzDS.validationQuery=select 0 from dual
53.  
    #数据库连接池，将其设置为druid

添加数据库表,这里官方已经提供了sql文件,官方网站：http://quartz-scheduler.org/

路径:quartz-2.3.0-SNAPSHOT\src\org\quartz\impl\jdbcjobstore\tables_mysql_innodb.sql

1.  
   #
2.  
   # In your Quartz properties file, you'll need to set
3.  
   # org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
4.  
   #
5.  
   #
6.  
   # By: Ron Cordell - roncordell
7.  
   # 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.
8.  
    
9.  
   DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;
10.  
    DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
11.  
    DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;
12.  
    DROP TABLE IF EXISTS QRTZ_LOCKS;
13.  
    DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;
14.  
    DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;
15.  
    DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;
16.  
    DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;
17.  
    DROP TABLE IF EXISTS QRTZ_TRIGGERS;
18.  
    DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;
19.  
    DROP TABLE IF EXISTS QRTZ_CALENDARS;
20.  
     
21.  
    CREATE TABLE QRTZ_JOB_DETAILS(
22.  
    SCHED_NAME VARCHAR(120) NOT NULL,
23.  
    JOB_NAME VARCHAR(190) NOT NULL,
24.  
    JOB_GROUP VARCHAR(190) NOT NULL,
25.  
    DESCRIPTION VARCHAR(250) NULL,
26.  
    JOB_CLASS_NAME VARCHAR(250) NOT NULL,
27.  
    IS_DURABLE VARCHAR(1) NOT NULL,
28.  
    IS_NONCONCURRENT VARCHAR(1) NOT NULL,
29.  
    IS_UPDATE_DATA VARCHAR(1) NOT NULL,
30.  
    REQUESTS_RECOVERY VARCHAR(1) NOT NULL,
31.  
    JOB_DATA BLOB NULL,
32.  
    PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP))
33.  
    ENGINE=InnoDB;
34.  
     
35.  
    CREATE TABLE QRTZ_TRIGGERS (
36.  
    SCHED_NAME VARCHAR(120) NOT NULL,
37.  
    TRIGGER_NAME VARCHAR(190) NOT NULL,
38.  
    TRIGGER_GROUP VARCHAR(190) NOT NULL,
39.  
    JOB_NAME VARCHAR(190) NOT NULL,
40.  
    JOB_GROUP VARCHAR(190) NOT NULL,
41.  
    DESCRIPTION VARCHAR(250) NULL,
42.  
    NEXT_FIRE_TIME BIGINT(13) NULL,
43.  
    PREV_FIRE_TIME BIGINT(13) NULL,
44.  
    PRIORITY INTEGER NULL,
45.  
    TRIGGER_STATE VARCHAR(16) NOT NULL,
46.  
    TRIGGER_TYPE VARCHAR(8) NOT NULL,
47.  
    START_TIME BIGINT(13) NOT NULL,
48.  
    END_TIME BIGINT(13) NULL,
49.  
    CALENDAR_NAME VARCHAR(190) NULL,
50.  
    MISFIRE_INSTR SMALLINT(2) NULL,
51.  
    JOB_DATA BLOB NULL,
52.  
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
53.  
    FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
54.  
    REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP))
55.  
    ENGINE=InnoDB;
56.  
     
57.  
    CREATE TABLE QRTZ_SIMPLE_TRIGGERS (
58.  
    SCHED_NAME VARCHAR(120) NOT NULL,
59.  
    TRIGGER_NAME VARCHAR(190) NOT NULL,
60.  
    TRIGGER_GROUP VARCHAR(190) NOT NULL,
61.  
    REPEAT_COUNT BIGINT(7) NOT NULL,
62.  
    REPEAT_INTERVAL BIGINT(12) NOT NULL,
63.  
    TIMES_TRIGGERED BIGINT(10) NOT NULL,
64.  
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
65.  
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
66.  
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
67.  
    ENGINE=InnoDB;
68.  
     
69.  
    CREATE TABLE QRTZ_CRON_TRIGGERS (
70.  
    SCHED_NAME VARCHAR(120) NOT NULL,
71.  
    TRIGGER_NAME VARCHAR(190) NOT NULL,
72.  
    TRIGGER_GROUP VARCHAR(190) NOT NULL,
73.  
    CRON_EXPRESSION VARCHAR(120) NOT NULL,
74.  
    TIME_ZONE_ID VARCHAR(80),
75.  
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
76.  
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
77.  
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
78.  
    ENGINE=InnoDB;
79.  
     
80.  
    CREATE TABLE QRTZ_SIMPROP_TRIGGERS
81.  
    (
82.  
    SCHED_NAME VARCHAR(120) NOT NULL,
83.  
    TRIGGER_NAME VARCHAR(190) NOT NULL,
84.  
    TRIGGER_GROUP VARCHAR(190) NOT NULL,
85.  
    STR_PROP_1 VARCHAR(512) NULL,
86.  
    STR_PROP_2 VARCHAR(512) NULL,
87.  
    STR_PROP_3 VARCHAR(512) NULL,
88.  
    INT_PROP_1 INT NULL,
89.  
    INT_PROP_2 INT NULL,
90.  
    LONG_PROP_1 BIGINT NULL,
91.  
    LONG_PROP_2 BIGINT NULL,
92.  
    DEC_PROP_1 NUMERIC(13,4) NULL,
93.  
    DEC_PROP_2 NUMERIC(13,4) NULL,
94.  
    BOOL_PROP_1 VARCHAR(1) NULL,
95.  
    BOOL_PROP_2 VARCHAR(1) NULL,
96.  
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
97.  
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
98.  
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
99.  
    ENGINE=InnoDB;
100.  
      
101.  
     CREATE TABLE QRTZ_BLOB_TRIGGERS (
102.  
     SCHED_NAME VARCHAR(120) NOT NULL,
103.  
     TRIGGER_NAME VARCHAR(190) NOT NULL,
104.  
     TRIGGER_GROUP VARCHAR(190) NOT NULL,
105.  
     BLOB_DATA BLOB NULL,
106.  
     PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
107.  
     INDEX (SCHED_NAME,TRIGGER_NAME, TRIGGER_GROUP),
108.  
     FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
109.  
     REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
110.  
     ENGINE=InnoDB;
111.  
      
112.  
     CREATE TABLE QRTZ_CALENDARS (
113.  
     SCHED_NAME VARCHAR(120) NOT NULL,
114.  
     CALENDAR_NAME VARCHAR(190) NOT NULL,
115.  
     CALENDAR BLOB NOT NULL,
116.  
     PRIMARY KEY (SCHED_NAME,CALENDAR_NAME))
117.  
     ENGINE=InnoDB;
118.  
      
119.  
     CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS (
120.  
     SCHED_NAME VARCHAR(120) NOT NULL,
121.  
     TRIGGER_GROUP VARCHAR(190) NOT NULL,
122.  
     PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP))
123.  
     ENGINE=InnoDB;
124.  
      
125.  
     CREATE TABLE QRTZ_FIRED_TRIGGERS (
126.  
     SCHED_NAME VARCHAR(120) NOT NULL,
127.  
     ENTRY_ID VARCHAR(95) NOT NULL,
128.  
     TRIGGER_NAME VARCHAR(190) NOT NULL,
129.  
     TRIGGER_GROUP VARCHAR(190) NOT NULL,
130.  
     INSTANCE_NAME VARCHAR(190) NOT NULL,
131.  
     FIRED_TIME BIGINT(13) NOT NULL,
132.  
     SCHED_TIME BIGINT(13) NOT NULL,
133.  
     PRIORITY INTEGER NOT NULL,
134.  
     STATE VARCHAR(16) NOT NULL,
135.  
     JOB_NAME VARCHAR(190) NULL,
136.  
     JOB_GROUP VARCHAR(190) NULL,
137.  
     IS_NONCONCURRENT VARCHAR(1) NULL,
138.  
     REQUESTS_RECOVERY VARCHAR(1) NULL,
139.  
     PRIMARY KEY (SCHED_NAME,ENTRY_ID))
140.  
     ENGINE=InnoDB;
141.  
      
142.  
     CREATE TABLE QRTZ_SCHEDULER_STATE (
143.  
     SCHED_NAME VARCHAR(120) NOT NULL,
144.  
     INSTANCE_NAME VARCHAR(190) NOT NULL,
145.  
     LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
146.  
     CHECKIN_INTERVAL BIGINT(13) NOT NULL,
147.  
     PRIMARY KEY (SCHED_NAME,INSTANCE_NAME))
148.  
     ENGINE=InnoDB;
149.  
      
150.  
     CREATE TABLE QRTZ_LOCKS (
151.  
     SCHED_NAME VARCHAR(120) NOT NULL,
152.  
     LOCK_NAME VARCHAR(40) NOT NULL,
153.  
     PRIMARY KEY (SCHED_NAME,LOCK_NAME))
154.  
     ENGINE=InnoDB;
155.  
      
156.  
     CREATE INDEX IDX_QRTZ_J_REQ_RECOVERY ON QRTZ_JOB_DETAILS(SCHED_NAME,REQUESTS_RECOVERY);
157.  
     CREATE INDEX IDX_QRTZ_J_GRP ON QRTZ_JOB_DETAILS(SCHED_NAME,JOB_GROUP);
158.  
      
159.  
     CREATE INDEX IDX_QRTZ_T_J ON QRTZ_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
160.  
     CREATE INDEX IDX_QRTZ_T_JG ON QRTZ_TRIGGERS(SCHED_NAME,JOB_GROUP);
161.  
     CREATE INDEX IDX_QRTZ_T_C ON QRTZ_TRIGGERS(SCHED_NAME,CALENDAR_NAME);
162.  
     CREATE INDEX IDX_QRTZ_T_G ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);
163.  
     CREATE INDEX IDX_QRTZ_T_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE);
164.  
     CREATE INDEX IDX_QRTZ_T_N_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP,TRIGGER_STATE);
165.  
     CREATE INDEX IDX_QRTZ_T_N_G_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP,TRIGGER_STATE);
166.  
     CREATE INDEX IDX_QRTZ_T_NEXT_FIRE_TIME ON QRTZ_TRIGGERS(SCHED_NAME,NEXT_FIRE_TIME);
167.  
     CREATE INDEX IDX_QRTZ_T_NFT_ST ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE,NEXT_FIRE_TIME);
168.  
     CREATE INDEX IDX_QRTZ_T_NFT_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME);
169.  
     CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_STATE);
170.  
     CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE_GRP ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_GROUP,TRIGGER_STATE);
171.  
      
172.  
     CREATE INDEX IDX_QRTZ_FT_TRIG_INST_NAME ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME);
173.  
     CREATE INDEX IDX_QRTZ_FT_INST_JOB_REQ_RCVRY ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME,REQUESTS_RECOVERY);
174.  
     CREATE INDEX IDX_QRTZ_FT_J_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
175.  
     CREATE INDEX IDX_QRTZ_FT_JG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_GROUP);
176.  
     CREATE INDEX IDX_QRTZ_FT_T_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP);
177.  
     CREATE INDEX IDX_QRTZ_FT_TG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);
178.  
      
179.  
     commit;

配置连接池(需要导入druid依赖,上面忘了说),

1.  
    
2.  
    
3.  
   import com.alibaba.druid.pool.DruidDataSource;
4.  
   import com.alibaba.druid.pool.DruidPooledConnection;
5.  
   import org.quartz.SchedulerException;
6.  
   import org.quartz.utils.ConnectionProvider;
7.  
    
8.  
   import java.sql.SQLException;
9.  
    
10.  
    public class DruidConnectionProvider implements ConnectionProvider {
11.  
     
12.  
    /**
13.  
    * 常量配置，与quartz.properties文件的key保持一致(去掉前缀)，同时提供set方法，Quartz框架自动注入值。
14.  
    * @return
15.  
    * @throws SQLException
16.  
    */
17.  
     
18.  
    //JDBC驱动
19.  
    public String driver;
20.  
    //JDBC连接串
21.  
    public String URL;
22.  
    //数据库用户名
23.  
    public String user;
24.  
    //数据库用户密码
25.  
    public String password;
26.  
    //数据库最大连接数
27.  
    public int maxConnection;
28.  
    //数据库SQL查询每次连接返回执行到连接池，以确保它仍然是有效的。
29.  
    public String validationQuery;
30.  
     
31.  
    private boolean validateOnCheckout;
32.  
     
33.  
    private int idleConnectionValidationSeconds;
34.  
     
35.  
    public String maxCachedStatementsPerConnection;
36.  
     
37.  
    private String discardIdleConnectionsSeconds;
38.  
     
39.  
    public static final int DEFAULT_DB_MAX_CONNECTIONS = 10;
40.  
     
41.  
    public static final int DEFAULT_DB_MAX_CACHED_STATEMENTS_PER_CONNECTION = 120;
42.  
     
43.  
    //Druid连接池
44.  
    private DruidDataSource datasource;
45.  
     
46.  
    @Override
47.  
    public DruidPooledConnection getConnection() throws SQLException {
48.  
    return datasource.getConnection();
49.  
    }
50.  
     
51.  
    @Override
52.  
    public void shutdown() throws SQLException {
53.  
    datasource.close();
54.  
    }
55.  
     
56.  
    @Override
57.  
    public void initialize() throws SQLException {
58.  
    if (this.URL == null) {
59.  
    throw new SQLException("DBPool could not be created: DB URL cannot be null");
60.  
    }
61.  
     
62.  
    if (this.driver == null) {
63.  
    throw new SQLException("DBPool driver could not be created: DB driver class name cannot be null!");
64.  
    }
65.  
     
66.  
    if (this.maxConnection < 0) {
67.  
    throw new SQLException("DBPool maxConnectins could not be created: Max connections must be greater than zero!");
68.  
    }
69.  
     
70.  
    datasource = new DruidDataSource();
71.  
    try{
72.  
    datasource.setDriverClassName(this.driver);
73.  
    } catch (Exception e) {
74.  
    try {
75.  
    throw new SchedulerException("Problem setting driver class name on datasource: " e.getMessage(), e);
76.  
    } catch (SchedulerException e1) {
77.  
    }
78.  
    }
79.  
     
80.  
    datasource.setUrl(this.URL);
81.  
    datasource.setUsername(this.user);
82.  
    datasource.setPassword(this.password);
83.  
    datasource.setMaxActive(this.maxConnection);
84.  
    datasource.setMinIdle(1);
85.  
    datasource.setMaxWait(0);
86.  
    datasource.setMaxPoolPreparedStatementPerConnectionSize(DEFAULT_DB_MAX_CONNECTIONS);
87.  
     
88.  
    if (this.validationQuery != null) {
89.  
    datasource.setValidationQuery(this.validationQuery);
90.  
    if(!this.validateOnCheckout)
91.  
    datasource.setTestOnReturn(true);
92.  
    else
93.  
    datasource.setTestOnBorrow(true);
94.  
    datasource.setValidationQueryTimeout(this.idleConnectionValidationSeconds);
95.  
    }
96.  
    }
97.  
     
98.  
    public String getDriver() {
99.  
    return driver;
100.  
     }
101.  
      
102.  
     public void setDriver(String driver) {
103.  
     this.driver = driver;
104.  
     }
105.  
      
106.  
     public String getURL() {
107.  
     return URL;
108.  
     }
109.  
      
110.  
     public void setURL(String URL) {
111.  
     this.URL = URL;
112.  
     }
113.  
      
114.  
     public String getUser() {
115.  
     return user;
116.  
     }
117.  
      
118.  
     public void setUser(String user) {
119.  
     this.user = user;
120.  
     }
121.  
      
122.  
     public String getPassword() {
123.  
     return password;
124.  
     }
125.  
      
126.  
     public void setPassword(String password) {
127.  
     this.password = password;
128.  
     }
129.  
      
130.  
     public int getMaxConnection() {
131.  
     return maxConnection;
132.  
     }
133.  
      
134.  
     public void setMaxConnection(int maxConnection) {
135.  
     this.maxConnection = maxConnection;
136.  
     }
137.  
      
138.  
     public String getValidationQuery() {
139.  
     return validationQuery;
140.  
     }
141.  
      
142.  
     public void setValidationQuery(String validationQuery) {
143.  
     this.validationQuery = validationQuery;
144.  
     }
145.  
      
146.  
     public boolean isValidateOnCheckout() {
147.  
     return validateOnCheckout;
148.  
     }
149.  
      
150.  
     public void setValidateOnCheckout(boolean validateOnCheckout) {
151.  
     this.validateOnCheckout = validateOnCheckout;
152.  
     }
153.  
      
154.  
     public int getIdleConnectionValidationSeconds() {
155.  
     return idleConnectionValidationSeconds;
156.  
     }
157.  
      
158.  
     public void setIdleConnectionValidationSeconds(int idleConnectionValidationSeconds) {
159.  
     this.idleConnectionValidationSeconds = idleConnectionValidationSeconds;
160.  
     }
161.  
      
162.  
     public DruidDataSource getDatasource() {
163.  
     return datasource;
164.  
     }
165.  
      
166.  
     public void setDatasource(DruidDataSource datasource) {
167.  
     this.datasource = datasource;
168.  
     }
169.  
      
170.  
     public String getDiscardIdleConnectionsSeconds() {
171.  
     return discardIdleConnectionsSeconds;
172.  
     }
173.  
      
174.  
     public void setDiscardIdleConnectionsSeconds(String discardIdleConnectionsSeconds) {
175.  
     this.discardIdleConnectionsSeconds = discardIdleConnectionsSeconds;
176.  
     }
177.  
     }

这里配好过后要更改一下上面quartz.properties里面的这个,后面路径写你自己的

1.  
   #数据库连接池，将其设置为druid
2.  
   org.quartz.dataSource.qzDS.connectionProvider.class=com.ruoyi.system.config.DruidConnectionPr

注册调度工厂

1.  
   package com.ruoyi.system.config;
2.  
    
3.  
   import org.quartz.Scheduler;
4.  
   import org.quartz.SchedulerException;
5.  
   import org.springframework.beans.factory.annotation.Autowired;
6.  
   import org.springframework.beans.factory.config.PropertiesFactoryBean;
7.  
   import org.springframework.context.annotation.Bean;
8.  
   import org.springframework.context.annotation.Configuration;
9.  
   import org.springframework.core.io.ClassPathResource;
10.  
    import org.springframework.scheduling.quartz.SchedulerFactoryBean;
11.  
     
12.  
    import java.io.IOException;
13.  
     
14.  
    @Configuration
15.  
    public class QuartzConfig {
16.  
     
17.  
    @Autowired
18.  
    private QuartzJobFactory jobFactory;
19.  
     
20.  
     
21.  
    @Bean
22.  
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
23.  
    //获取配置属性
24.  
    PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
25.  
    propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
26.  
    //在quartz.properties中的属性被读取并注入后再初始化对象
27.  
    propertiesFactoryBean.afterPropertiesSet();
28.  
    //创建SchedulerFactoryBean
29.  
    SchedulerFactoryBean factory = new SchedulerFactoryBean();
30.  
    factory.setQuartzProperties(propertiesFactoryBean.getObject());
31.  
    factory.setJobFactory(jobFactory);//支持在JOB实例中注入其他的业务对象
32.  
    factory.setApplicationContextSchedulerContextKey("applicationContextKey");
33.  
    factory.setWaitForJobsToCompleteOnShutdown(true);//这样当spring关闭时，会等待所有已经启动的quartz job结束后spring才能完全shutdown。
34.  
    factory.setOverwriteExistingJobs(false);//是否覆盖己存在的Job
35.  
    factory.setStartupDelay(10);//QuartzScheduler 延时启动，应用启动完后 QuartzScheduler 再启动
36.  
     
37.  
    return factory;
38.  
    }
39.  
     
40.  
    /**
41.  
    * 通过SchedulerFactoryBean获取Scheduler的实例
42.  
    * @return
43.  
    * @throws IOException
44.  
    * @throws SchedulerException
45.  
    */
46.  
    @Bean(name = "scheduler")
47.  
    public Scheduler scheduler() throws IOException, SchedulerException {
48.  
    Scheduler scheduler = schedulerFactoryBean().getScheduler();
49.  
    return scheduler;
50.  
    }
51.  
    }

注册任务工厂

1.  
    
2.  
   import org.quartz.spi.TriggerFiredBundle;
3.  
   import org.springframework.beans.factory.annotation.Autowired;
4.  
   import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
5.  
   import org.springframework.scheduling.quartz.AdaptableJobFactory;
6.  
   import org.springframework.stereotype.Component;
7.  
    
8.  
   @Component
9.  
   public class QuartzJobFactory extends AdaptableJobFactory {
10.  
     
11.  
    @Autowired
12.  
    private AutowireCapableBeanFactory capableBeanFactory;
13.  
     
14.  
    @Override
15.  
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
16.  
    //调用父类的方法
17.  
    Object jobInstance = super.createJobInstance(bundle);
18.  
    //进行注入
19.  
    capableBeanFactory.autowireBean(jobInstance);
20.  
    return jobInstance;
21.  
    }
22.  
    }

新建一个任务job,你想定时执行的任务

1.  
   package com.ruoyi.system.task;
2.  
    
3.  
   import org.quartz.Job;
4.  
   import org.quartz.JobExecutionContext;
5.  
   import org.quartz.JobExecutionException;
6.  
   import org.slf4j.Logger;
7.  
   import org.slf4j.LoggerFactory;
8.  
    
9.  
   public class Msmjob implements Job {
10.  
     
11.  
    private static final Logger log = LoggerFactory.getLogger(Msmjob.class);
12.  
    @Override
13.  
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
14.  
    System.out.println("您的核酸任务于一个小时候开启,请及时完成核算任务");
15.  
    }
16.  
    }

添加service

1.  
   import java.util.Map;
2.  
    
3.  
    
4.  
   public interface QuartzService {
5.  
    
6.  
   /**
7.  
   * 添加任务可以传参数
8.  
   * @param clazzName
9.  
   * @param jobName
10.  
    * @param groupName
11.  
    * @param cronExp
12.  
    * @param param
13.  
    */
14.  
    void addJob(String clazzName, String jobName, String groupName, String cronExp, Map<String, Object> param);
15.  
     
16.  
    /**
17.  
    * 暂停任务
18.  
    * @param jobName
19.  
    * @param groupName
20.  
    */
21.  
    void pauseJob(String jobName, String groupName);
22.  
     
23.  
    /**
24.  
    * 恢复任务
25.  
    * @param jobName
26.  
    * @param groupName
27.  
    */
28.  
    void resumeJob(String jobName, String groupName);
29.  
     
30.  
    /**
31.  
    * 立即运行一次定时任务
32.  
    * @param jobName
33.  
    * @param groupName
34.  
    */
35.  
    void runOnce(String jobName, String groupName);
36.  
     
37.  
    /**
38.  
    * 更新任务
39.  
    * @param jobName
40.  
    * @param groupName
41.  
    * @param cronExp
42.  
    * @param param
43.  
    */
44.  
    void updateJob(String jobName, String groupName, String cronExp, Map<String, Object> param);
45.  
     
46.  
    /**
47.  
    * 删除任务
48.  
    * @param jobName
49.  
    * @param groupName
50.  
    */
51.  
    void deleteJob(String jobName, String groupName);
52.  
     
53.  
    /**
54.  
    * 启动所有任务
55.  
    */
56.  
    void startAllJobs();
57.  
     
58.  
    /**
59.  
    * 暂停所有任务
60.  
    */
61.  
    void pauseAllJobs();
62.  
     
63.  
    /**
64.  
    * 恢复所有任务
65.  
    */
66.  
    void resumeAllJobs();
67.  
     
68.  
    /**
69.  
    * 关闭所有任务
70.  
    */
71.  
    void shutdownAllJobs();
72.  
     
73.  
    }

添加实现类

1.  
   package com.ruoyi.system.service.impl;
2.  
    
3.  
   import com.alibaba.fastjson.JSONArray;
4.  
   import com.alibaba.fastjson.JSONObject;
5.  
   import com.ruoyi.system.service.QuartzService;
6.  
   import org.quartz.*;
7.  
   import org.quartz.impl.matchers.GroupMatcher;
8.  
   import org.slf4j.Logger;
9.  
   import org.slf4j.LoggerFactory;
10.  
    import org.springframework.beans.factory.annotation.Autowired;
11.  
    import org.springframework.beans.factory.annotation.Qualifier;
12.  
    import org.springframework.jdbc.core.JdbcTemplate;
13.  
    import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
14.  
    import org.springframework.scheduling.quartz.JobDetailFactoryBean;
15.  
    import org.springframework.scheduling.quartz.SchedulerFactoryBean;
16.  
    import org.springframework.stereotype.Service;
17.  
     
18.  
    import javax.sql.DataSource;
19.  
    import java.text.SimpleDateFormat;
20.  
    import java.util.List;
21.  
    import java.util.Map;
22.  
    import java.util.Set;
23.  
     
24.  
    /**
25.  
     
26.  
    */
27.  
    @Service
28.  
    public class QuartzServiceImpl implements QuartzService {
29.  
    private static final Logger log = LoggerFactory.getLogger(QuartzServiceImpl.class);
30.  
     
31.  
    @Autowired
32.  
    private Scheduler scheduler;
33.  
     
34.  
    @Override
35.  
    public void addJob(String clazzName, String jobName, String groupName, String cronExp, Map<String, Object> param) {
36.  
    try {
37.  
    // 启动调度器，默认初始化的时候已经启动
38.  
    // scheduler.start();
39.  
    //构建job信息
40.  
    Class<? extends Job> jobClass = (Class<? extends Job>) Class.forName(clazzName);
41.  
    JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, groupName).build();
42.  
    //表达式调度构建器(即任务执行的时间)
43.  
    CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExp);
44.  
    //按新的cronExpression表达式构建一个新的trigger
45.  
    CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobName, groupName).withSchedule(scheduleBuilder).build();
46.  
    //获得JobDataMap，写入数据
47.  
    if (param != null) {
48.  
    trigger.getJobDataMap().putAll(param);
49.  
    }
50.  
    scheduler.scheduleJob(jobDetail, trigger);
51.  
    } catch (Exception e) {
52.  
    log.error("创建任务失败", e);
53.  
    }
54.  
    }
55.  
     
56.  
    @Override
57.  
    public void pauseJob(String jobName, String groupName) {
58.  
    try {
59.  
    scheduler.pauseJob(JobKey.jobKey(jobName, groupName));
60.  
    } catch (SchedulerException e) {
61.  
    log.error("暂停任务失败", e);
62.  
    }
63.  
    }
64.  
     
65.  
    @Override
66.  
    public void resumeJob(String jobName, String groupName) {
67.  
    try {
68.  
    scheduler.resumeJob(JobKey.jobKey(jobName, groupName));
69.  
    } catch (SchedulerException e) {
70.  
    log.error("恢复任务失败", e);
71.  
    }
72.  
    }
73.  
     
74.  
    @Override
75.  
    public void runOnce(String jobName, String groupName) {
76.  
    try {
77.  
    scheduler.triggerJob(JobKey.jobKey(jobName, groupName));
78.  
    } catch (SchedulerException e) {
79.  
    log.error("立即运行一次定时任务失败", e);
80.  
    }
81.  
    }
82.  
     
83.  
    @Override
84.  
    public void updateJob(String jobName, String groupName, String cronExp, Map<String, Object> param) {
85.  
    try {
86.  
    TriggerKey triggerKey = TriggerKey.triggerKey(jobName, groupName);
87.  
    CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
88.  
    if (cronExp != null) {
89.  
    // 表达式调度构建器
90.  
    CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExp);
91.  
    // 按新的cronExpression表达式重新构建trigger
92.  
    trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
93.  
    }
94.  
    //修改map
95.  
    if (param != null) {
96.  
    trigger.getJobDataMap().putAll(param);
97.  
    }
98.  
    // 按新的trigger重新设置job执行
99.  
    scheduler.rescheduleJob(triggerKey, trigger);
100.  
     } catch (Exception e) {
101.  
     log.error("更新任务失败", e);
102.  
     }
103.  
     }
104.  
      
105.  
     @Override
106.  
     public void deleteJob(String jobName, String groupName) {
107.  
     try {
108.  
     //暂停、移除、删除
109.  
     scheduler.pauseTrigger(TriggerKey.triggerKey(jobName, groupName));
110.  
     scheduler.unscheduleJob(TriggerKey.triggerKey(jobName, groupName));
111.  
     scheduler.deleteJob(JobKey.jobKey(jobName, groupName));
112.  
     } catch (Exception e) {
113.  
     log.error("删除任务失败", e);
114.  
     }
115.  
     }
116.  
      
117.  
     @Override
118.  
     public void startAllJobs() {
119.  
     try {
120.  
     scheduler.start();
121.  
     } catch (Exception e) {
122.  
     log.error("开启所有的任务失败", e);
123.  
     }
124.  
     }
125.  
      
126.  
     @Override
127.  
     public void pauseAllJobs() {
128.  
     try {
129.  
     scheduler.pauseAll();
130.  
     } catch (Exception e) {
131.  
     log.error("暂停所有任务失败", e);
132.  
     }
133.  
     }
134.  
      
135.  
     @Override
136.  
     public void resumeAllJobs() {
137.  
     try {
138.  
     scheduler.resumeAll();
139.  
     } catch (Exception e) {
140.  
     log.error("恢复所有任务失败", e);
141.  
     }
142.  
     }
143.  
      
144.  
     @Override
145.  
     public void shutdownAllJobs() {
146.  
     try {
147.  
      
148.  
     if (!scheduler.isShutdown()) {
149.  
     // 需谨慎操作关闭scheduler容器
150.  
     // scheduler生命周期结束，无法再 start() 启动scheduler
151.  
     scheduler.shutdown(true);
152.  
     }
153.  
     } catch (Exception e) {
154.  
     log.error("关闭所有的任务失败", e);
155.  
     }
156.  
     }
157.  
     }

这里再提供一个 Date类型转换Cron表达式的工具类,这样就能自定义时间了.

1.  
   package com.ruoyi.system.util;
2.  
    
3.  
   import java.text.SimpleDateFormat;
4.  
   import java.util.Date;
5.  
    
6.  
   public class TimeUtil {
7.  
    
8.  
   private static String formatDateByPattern(Date date, String dateFormat){
9.  
   SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
10.  
    String formatTimeStr = null;
11.  
    if (date != null) {
12.  
    formatTimeStr = sdf.format(date);
13.  
    }
14.  
    return formatTimeStr;
15.  
    }
16.  
     
17.  
    /**
18.  
    * Date转为cron表达式
19.  
    * @param date
20.  
    * @return
21.  
    */
22.  
    public static String getCron(java.util.Date date){
23.  
    String dateFormat="ss mm HH dd MM ? yyyy";
24.  
    return formatDateByPattern(date, dateFormat);
25.  
    }
26.  
    }

接下来只需要在你使用的地方注入service调用方法即可

1.  
   @Autowired
2.  
   private QuartzService quartzService;
3.  
    
4.  
    
5.  
    
6.  
    
7.  
   quartzService.addJob(Msmjob.class.getName(),Msmjob.class.getName(),
8.  
   "duanxin", TimeUtil.getCron(hsBuildingTask.getStartTime()),null);

数据库也有了

才疏学浅,有错误欢迎指出