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

SpringBoot-集成Quartz实现持久化定时接口调用任务

作者：喵喵爱编程 | 2024-08-15 03:16:44

赞

踩

SpringBoot-集成Quartz实现持久化定时接口调用任务

一、基本概念

Quartz 是功能强大的开源作业调度库，几乎可以集成到任何 Java 应用程序中，从最小的独立应用程序到最大的电子商务系统。Quartz 可用于创建简单或复杂的计划，以执行数以万计的工作；可以执行您编写的所有内容。

Spring Boot 官方也对 Quartz 调度器进行了集成，Spring boot 官网文档：Quartz Scheduler，Java JDK 也带有 计时器 Timer 以及 定时执行服务 ScheduledExecutorService ，Spring 也提供了 @Scheduled 执行定时任务。

如果实际环境中定时任务过多，处理频繁，建议适应第三方封装的调度框架，因为定时器操作底层都是多线程的操作，任务的启动、暂停、恢复、删除、实质是线程的启动、暂停、中断、唤醒等操作。

二、Quartz-scheduler 的核心流程

Scheduler - 调度器

1、Scheduler 用来对 Trigger 和 Job 进行管理，Trigger 和 JobDetail 可以注册到 Scheduler 中，两者在 Scheduler 中都拥有自己的唯一的组(group)和名称(name)用来进行彼此的区分，Scheduler 可以通过任务组和名称来对 Trigger 和 JobDetail 进行管理。

2、每个 Scheduler 都有一个 SchedulerContext，用来保存 Scheduler 的上下文数据，Job 和 Trigger 都可以获取其中的信息。

3、Scheduler 是由 SchedulerFactory 创建，它有两个实现：DirectSchedulerFactory 、StdSchdulerFactory ，前者可以用来在代码里定制 Schduler 参数，后者直接读取 classpath 下的 quartz.properties（不存在就都使用默认值）配置来实例化 Scheduler。

Job - 任务

1、Job 是一个任务接口，开发者可以实现该接口定义自己的任务，JobExecutionContext 中提供了调度上下文的各种信息。

2、Job 中的任务有可能并发执行，例如任务的执行时间过长，而每次触发的时间间隔太短，则会导致任务会被并发执行。如果是并发执行，就需要一个数据库锁去避免一个数据被多次处理。可以在 execute（）方法上添加 @DisallowConcurrentExecution 注解解决这个问题。

JobDetail - 任务详情

1、JobDetail 对象是在将 job 注册到 scheduler 时，由客户端程序创建的，它包含 job 的各种属性设置，以及用于存储 job 实例状态信息的 JobDataMap。

2、JobDetail 由 JobBuilder 创建/定义，Quartz 不存储 Job 的实际实例，但是允许通过使用 JobDetail 定义一个实例。

3、Job 有一个与其关联的名称和组，应该在单个 Scheduler 中唯一标识它们。

4、一个 Trigger(触发器) 只能对应一个 Job（任务），但是一个 Job 可以对应多个 Trigger。JobDetal 与 Trigger 一对多

Trigger - 触发器

1、Trigger 用于触发 Job 的执行。TriggerBuilder 用于定义/构建触发器实例。

2、Trigger也有一个相关联的 JobDataMap，用于给Job传递一些触发相关的参数。

3、Quartz自带了各种不同类型的 Trigger，最常用的主要是SimpleTrigger和CronTrigger。

JobDataMap

1、JobDataMap 实现了 JDK 的 Map 接口，可以以 Key-Value 的形式存储数据。

2、JobDetail、Trigger 实现类中都定义 JobDataMap 成员变量及其 getter、setter 方法，可以用来设置参数信息，Job 执行 execute() 方法的时候，JobExecutionContext 可以获取到 JobDataMap 中的信息。

三、实践

1、新建一个quartz-service服务

