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

SpringBoot整合Quartz 实现分布式定时任务调度_quartz autostartup

作者：繁依Fanyi0 | 2024-08-15 02:58:20

赞

踩

quartz autostartup

一、Quartz 集群架构

Quartz 是 Java 领域最著名的开源任务调度工具。

在上篇文章中，我们详细的介绍了 Quartz 的单体应用实践，如果只在单体环境中应用，Quartz 未必是最好的选择，例如Spring Scheduled一样也可以实现任务调度，并且与SpringBoot无缝集成，支持注解配置，非常简单，但是它有个缺点就是在集群环境下，会导致任务被重复调度！

而与之对应的 Quartz 提供了极为广用的特性，如任务持久化、集群部署和分布式调度任务等等，正因如此，基于 Quartz 任务调度功能在系统开发中应用极为广泛！

在集群环境下，Quartz 集群中的每个节点是一个独立的 Quartz 应用，没有负责集中管理的节点，而是通过数据库表来感知另一个应用，利用数据库锁的方式来实现集群环境下进行并发控制，每个任务当前运行的有效节点有且只有一个！

特别需要注意的是：分布式部署时需要保证各个节点的系统时间一致！

 二、数据表初始化

数据库表结构官网已经提供，我们可以直接访问Quartz对应的官方网站，找到对应的版本，然后将其下载！

 我选择的是quartz-2.3.0-distribution.tar.gz，下载完成之后将其解压，在文件中搜索sql，在里面选择适合当前环境的数据库脚本文件，然后将其初始化到数据库中即可！

例如，我使用的数据库是mysql-5.7，因此我选择的是tables_mysql_innodb.sql脚本，具体内容如下： 

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

具体表描述如下：

 其中，QRTZ_LOCKS 就是 Quartz 集群实现同步机制的行锁表！

三、Quartz 集群实践

3.1、创建springboot项目，导入maven依赖包

  1. <!--引入boot父类-->
  2. <parent>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-parent</artifactId>
  5.     <version>2.1.0.RELEASE</version>
  6. </parent>
  7.  
  8. <!--引入相关包-->
  9. <dependencies>
  10.     <!--spring boot核心-->
  11.     <dependency>
  12.         <groupId>org.springframework.boot</groupId>
  13.         <artifactId>spring-boot-starter</artifactId>
  14.     </dependency>
  15.     <!--spring boot 测试-->
  16.     <dependency>
  17.         <groupId>org.springframework.boot</groupId>
  18.         <artifactId>spring-boot-starter-test</artifactId>
  19.         <scope>test</scope>
  20.     </dependency>
  21.     <!--springmvc web-->
  22.     <dependency>
  23.         <groupId>org.springframework.boot</groupId>
  24.         <artifactId>spring-boot-starter-web</artifactId>
  25.     </dependency>
  26.     <!--开发环境调试-->
  27.     <dependency>
  28.         <groupId>org.springframework.boot</groupId>
  29.         <artifactId>spring-boot-devtools</artifactId>
  30.         <optional>true</optional>
  31.     </dependency>
  32.     <!--jpa 支持-->
  33.     <dependency>
  34.         <groupId>org.springframework.boot</groupId>
  35.         <artifactId>spring-boot-starter-data-jpa</artifactId>
  36.     </dependency>
  37.     <!--mysql 数据源-->
  38.     <dependency>
  39.         <groupId>mysql</groupId>
  40.         <artifactId>mysql-connector-java</artifactId>
  41.     </dependency>
  42.     <!--druid 数据连接池-->
  43.     <dependency>
  44.         <groupId>com.alibaba</groupId>
  45.         <artifactId>druid-spring-boot-starter</artifactId>
  46.         <version>1.1.17</version>
  47.     </dependency>
  48.     <dependency>
  49.         <groupId>org.springframework.boot</groupId>
  50.         <artifactId>spring-boot-starter-quartz</artifactId>
  51.     </dependency>
  52.     <!--Alibaba Json处理包 -->
  53.     <dependency>
  54.         <groupId>com.alibaba</groupId>
  55.         <artifactId>fastjson</artifactId>
  56.         <version>1.2.46</version>
  57.     </dependency>
  58. </dependencies>

