devbox
天景科技苑
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringBoot 整合 Quartz_springboot整合quartz

作者：天景科技苑 | 2024-08-15 03:27:10

赞

踩

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>

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

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

数据库也有了

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

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号