添加依赖：

  1. <modelVersion>4.0.0</modelVersion>
  2.  
  3.     <groupId>org.example</groupId>
  4.     <artifactId>quartz-servicer</artifactId>
  5.     <version>1.0.0</version>
  6.  
  7.     <properties>
  8.         <maven.compiler.source>11</maven.compiler.source>
  9.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  10.         <maven.compiler.target>11</maven.compiler.target>
  11.     </properties>
  12.  
  13.     <dependencies>
  14.         <dependency>
  15.             <groupId>org.springframework.boot</groupId>
  16.             <artifactId>spring-boot-starter-web</artifactId>
  17.             <version>2.7.5</version>
  18.         </dependency>
  19.         
  20.         <!-- 公共依赖 -->
  21.         <dependency>
  22.             <groupId>com.alibaba</groupId>
  23.             <artifactId>fastjson</artifactId>
  24.             <version>2.0.19</version>
  25.         </dependency>
  26.  
  27.         <!-- quartz依赖 -->
  28.         <dependency>
  29.             <groupId>org.springframework.boot</groupId>
  30.             <artifactId>spring-boot-starter-quartz</artifactId>
  31.             <version>2.5.4</version>
  32.         </dependency>
  33.         <dependency>
  34.             <groupId>mysql</groupId>
  35.             <artifactId>mysql-connector-java</artifactId>
  36.             <version>8.0.31</version>
  37.         </dependency>
  38.         <dependency>
  39.             <groupId>org.springframework.boot</groupId>
  40.             <artifactId>spring-boot-starter-jdbc</artifactId>
  41.             <version>2.7.3</version>
  42.         </dependency>
  43.  
  44.         <dependency>
  45.             <groupId>com.alibaba</groupId>
  46.             <artifactId>druid-spring-boot-starter</artifactId>
  47.             <version>1.2.14</version>
  48.             <exclusions>
  49.                 <exclusion>
  50.                     <artifactId>spring-boot-autoconfigure</artifactId>
  51.                     <groupId>org.springframework.boot</groupId>
  52.                 </exclusion>
  53.             </exclusions>
  54.         </dependency>
  55.  
  56.     </dependencies>
  57.  
  58.     <build>
  59.         <plugins>
  60.             <plugin>
  61.                 <groupId>org.springframework.boot</groupId>
  62.                 <artifactId>spring-boot-maven-plugin</artifactId>
  63.             </plugin>
  64.         </plugins>
  65.     </build>
  66. 复制代码

2、配置数据源相关链接