3.2、创建 application.properties 配置文件

  1. spring.application.name=springboot-quartz-001
  2. server.port=8080
  3.  
  4. #引入数据源
  5. spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
  6. spring.datasource.username=root
  7. spring.datasource.password=123456
  8. spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

3.3、创建 quartz.properties 配置文件

  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.example.cluster.quartz.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/test-quartz?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
  45. #数据库用户
  46. org.quartz.dataSource.qzDS.user=root
  47. #数据库密码
  48. org.quartz.dataSource.qzDS.password=123456
  49. #允许最大连接
  50. org.quartz.dataSource.qzDS.maxConnection=5
  51. #验证查询sql,可以不设置
  52. org.quartz.dataSource.qzDS.validationQuery=select 0 from dual

3.4、注册 Quartz 任务工厂

  1. @Component
  2. public class QuartzJobFactory extends AdaptableJobFactory {
  3.  
  4.     @Autowired
  5.     private AutowireCapableBeanFactory capableBeanFactory;
  6.  
  7.     @Override
  8.     protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
  9.         //调用父类的方法
  10.         Object jobInstance = super.createJobInstance(bundle);
  11.         //进行注入
  12.         capableBeanFactory.autowireBean(jobInstance);
  13.         return jobInstance;
  14.     }
  15. }

3.5、注册调度工厂

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

3.6、重新设置 Quartz 数据连接池

默认 Quartz 的数据连接池是 c3p0，由于性能不太稳定，不推荐使用，因此我们将其改成driud数据连接池，配置如下：

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

创建完成之后，还需要在quartz.properties配置文件中设置一下即可！

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

如果已经配置，请忽略！

3.7、编写 Job 具体任务类

  1. public class TfCommandJob implements Job {
  2.  
  3.     private static final Logger log = LoggerFactory.getLogger(TfCommandJob.class);
  4.  
  5.     @Override
  6.     public void execute(JobExecutionContext context) {
  7.         try {
  8.             System.out.println(context.getScheduler().getSchedulerInstanceId() + "--" + new SimpleDateFormat("YYYY-MM-dd HH:mm:ss").format(new Date()));
  9.         } catch (SchedulerException e) {
  10.             log.error("任务执行失败",e);
  11.         }
  12.     }
  13. }

3.8、编写 Quartz 服务层接口

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

对应的实现类QuartzJobServiceImpl如下：

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

3.9、编写 contoller 服务

  • 先创建一个请求参数实体类
  1. public class QuartzConfigDTO implements Serializable {
  2.  
  3.  
  4.     private static final long serialVersionUID = 1L;
  5.     /**
  6.      * 任务名称
  7.      */
  8.     private String jobName;
  9.  
  10.     /**
  11.      * 任务所属组
  12.      */
  13.     private String groupName;
  14.  
  15.     /**
  16.      * 任务执行类
  17.      */
  18.     private String jobClass;
  19.  
  20.     /**
  21.      * 任务调度时间表达式
  22.      */
  23.     private String cronExpression;
  24.  
  25.     /**
  26.      * 附加参数
  27.      */
  28.     private Map<String, Object> param;
  29.  
  30.  
  31.     public String getJobName() {
  32.         return jobName;
  33.     }
  34.  
  35.     public QuartzConfigDTO setJobName(String jobName) {
  36.         this.jobName = jobName;
  37.         return this;
  38.     }
  39.  
  40.     public String getGroupName() {
  41.         return groupName;
  42.     }
  43.  
  44.     public QuartzConfigDTO setGroupName(String groupName) {
  45.         this.groupName = groupName;
  46.         return this;
  47.     }
  48.  
  49.     public String getJobClass() {
  50.         return jobClass;
  51.     }
  52.  
  53.     public QuartzConfigDTO setJobClass(String jobClass) {
  54.         this.jobClass = jobClass;
  55.         return this;
  56.     }
  57.  
  58.     public String getCronExpression() {
  59.         return cronExpression;
  60.     }
  61.  
  62.     public QuartzConfigDTO setCronExpression(String cronExpression) {
  63.         this.cronExpression = cronExpression;
  64.         return this;
  65.     }
  66.  
  67.     public Map<String, Object> getParam() {
  68.         return param;
  69.     }
  70.  
  71.     public QuartzConfigDTO setParam(Map<String, Object> param) {
  72.         this.param = param;
  73.         return this;
  74.     }
  75. }
  • 编写 web 服务接口
  1. @RestController
  2. @RequestMapping("/test")
  3. public class TestController {
  4.  
  5.     private static final Logger log = LoggerFactory.getLogger(TestController.class);
  6.  
  7.     @Autowired
  8.     private QuartzJobService quartzJobService;
  9.  
  10.     /**
  11.      * 添加新任务
  12.      * @param configDTO
  13.      * @return
  14.      */
  15.     @RequestMapping("/addJob")
  16.     public Object addJob(@RequestBody QuartzConfigDTO configDTO) {
  17.         quartzJobService.addJob(configDTO.getJobClass(), configDTO.getJobName(), configDTO.getGroupName(), configDTO.getCronExpression(), configDTO.getParam());
  18.         return HttpStatus.OK;
  19.     }
  20.  
  21.     /**
  22.      * 暂停任务
  23.      * @param configDTO
  24.      * @return
  25.      */
  26.     @RequestMapping("/pauseJob")
  27.     public Object pauseJob(@RequestBody QuartzConfigDTO configDTO) {
  28.         quartzJobService.pauseJob(configDTO.getJobName(), configDTO.getGroupName());
  29.         return HttpStatus.OK;
  30.     }
  31.  
  32.     /**
  33.      * 恢复任务
  34.      * @param configDTO
  35.      * @return
  36.      */
  37.     @RequestMapping("/resumeJob")
  38.     public Object resumeJob(@RequestBody QuartzConfigDTO configDTO) {
  39.         quartzJobService.resumeJob(configDTO.getJobName(), configDTO.getGroupName());
  40.         return HttpStatus.OK;
  41.     }
  42.  
  43.     /**
  44.      * 立即运行一次定时任务
  45.      * @param configDTO
  46.      * @return
  47.      */
  48.     @RequestMapping("/runOnce")
  49.     public Object runOnce(@RequestBody QuartzConfigDTO configDTO) {
  50.         quartzJobService.runOnce(configDTO.getJobName(), configDTO.getGroupName());
  51.         return HttpStatus.OK;
  52.     }
  53.  
  54.     /**
  55.      * 更新任务
  56.      * @param configDTO
  57.      * @return
  58.      */
  59.     @RequestMapping("/updateJob")
  60.     public Object updateJob(@RequestBody QuartzConfigDTO configDTO) {
  61.         quartzJobService.updateJob(configDTO.getJobName(), configDTO.getGroupName(), configDTO.getCronExpression(), configDTO.getParam());
  62.         return HttpStatus.OK;
  63.     }
  64.  
  65.     /**
  66.      * 删除任务
  67.      * @param configDTO
  68.      * @return
  69.      */
  70.     @RequestMapping("/deleteJob")
  71.     public Object deleteJob(@RequestBody QuartzConfigDTO configDTO) {
  72.         quartzJobService.deleteJob(configDTO.getJobName(), configDTO.getGroupName());
  73.         return HttpStatus.OK;
  74.     }
  75.  
  76.     /**
  77.      * 启动所有任务
  78.      * @return
  79.      */
  80.     @RequestMapping("/startAllJobs")
  81.     public Object startAllJobs() {
  82.         quartzJobService.startAllJobs();
  83.         return HttpStatus.OK;
  84.     }
  85.  
  86.     /**
  87.      * 暂停所有任务
  88.      * @return
  89.      */
  90.     @RequestMapping("/pauseAllJobs")
  91.     public Object pauseAllJobs() {
  92.         quartzJobService.pauseAllJobs();
  93.         return HttpStatus.OK;
  94.     }
  95.  
  96.     /**
  97.      * 恢复所有任务
  98.      * @return
  99.      */
  100.     @RequestMapping("/resumeAllJobs")
  101.     public Object resumeAllJobs() {
  102.         quartzJobService.resumeAllJobs();
  103.         return HttpStatus.OK;
  104.     }
  105.  
  106.     /**
  107.      * 关闭所有任务
  108.      * @return
  109.      */
  110.     @RequestMapping("/shutdownAllJobs")
  111.     public Object shutdownAllJobs() {
  112.         quartzJobService.shutdownAllJobs();
  113.         return HttpStatus.OK;
  114.     }
  115.  
  116. }