quartz需要单据的数据库，所以需要单据创建一个库来给quartz使用，我新建了一个scheduler的库，详细信息官方参考quartz-scheduler/quartz

  1. #1 保存已经触发的触发器状态信息
  2. DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;
  3. #2 存放暂停掉的触发器表表
  4. DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
  5. #3 调度器状态表
  6. DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;
  7. #4 存储程序的悲观锁的信息(假如使用了悲观锁)
  8. DROP TABLE IF EXISTS QRTZ_LOCKS;
  9. #5 简单的触发器表
  10. DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;
  11. #6 存储两种类型的触发器表
  12. DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;
  13. #7 定时触发器表
  14. DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;
  15. #8 以blob 类型存储的触发器
  16. DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;
  17. #9 触发器表
  18. DROP TABLE IF EXISTS QRTZ_TRIGGERS;
  19. #10 job 详细信息表
  20. DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;
  21. #11 日历信息表
  22. DROP TABLE IF EXISTS QRTZ_CALENDARS;
  23.  
  24. #job 详细信息表
  25. CREATE TABLE QRTZ_JOB_DETAILS
  26.   (
  27.     SCHED_NAME VARCHAR(120) NOT NULL,
  28.     JOB_NAME  VARCHAR(200) NOT NULL,
  29.     JOB_GROUP VARCHAR(200) NOT NULL,
  30.     DESCRIPTION VARCHAR(250) NULL,
  31.     JOB_CLASS_NAME   VARCHAR(250) NOT NULL,
  32.     IS_DURABLE VARCHAR(1) NOT NULL,
  33.     IS_NONCONCURRENT VARCHAR(1) NOT NULL,
  34.     IS_UPDATE_DATA VARCHAR(1) NOT NULL,
  35.     REQUESTS_RECOVERY VARCHAR(1) NOT NULL,
  36.     JOB_DATA BLOB NULL,
  37.     PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
  38. );
  39.  
  40. #触发器表
  41. CREATE TABLE QRTZ_TRIGGERS
  42.   (
  43.     SCHED_NAME VARCHAR(120) NOT NULL,
  44.     TRIGGER_NAME VARCHAR(200) NOT NULL,
  45.     TRIGGER_GROUP VARCHAR(200) NOT NULL,
  46.     JOB_NAME  VARCHAR(200) NOT NULL,
  47.     JOB_GROUP VARCHAR(200) NOT NULL,
  48.     DESCRIPTION VARCHAR(250) NULL,
  49.     NEXT_FIRE_TIME BIGINT(13) NULL,
  50.     PREV_FIRE_TIME BIGINT(13) NULL,
  51.     PRIORITY INTEGER NULL,
  52.     TRIGGER_STATE VARCHAR(16) NOT NULL,
  53.     TRIGGER_TYPE VARCHAR(8) NOT NULL,
  54.     START_TIME BIGINT(13) NOT NULL,
  55.     END_TIME BIGINT(13) NULL,
  56.     CALENDAR_NAME VARCHAR(200) NULL,
  57.     MISFIRE_INSTR SMALLINT(2) NULL,
  58.     JOB_DATA BLOB NULL,
  59.     PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
  60.     FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
  61.         REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP)
  62. );
  63.  
  64. #简单的触发器表，包括重复次数，间隔，以及已触发的次数
  65. CREATE TABLE QRTZ_SIMPLE_TRIGGERS
  66.   (
  67.     SCHED_NAME VARCHAR(120) NOT NULL,
  68.     TRIGGER_NAME VARCHAR(200) NOT NULL,
  69.     TRIGGER_GROUP VARCHAR(200) NOT NULL,
  70.     REPEAT_COUNT BIGINT(7) NOT NULL,
  71.     REPEAT_INTERVAL BIGINT(12) NOT NULL,
  72.     TIMES_TRIGGERED BIGINT(10) NOT NULL,
  73.     PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
  74.     FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
  75.         REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
  76. );
  77.  
  78. #定时触发器表，存储 cron trigger，包括 cron 表达式和时区信息
  79. CREATE TABLE QRTZ_CRON_TRIGGERS
  80.   (
  81.     SCHED_NAME VARCHAR(120) NOT NULL,
  82.     TRIGGER_NAME VARCHAR(200) NOT NULL,
  83.     TRIGGER_GROUP VARCHAR(200) NOT NULL,
  84.     CRON_EXPRESSION VARCHAR(200) NOT NULL,
  85.     TIME_ZONE_ID VARCHAR(80),
  86.     PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
  87.     FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
  88.         REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
  89. );
  90.  
  91. #存储calendarintervaltrigger和dailytimeintervaltrigger两种类型的触发器
  92. CREATE TABLE QRTZ_SIMPROP_TRIGGERS
  93.   (
  94.     SCHED_NAME VARCHAR(120) NOT NULL,
  95.     TRIGGER_NAME VARCHAR(200) NOT NULL,
  96.     TRIGGER_GROUP VARCHAR(200) NOT NULL,
  97.     STR_PROP_1 VARCHAR(512) NULL,
  98.     STR_PROP_2 VARCHAR(512) NULL,
  99.     STR_PROP_3 VARCHAR(512) NULL,
  100.     INT_PROP_1 INT NULL,
  101.     INT_PROP_2 INT NULL,
  102.     LONG_PROP_1 BIGINT NULL,
  103.     LONG_PROP_2 BIGINT NULL,
  104.     DEC_PROP_1 NUMERIC(13,4) NULL,
  105.     DEC_PROP_2 NUMERIC(13,4) NULL,
  106.     BOOL_PROP_1 VARCHAR(1) NULL,
  107.     BOOL_PROP_2 VARCHAR(1) NULL,
  108.     PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
  109.     FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
  110.     REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
  111. );
  112.  
  113. #以blob 类型存储的触发器
  114. CREATE TABLE QRTZ_BLOB_TRIGGERS
  115.   (
  116.     SCHED_NAME VARCHAR(120) NOT NULL,
  117.     TRIGGER_NAME VARCHAR(200) NOT NULL,
  118.     TRIGGER_GROUP VARCHAR(200) NOT NULL,
  119.     BLOB_DATA BLOB NULL,
  120.     PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
  121.     FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
  122.         REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
  123. );
  124.  
  125. #日历信息表， quartz可配置一个日历来指定一个时间范围
  126. CREATE TABLE QRTZ_CALENDARS
  127.   (
  128.     SCHED_NAME VARCHAR(120) NOT NULL,
  129.     CALENDAR_NAME  VARCHAR(200) NOT NULL,
  130.     CALENDAR BLOB NOT NULL,
  131.     PRIMARY KEY (SCHED_NAME,CALENDAR_NAME)
  132. );
  133.  
  134. #存放暂停掉的触发器表表
  135. CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS
  136.   (
  137.     SCHED_NAME VARCHAR(120) NOT NULL,
  138.     TRIGGER_GROUP  VARCHAR(200) NOT NULL,
  139.     PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP)
  140. );
  141.  
  142. # 存储与已触发的 trigger 相关的状态信息，以及相联 job 的执行信息
  143. CREATE TABLE QRTZ_FIRED_TRIGGERS
  144.   (
  145.     SCHED_NAME VARCHAR(120) NOT NULL,
  146.     ENTRY_ID VARCHAR(95) NOT NULL,
  147.     TRIGGER_NAME VARCHAR(200) NOT NULL,
  148.     TRIGGER_GROUP VARCHAR(200) NOT NULL,
  149.     INSTANCE_NAME VARCHAR(200) NOT NULL,
  150.     FIRED_TIME BIGINT(13) NOT NULL,
  151.     SCHED_TIME BIGINT(13) NOT NULL,
  152.     PRIORITY INTEGER NOT NULL,
  153.     STATE VARCHAR(16) NOT NULL,
  154.     JOB_NAME VARCHAR(200) NULL,
  155.     JOB_GROUP VARCHAR(200) NULL,
  156.     IS_NONCONCURRENT VARCHAR(1) NULL,
  157.     REQUESTS_RECOVERY VARCHAR(1) NULL,
  158.     PRIMARY KEY (SCHED_NAME,ENTRY_ID)
  159. );
  160.  
  161.  3、 调度器状态表
  162. CREATE TABLE QRTZ_SCHEDULER_STATE
  163.   (
  164.     SCHED_NAME VARCHAR(120) NOT NULL,
  165.     INSTANCE_NAME VARCHAR(200) NOT NULL,
  166.     LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
  167.     CHECKIN_INTERVAL BIGINT(13) NOT NULL,
  168.     PRIMARY KEY (SCHED_NAME,INSTANCE_NAME)
  169. );
  170. 4、 存储程序的悲观锁的信息(假如使用了悲观锁)
  171. CREATE TABLE QRTZ_LOCKS
  172.   (
  173.     SCHED_NAME VARCHAR(120) NOT NULL,
  174.     LOCK_NAME  VARCHAR(40) NOT NULL,
  175.     PRIMARY KEY (SCHED_NAME,LOCK_NAME)
  176. );
  177.  
  178. 复制代码

3、创建配置文件

Quartz 使用一个名为 quartz.properties 的属性文件进行信息配置，必须位于 classpath 下，是 StdSchedulerFactory 用于创建 Scheduler 的默认属性文件。默认情况下 StdSchedulerFactory 从类路径下加载名为 “quartz.properties” 的属性文件，如果失败，则加载 org/quartz 包中的“quartz.properties”文件，因为我需要的是新建一个Scheduler服务，所以直接使用application.yml，配置如下：

  1. datasource:
  2.     url: jdbc:mysql://127.0.0.1:3306/scheduler
  3.     username: ***
  4.     password: ****
  5.     driver-class-name: com.mysql.cj.jdbc.Driver
  6.     type: com.alibaba.druid.pool.DruidDataSource
  7.   #定时配置
  8.   quartz:
  9.     #相关属性配置
  10.     properties:
  11.       org:
  12.         quartz:
  13.           scheduler:
  14.             instanceName: local-scheduler-svc
  15.             instanceId: AUTO
  16.           jobStore:
  17.             #表示 quartz 中的所有数据，比如作业和触发器的信息都保存在内存中（而不是数据库中）
  18.             class: org.springframework.scheduling.quartz.LocalDataSourceJobStore
  19.             # 驱动配置
  20.             driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
  21.             # 表前缀
  22.             tablePrefix: QRTZ_
  23.             #是否为集群
  24.             isClustered: false
  25.             clusterCheckinInterval: 10000
  26.             useProperties: false
  27.             dataSource: quartzDs
  28.           #线程池配置
  29.           threadPool:
  30.             class: org.quartz.simpl.SimpleThreadPool
  31.             #线程数
  32.             threadCount: 10
  33.             #优先级
  34.             threadPriority: 5
  35.             #线程继承上下文类加载器的初始化线程
  36.             threadsInheritContextClassLoaderOfInitializingThread: true
  37.     #数据库方式
  38.     job-store-type: JDBC
  39.     #初始化表结构
  40.     jdbc:
  41.       initialize-schema: NEVER
  42.  
  43. 复制代码

4、新建一个任务实体类JobInfo，用户新建，传递任务信息

jobName：任务名称

jobGroup：任务组

jsonParams：任务执行信息（在用户定时远程调用接口的时候，我们可以接口信息封装到这个Map中）

cron：定时任务的cron表达式

timeZoneId：定制执行任务的时区

triggerTime：定时器时间（目前没用上）

  1. @Data
  2. public class JobInfo {
  3.  
  4.     private String jobName;
  5.  
  6.     private String jobGroup;
  7.  
  8.     private Map<String, Object> jsonParams;
  9.  
  10.     private String cron;
  11.  
  12.     private String timeZoneId;
  13.  
  14.     private Date triggerTime; 
  15. }
  16. 复制代码

5、新建一个任务执行类HttpRemoteJob 实现 Job接口，重写execute()方法

execute()里面就是任务的逻辑：

① 使用HttpURLConnection发送网络请求，利用BufferedReader接收请求返回的结果

② 在任务的Description中取出定时请求的接口信息，解析Description,获取请求url