3.10、服务接口测试

运行 SpringBoot 的Application类，启动服务！

 创建一个每5秒钟执行一次的定时任务

 

可以看到服务正常运行！

3.11、注册监听器（选用）

当然，如果你想在 SpringBoot 里面集成 Quartz 的监听器，操作也很简单！

  • 创建任务调度监听器
  1. @Component
  2. public class SimpleSchedulerListener extends SchedulerListenerSupport {
  3.  
  4.     @Override
  5.     public void jobScheduled(Trigger trigger) {
  6.         System.out.println("任务被部署时被执行");
  7.     }
  8.  
  9.     @Override
  10.     public void jobUnscheduled(TriggerKey triggerKey) {
  11.         System.out.println("任务被卸载时被执行");
  12.     }
  13.  
  14.     @Override
  15.     public void triggerFinalized(Trigger trigger) {
  16.         System.out.println("任务完成了它的使命，光荣退休时被执行");
  17.     }
  18.  
  19.     @Override
  20.     public void triggerPaused(TriggerKey triggerKey) {
  21.         System.out.println(triggerKey + "（一个触发器）被暂停时被执行");
  22.     }
  23.  
  24.     @Override
  25.     public void triggersPaused(String triggerGroup) {
  26.         System.out.println(triggerGroup + "所在组的全部触发器被停止时被执行");
  27.     }
  28.  
  29.     @Override
  30.     public void triggerResumed(TriggerKey triggerKey) {
  31.         System.out.println(triggerKey + "（一个触发器）被恢复时被执行");
  32.     }
  33.  
  34.     @Override
  35.     public void triggersResumed(String triggerGroup) {
  36.         System.out.println(triggerGroup + "所在组的全部触发器被回复时被执行");
  37.     }
  38.  
  39.     @Override
  40.     public void jobAdded(JobDetail jobDetail) {
  41.         System.out.println("一个JobDetail被动态添加进来");
  42.     }
  43.  
  44.     @Override
  45.     public void jobDeleted(JobKey jobKey) {
  46.         System.out.println(jobKey + "被删除时被执行");
  47.     }
  48.  
  49.     @Override
  50.     public void jobPaused(JobKey jobKey) {
  51.         System.out.println(jobKey + "被暂停时被执行");
  52.     }
  53.  
  54.     @Override
  55.     public void jobsPaused(String jobGroup) {
  56.         System.out.println(jobGroup + "(一组任务）被暂停时被执行");
  57.     }
  58.  
  59.     @Override
  60.     public void jobResumed(JobKey jobKey) {
  61.         System.out.println(jobKey + "被恢复时被执行");
  62.     }
  63.  
  64.     @Override
  65.     public void jobsResumed(String jobGroup) {
  66.         System.out.println(jobGroup + "(一组任务）被恢复时被执行");
  67.     }
  68.  
  69.     @Override
  70.     public void schedulerError(String msg, SchedulerException cause) {
  71.         System.out.println("出现异常" + msg + "时被执行");
  72.         cause.printStackTrace();
  73.     }
  74.  
  75.     @Override
  76.     public void schedulerInStandbyMode() {
  77.         System.out.println("scheduler被设为standBy等候模式时被执行");
  78.     }
  79.  
  80.     @Override
  81.     public void schedulerStarted() {
  82.         System.out.println("scheduler启动时被执行");
  83.     }
  84.  
  85.     @Override
  86.     public void schedulerStarting() {
  87.         System.out.println("scheduler正在启动时被执行");
  88.     }
  89.  
  90.     @Override
  91.     public void schedulerShutdown() {
  92.         System.out.println("scheduler关闭时被执行");
  93.     }
  94.  
  95.     @Override
  96.     public void schedulerShuttingdown() {
  97.         System.out.println("scheduler正在关闭时被执行");
  98.     }
  99.  
  100.     @Override
  101.     public void schedulingDataCleared() {
  102.         System.out.println("scheduler中所有数据包括jobs, triggers和calendars都被清空时被执行");
  103.     }
  104. }
  • 创建任务触发监听器
  1. @Component
  2. public class SimpleTriggerListener extends TriggerListenerSupport {
  3.  
  4.     /**
  5.      * Trigger监听器的名称
  6.      * @return
  7.      */
  8.     @Override
  9.     public String getName() {
  10.         return "mySimpleTriggerListener";
  11.     }
  12.  
  13.     /**
  14.      * Trigger被激发 它关联的job即将被运行
  15.      * @param trigger
  16.      * @param context
  17.      */
  18.     @Override
  19.     public void triggerFired(Trigger trigger, JobExecutionContext context) {
  20.         System.out.println("myTriggerListener.triggerFired()");
  21.     }
  22.  
  23.     /**
  24.      * Trigger被激发 它关联的job即将被运行, TriggerListener 给了一个选择去否决 Job 的执行,如果返回TRUE 那么任务job会被终止
  25.      * @param trigger
  26.      * @param context
  27.      * @return
  28.      */
  29.     @Override
  30.     public boolean vetoJobExecution(Trigger trigger, JobExecutionContext context) {
  31.         System.out.println("myTriggerListener.vetoJobExecution()");
  32.         return false;
  33.     }
  34.  
  35.     /**
  36.      * 当Trigger错过被激发时执行,比如当前时间有很多触发器都需要执行，但是线程池中的有效线程都在工作，
  37.      * 那么有的触发器就有可能超时，错过这一轮的触发。
  38.      * @param trigger
  39.      */
  40.     @Override
  41.     public void triggerMisfired(Trigger trigger) {
  42.         System.out.println("myTriggerListener.triggerMisfired()");
  43.     }
  44.  
  45.     /**
  46.      * 任务完成时触发
  47.      * @param trigger
  48.      * @param context
  49.      * @param triggerInstructionCode
  50.      */
  51.     @Override
  52.     public void triggerComplete(Trigger trigger, JobExecutionContext context, Trigger.CompletedExecutionInstruction triggerInstructionCode) {
  53.         System.out.println("myTriggerListener.triggerComplete()");
  54.     }
  55. }
  • 创建任务执行监听器
  1. @Component
  2. public class SimpleJobListener extends JobListenerSupport {
  3.  
  4.  
  5.     /**
  6.      * job监听器名称
  7.      * @return
  8.      */
  9.     @Override
  10.     public String getName() {
  11.         return "mySimpleJobListener";
  12.     }
  13.  
  14.     /**
  15.      * 任务被调度前
  16.      * @param context
  17.      */
  18.     @Override
  19.     public void jobToBeExecuted(JobExecutionContext context) {
  20.         System.out.println("simpleJobListener监听器，准备执行："+context.getJobDetail().getKey());
  21.     }
  22.  
  23.     /**
  24.      * 任务调度被拒了
  25.      * @param context
  26.      */
  27.     @Override
  28.     public void jobExecutionVetoed(JobExecutionContext context) {
  29.         System.out.println("simpleJobListener监听器，取消执行："+context.getJobDetail().getKey());
  30.     }
  31.  
  32.     /**
  33.      * 任务被调度后
  34.      * @param context
  35.      * @param jobException
  36.      */
  37.     @Override
  38.     public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) {
  39.         System.out.println("simpleJobListener监听器，执行结束："+context.getJobDetail().getKey());
  40.     }
  41. }
  • 最后，将监听器注册到Scheduler
  1. @Autowired
  2. private SimpleSchedulerListener simpleSchedulerListener;
  3.  
  4. @Autowired
  5. private SimpleJobListener simpleJobListener;
  6.  
  7. @Autowired
  8. private SimpleTriggerListener simpleTriggerListener;
  9.  
  10. @Bean(name = "scheduler")
  11. public Scheduler scheduler() throws IOException, SchedulerException {
  12.     Scheduler scheduler = schedulerFactoryBean().getScheduler();
  13.     //全局添加监听器
  14.     //添加SchedulerListener监听器
  15.     scheduler.getListenerManager().addSchedulerListener(simpleSchedulerListener);
  16.  
  17.     // 添加JobListener, 支持带条件匹配监听器
  18.     scheduler.getListenerManager().addJobListener(simpleJobListener, KeyMatcher.keyEquals(JobKey.jobKey("myJob", "myGroup")));
  19.  
  20.     // 添加triggerListener，设置全局监听
  21.     scheduler.getListenerManager().addTriggerListener(simpleTriggerListener, EverythingMatcher.allTriggers());
  22.     return scheduler;
  23. }

3.12、采用项目数据源（选用）

在上面的 Quartz 数据源配置中，我们使用了自定义的数据源，目的是和项目中的数据源实现解耦，当然有的同学不想单独建库，想和项目中数据源保持一致，配置也很简单！

  • 在quartz.properties配置文件中，去掉org.quartz.jobStore.dataSource配置
  1. #注释掉quartz的数据源配置
  2. #org.quartz.jobStore.dataSource=qzDS
  • 在QuartzConfig配置类中加入dataSource数据源，并将其注入到quartz中
  1. @Autowired
  2. private DataSource dataSource;
  3.  
  4. @Bean
  5. public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
  6.     //...
  7.  
  8.     SchedulerFactoryBean factory = new SchedulerFactoryBean();
  9.     factory.setQuartzProperties(propertiesFactoryBean.getObject());
  10.     //使用数据源，自定义数据源
  11.     factory.setDataSource(dataSource);
  12.     
  13.     //...
  14.     return factory;
  15. }

四、任务调度测试

在实际的部署中，项目都是集群进行部署，因此为了和正式环境一致，我们再新建两个相同的项目来测试一下在集群环境下 quartz 是否可以实现分布式调度，保证任何一个定时任务只有一台机器在运行？

理论上，我们只需要将刚刚新建好的项目，重新复制一份，然后修改一下端口号就可以实现本地测试！

因为curd服务只需要一个，因此我们不需要再编写QuartzJobService等增、删、改服务，仅仅保持QuartzConfig、DruidConnectionProvider、QuartzJobFactory、TfCommandJob、quartz.properties类和配置都是相同的就可以了！

  • 依次启动服务quartz-001、quartz-002、quartz-003，看看效果如何

第一个启动的服务quartz-001会优先加载数据库中已经配置好的定时任务，其他两个服务quartz-002、quartz-003都没有主动调度服务

  • 当我们主动关闭quartz-001，quartz-002服务主动接收任务调度 

  • 当我们主动关闭quartz-002，同样quartz-003服务主动接收任务调度

最终结果，和我们预期效果一致！

五、小结

本文主要围绕springboot + quartz + mysql实现持久化分布式调度进行介绍，所有的代码功能，都测试过。

 

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/981735
推荐阅读
相关标签

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

  

闽ICP备14008679号