③ 编辑请求信息，通过URL类编辑请求信息，使用HttpURLConnection发送请求，并接收请求返回的状态码，根据状态码，判断是否请求成功，请求成功便通过BufferedReader读取响应信息，返回请求结果

  1. import com.alibaba.fastjson.JSONObject;
  2. import org.quartz.DisallowConcurrentExecution;
  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. import org.springframework.util.StringUtils;
  9.  
  10. import java.io.BufferedReader;
  11. import java.io.InputStreamReader;
  12. import java.net.HttpURLConnection;
  13. import java.net.URL;
  14. import java.util.Objects;
  15.  
  16. @DisallowConcurrentExecution
  17. public class HttpRemoteJob implements Job {
  18.    //日志
  19.     private static final Logger log = LoggerFactory.getLogger(HttpRemoteJob.class);
  20.  
  21.    @Override
  22.     public void execute(JobExecutionContext context)throws JobExecutionException {
  23.       //用于发送网络请求
  24.       HttpURLConnection connection = null;
  25.       //用于接收请求返回的结果
  26.       BufferedReader bufferedReader = null;
  27.       //获取任务Description述,之前我们把接口请求的信息放在Description里面了
  28.       String jsonParams = context.getJobDetail().getDescription();
  29.       if (StringUtils.isEmpty(jsonParams)){
  30.          return;
  31.       }
  32.       //解析Description,获取请求url
  33.       JSONObject jsonObj= (JSONObject) JSONObject.parse(jsonParams);
  34.       String callUrl = jsonObj.getString("callUrl");
  35.       if(StringUtils.isEmpty(callUrl)) {
  36.          return;
  37.       }
  38.  
  39.       try {
  40.          //编辑请求信息
  41.          URL realUrl = new URL(callUrl);
  42.          connection = (HttpURLConnection) realUrl.openConnection();
  43.  
  44.          connection.setRequestMethod("GET");
  45.          connection.setDoOutput(true);
  46.          connection.setDoInput(true);
  47.          connection.setUseCaches(false);
  48.          connection.setReadTimeout(5 * 1000);
  49.          connection.setConnectTimeout(3 * 1000);
  50.          connection.setRequestProperty("connection", "Keep-Alive");
  51.          connection.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
  52.          connection.setRequestProperty("Accept-Charset", "application/json;charset=UTF-8");
  53.          //发送请求
  54.          connection.connect();
  55.  
  56.          //获取请求返回的状态吗
  57.          int statusCode = connection.getResponseCode();
  58.          if (statusCode != 200){
  59.             //请求失败抛出异常
  60.             throw new RuntimeException("Http Request StatusCode(" + statusCode + ") Invalid.");
  61.          }
  62.          //如果返回值正常，数据在网络中是以流的形式得到服务端返回的数据
  63.          bufferedReader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
  64.          StringBuilder stringBuilder = new StringBuilder();
  65.          String line;
  66.          // 从流中读取响应信息
  67.          while ((line = bufferedReader.readLine()) != null) {
  68.             stringBuilder.append(line);
  69.          }
  70.          String responseMsg = stringBuilder.toString();
  71.          log.info(responseMsg);
  72.  
  73.       } catch (Exception e) {
  74.          log.error(e.getMessage());
  75.       } finally {
  76.          //关闭流与请求连接
  77.          try {
  78.             if (Objects.nonNull(bufferedReader)){
  79.                bufferedReader.close();
  80.             }
  81.             if (Objects.nonNull(connection)){
  82.                connection.disconnect();
  83.             }
  84.          } catch (Exception e) {
  85.             log.error(e.getMessage());
  86.          }
  87.       }
  88.    }
  89.  
  90. }
  91. 复制代码

@DisallowConcurrentExecution 的作用：

Quartz定时任务默认是并发执行的，不会等待上一次任务执行完毕，只要有间隔时间到就会执行, 如果定时任执行太长，会长时间占用资源，导致其它任务堵塞。@DisallowConcurrentExecution 这个注解是加在Job类上的，是禁止并发执行多个相同定义的JobDetail, , 但并不是不能同时执行多个Job, 而是不能并发执行同一个Job Definition(由JobDetail定义), 但是可以同时执行多个不同的JobDetail。

JobExecutionContext 类可以获取很多任务的信息：

  1.     @Override
  2.     public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
  3.         JobKey jobKey = jobExecutionContext.getJobDetail().getKey();
  4.         //工作任务名称
  5.         String jobName = jobKey.getName();
  6.         //工作任务组名称
  7.         String groupName = jobKey.getGroup();
  8.         //任务类名称(带路径)
  9.         String classPathName = jobExecutionContext.getJobDetail().getJobClass().getName();
  10.         //任务类名称
  11.         String className = jobExecutionContext.getJobDetail().getJobClass().getSimpleName();
  12.         //获取Trigger内容
  13.         TriggerKey triggerKey = jobExecutionContext.getTrigger().getKey();
  14.         //触发器名称
  15.         String triggerName = triggerKey.getName();
  16.         //出发组名称(带路径)
  17.         String triggerPathName = jobExecutionContext.getTrigger().getClass().getName();
  18.         //触发器类名称
  19.         String triggerClassName = jobExecutionContext.getTrigger().getClass().getSimpleName();
  20.     }
  21.  
  22. 复制代码

注意：

  1.       //解析Description,获取请求url
  2.       JSONObject jsonObj= (JSONObject) JSONObject.parse(jsonParams);
  3.       String callUrl = jsonObj.getString("callUrl");
  4. 复制代码

之前我们封装JobInfo信息是将Map<String, Object> jsonParams保存接口请求信息，们去解析接口请求的时候也要用callUrl去取，那么在封装JobInfo类时，Map中就需要指定key是callUrl，不然取不到就会报错了。

6、创建定时任务业务层，创建 JobService接口和 JobServiceImpl实现类

JobServiceImpl业务逻辑：

JobInfo携带这我们需要新建任务的信息

① 通过jobName和jobGroup可以查询到任务唯一的jobKey，通过getJobDetail（jobKey），判断是否已有这个任务，有的话先删除在新增这个任务

② 新建一个任务JobDetail，withDescription属性中是指任务描述，JobInfo类中JsonParams属性是一个Map，这里需要将Map格式化一下，不然无法赋给withDescription，这个JsonUtils在下面：

  1.         //任务详情
  2.         JobDetail jobDetail = JobBuilder.newJob(HttpRemoteJob.class)
  3.                 .withDescription(JsonUtils.object2Json(jobInfo.getJsonParams()))  //任务描述
  4.                 .withIdentity(jobKey) //指定任务
  5.                 .build();
  6. 复制代码

③ 创建触发器，触发器有多种类型，需要定时执行就使用cron表达式，创建cron调度器建造器CronScheduleBuilder，再创建Trigger触发器，调度器建造器有很多种，除了我下面用到的简单调度器构造器SimpleTrigger，还有：

CalendarIntervalScheduleBuilder ： 每隔一段时间执行一次(年月日)

DailyTimeIntervalScheduleBuilder : 设置年月日中的某些固定日期，可以设置执行总次数

以后我们再单独写一片介绍；

CronScheduleBuilder和SimpleTrigger的区别在于：CronScheduleBuilder是通过cron表达式定时某个时间点或多个时间点定时直接，而SimpleTrigger是周期性执行，着重与时间间隔，着重与周期执行；

④ 将任务添加到Scheduler中

此外还有一些Scheduler的其他方法：

获取任务触发器 ：TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);

停止触发器 ：scheduler.pauseTrigger(triggerKey);

移除触发器：scheduler.unscheduleJob(triggerKey);

删除任务：scheduler.deleteJob(JobKey.jobKey(jobName,jobGroup));

根据jobName,jobGroup获取jobKey 恢复任务：scheduler.resumeJob(JobKey.jobKey(jobName,jobGroup));

根据jobName,jobGroup获取jobKey 暂停任务： scheduler.pauseJob(JobKey.jobKey(jobName,jobGroup));

根据jobName,jobGroup获取jobKey 立即执行任务： scheduler.triggerJob(JobKey.jobKey(jobName,jobGroup));

在下面的实现类代码中有很好的用例;

JsonUtils工具类

  1. public class JsonUtils {
  2.  
  3.     public static final ObjectMapper OBJECT_MAPPER = createObjectMapper();
  4.  
  5.     private static final ObjectMapper IGNORE_OBJECT_MAPPER = createIgnoreObjectMapper();
  6.  
  7.     private static ObjectMapper createIgnoreObjectMapper() {
  8.         ObjectMapper objectMapper = createObjectMapper();
  9.         objectMapper.addMixIn(Object.class, DynamicMixIn.class);
  10.         return objectMapper;
  11.     }
  12.  
  13.     public static ObjectMapper createObjectMapper() {
  14.         ObjectMapper objectMapper = new ObjectMapper();
  15.         objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
  16.         objectMapper.configure(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT, true);
  17.         objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
  18.         objectMapper.configure(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS, true);
  19.         objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
  20.         objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
  21.         objectMapper.registerModule(new JavaTimeModule());
  22.         return objectMapper;
  23.     }
  24.  
  25.     public static String object2Json(Object o) {
  26.         StringWriter sw = new StringWriter();
  27.         JsonGenerator gen = null;
  28.         try {
  29.             gen = new JsonFactory().createGenerator(sw);
  30.             OBJECT_MAPPER.writeValue(gen, o);
  31.         } catch (IOException e) {
  32.             throw new RuntimeException("Cannot serialize object as JSON", e);
  33.         } finally {
  34.             if (null != gen) {
  35.                 try {
  36.                     gen.close();
  37.                 } catch (IOException e) {
  38.                     throw new RuntimeException("Cannot serialize object as JSON", e);
  39.                 }
  40.             }
  41.         }
  42.         return sw.toString();
  43.     }
  44. }
  45. 复制代码

JobService接口

  1. import liu.qingxu.domain.JobInfo;
  2. import org.springframework.web.bind.annotation.RequestBody;
  3.  
  4. /**
  5.  * @module
  6.  * @author: qingxu.liu
  7.  * @date: 2022-11-15 14:37
  8.  * @copyright
  9.  **/
  10. public interface JobService {
  11.  
  12.     /**
  13.      * 新建一个定时任务
  14.      * @param jobInfo 任务信息
  15.      * @return 任务信息
  16.      */
  17.     JobInfo save(@RequestBody JobInfo jobInfo);
  18.  
  19.     /**
  20.      * 新建一个简单定时任务
  21.      * @param jobInfo 任务信息
  22.      * @return 任务信息
  23.      */
  24.     JobInfo simpleSave(@RequestBody JobInfo jobInfo);
  25.  
  26.     /**
  27.      * 删除任务
  28.      * @param jobName 任务名称
  29.      * @param jobGroup 任务组
  30.      */
  31.     void remove( String jobName,String jobGroup);
  32.  
  33.     /**
  34.      * 恢复任务
  35.      * @param jobName 任务名称
  36.      * @param jobGroup 任务组
  37.      */
  38.     void resume(String jobName,  String jobGroup);
  39.  
  40.     /**
  41.      * 暂停任务
  42.      * @param jobName 任务名称
  43.      * @param jobGroup 任务组
  44.      */
  45.     void pause(String jobName,  String jobGroup);
  46.  
  47.     /**
  48.      * 立即执行任务一主要是用于执行一次任务的场景
  49.      * @param jobName 任务名称
  50.      * @param jobGroup 任务组
  51.      */
  52.     void trigger(String jobName,  String jobGroup);
  53. }
  54.  
  55. 复制代码

JobServiceImpl实现类

  1. import liu.qingxu.domain.JobInfo;
  2. import liu.qingxu.executors.HttpRemoteJob;
  3. import liu.qingxu.service.JobService;
  4. import liu.qingxu.utils.JsonUtils;
  5. import org.quartz.CronScheduleBuilder;
  6. import org.quartz.JobBuilder;
  7. import org.quartz.JobDetail;
  8. import org.quartz.JobKey;
  9. import org.quartz.Scheduler;
  10. import org.quartz.SchedulerException;
  11. import org.quartz.SimpleTrigger;
  12. import org.quartz.Trigger;
  13. import org.quartz.TriggerBuilder;
  14. import org.quartz.TriggerKey;
  15. import org.springframework.beans.factory.annotation.Autowired;
  16. import org.springframework.stereotype.Service;
  17.  
  18. import java.util.Objects;
  19. import java.util.TimeZone;
  20.  
  21. /**
  22.  * @module
  23.  * @author: qingxu.liu
  24.  * @date: 2022-11-15 14:48
  25.  * @copyright
  26.  **/
  27. @Service
  28. public class JobServiceImpl implements JobService {
  29.  
  30.     @Autowired
  31.     private Scheduler scheduler;
  32.  
  33.     @Override
  34.     public JobInfo save(JobInfo jobInfo) {
  35.         //查询是否已有相同任务 jobKey可以唯一确定一个任务
  36.         JobKey jobKey = JobKey.jobKey(jobInfo.getJobName(), jobInfo.getJobGroup());
  37.         try {
  38.             JobDetail jobDetail = scheduler.getJobDetail(jobKey);
  39.             if (Objects.nonNull(jobDetail)){
  40.                 scheduler.deleteJob(jobKey);
  41.             }
  42.         } catch (SchedulerException e) {
  43.             e.printStackTrace();
  44.         }
  45.  
  46.         //任务详情
  47.         JobDetail jobDetail = JobBuilder.newJob(HttpRemoteJob.class)
  48.                 .withDescription(JsonUtils.object2Json(jobInfo.getJsonParams()))  //任务描述
  49.                 .withIdentity(jobKey) //指定任务
  50.                 .build();
  51.         //根据cron,TimeZone时区,指定执行计划
  52.         CronScheduleBuilder builder = CronScheduleBuilder.cronSchedule(jobInfo.getCron())
  53.                 .inTimeZone(TimeZone.getTimeZone(jobInfo.getTimeZoneId()));
  54.  
  55.         //触发器
  56.         Trigger trigger = TriggerBuilder.newTrigger()
  57.                 .withIdentity(jobInfo.getJobName(), jobInfo.getJobGroup()).startNow()
  58.                 .withSchedule(builder)
  59.                 .build();
  60.  
  61.         //添加任务
  62.         try {
  63.             scheduler.scheduleJob(jobDetail, trigger);
  64.         } catch (SchedulerException e) {
  65.             System.out.println(e.getMessage());
  66.         }
  67.         return jobInfo;
  68.     }
  69.  
  70.     @Override
  71.     public JobInfo simpleSave(JobInfo jobInfo) {
  72.         JobKey jobKey = JobKey.jobKey(jobInfo.getJobName(), jobInfo.getJobGroup());  //作业名称及其组名
  73.         //判断是否有相同的作业
  74.         try {
  75.             JobDetail jobDetail = scheduler.getJobDetail(jobKey);
  76.             if(jobDetail != null){
  77.                 scheduler.deleteJob(jobKey);
  78.             }
  79.         } catch (SchedulerException e) {
  80.             e.printStackTrace();
  81.         }
  82.         //定义作业的详细信息,并设置要执行的作业类名,设置作业名称及其组名
  83.         JobDetail jobDetail = JobBuilder.newJob(HttpRemoteJob.class)
  84.                 .withDescription(JsonUtils.object2Json(jobInfo.getJsonParams()))
  85.                 .withIdentity(jobKey)
  86.                 .build()
  87.                 ;
  88.         //简单触发器,着重与时间间隔
  89.         SimpleTrigger trigger = (SimpleTrigger) TriggerBuilder.newTrigger()
  90.                 .withIdentity(jobInfo.getJobName(), jobInfo.getJobGroup())
  91.                 .startAt(jobInfo.getTriggerTime())
  92.                 .build();
  93.  
  94.         try {
  95.             scheduler.scheduleJob(jobDetail, trigger);
  96.         } catch (SchedulerException e) {
  97.             System.out.println(e.getMessage());
  98.         }
  99.  
  100.         return jobInfo;
  101.     }
  102.  
  103.     @Override
  104.     public void remove(String jobName, String jobGroup) {
  105.         //获取任务触发器
  106.         TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
  107.         try {
  108.             //停止触发器
  109.             scheduler.pauseTrigger(triggerKey);
  110.             //移除触发器
  111.             scheduler.unscheduleJob(triggerKey);
  112.             //删除任务
  113.             scheduler.deleteJob(JobKey.jobKey(jobName,jobGroup));
  114.         } catch (SchedulerException e) {
  115.             System.out.println(e.getMessage());
  116.         }
  117.     }
  118.  
  119.     @Override
  120.     public void resume(String jobName, String jobGroup) {
  121.         try {
  122.             //根据jobName,jobGroup获取jobKey 恢复任务
  123.             scheduler.resumeJob(JobKey.jobKey(jobName,jobGroup));
  124.         } catch (SchedulerException e) {
  125.             System.out.println(e.getMessage());
  126.         }
  127.     }
  128.  
  129.     @Override
  130.     public void pause(String jobName, String jobGroup) {
  131.         try {
  132.             //根据jobName,jobGroup获取jobKey 暂停任务
  133.             scheduler.pauseJob(JobKey.jobKey(jobName,jobGroup));
  134.         } catch (SchedulerException e) {
  135.             System.out.println(e.getMessage());
  136.         }
  137.     }
  138.  
  139.     @Override
  140.     public void trigger(String jobName, String jobGroup) {
  141.         try {
  142.             //根据jobName,jobGroup获取jobKey 立即执行任务
  143.             scheduler.triggerJob(JobKey.jobKey(jobName,jobGroup));
  144.         } catch (SchedulerException e) {
  145.             System.out.println(e.getMessage());
  146.         }
  147.     }
  148. }
  149. 复制代码

到此为止，我的定时调用接口任务已经完成了，现在我们写个Controller来试着调用一下：

我们调用test接口，新建一个任务，让任务每隔5秒调用runTest接口，然后在调用deleteTest接口删除任务；

  1. @RestController
  2. @RequestMapping("/quartz/job")
  3. public class QuartzController {
  4.  
  5.     private  final  JobService jobService;
  6.     public QuartzController(JobService jobService) {
  7.         this.jobService = jobService;
  8.     }
  9.  
  10.     @GetMapping("/test")
  11.     public void test(){
  12.         JobInfo jobInfo = new JobInfo();
  13.         jobInfo.setJobName("test-job");
  14.         jobInfo.setJobGroup("test");
  15.         jobInfo.setTimeZoneId("Asia/Shanghai");  //时区指定上海
  16.         jobInfo.setCron("0/5 * * * * ? ");  //每5秒执行一次
  17.         Map<String, Object> params = new HashMap<>();
  18.         //添加需要调用的接口信息
  19.         String callUrl = "http://127.0.0.1:8080/quartz/job/test/run";
  20.         params.put("callUrl", callUrl);
  21.         jobInfo.setJsonParams(params);
  22.         jobService.save(jobInfo);
  23.     }
  24.  
  25.  
  26.     @GetMapping("/test/run")
  27.     public void runTest(){
  28.         System.out.println(new Date());
  29.     }
  30.  
  31.     @GetMapping("/test/delete")
  32.     public void deleteTest(){
  33.         jobService.remove("test-job","test");
  34.         System.out.println("任务已删除");
  35.     }
  36. }
  37. 复制代码

四、验证结果

可以看到runTest接口每隔5秒就被任务调用了一个，这时候我们去看数据库中的scheduler库的QRTZ_JOB_DETAILS表和QRTZ_TRIGGERS表，可以看到我们我们定时任务的信息，表示我们的定时任务持久化成功，这个时候你关掉服务器，再重启任务也会定时去执行runTest接口；

然后我们再调用deleteTest接口删除任务

此时再看去看数据库中的scheduler库的QRTZ_JOB_DETAILS表和QRTZ_TRIGGERS表中就没有之前的任务数据了

end~~~

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

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

  

闽ICP备14008679号