SpringBoot 整合Quartz快速入门

前言

        本文不讲太多的理论，主要记录学习中如何快速上手使用方法！！！

什么是Quartz？

        Quartz 是基于 Java 实现的任务调度框架，是一款功能强大的免费开源的定时任务调度的框架。

        中文文档：Quartz快速入门指南_w3cschool

 Quartz API的关键接口

• Scheduler - 与调度程序交互的主要API。
• Job - 你想要调度器执行的任务组件需要实现的接口
• JobDetail - 用于定义作业的实例。
• Trigger（即触发器） - 定义执行给定作业的计划的组件。
• JobBuilder - 用于定义/构建 JobDetail 实例，用于定义作业的实例。
• TriggerBuilder - 用于定义/构建触发器实例。

        Scheduler 的生命期，从 SchedulerFactory 创建它时开始，到 Scheduler 调用shutdown() 方法时结束；Scheduler 被创建后，可以增加、删除和列举 Job 和 Trigger，以及执行其它与调度相关的操作（如暂停 Trigger）。但是，Scheduler 只有在调用 start() 方法后，才会真正地触发 trigger（即执行 job）。

代码示例

1.创建数据库

-- QUARTZ_TABLE
DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;
DROP TABLE IF EXISTS QRTZ_LOCKS;
DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;
DROP TABLE IF EXISTS QRTZ_CALENDARS;
 
--  quartz自带表结构
 
CREATE TABLE QRTZ_JOB_DETAILS(
SCHED_NAME VARCHAR(120) NOT NULL,
JOB_NAME VARCHAR(200) NOT NULL,
JOB_GROUP VARCHAR(200) NOT NULL,
DESCRIPTION VARCHAR(250) NULL,
JOB_CLASS_NAME VARCHAR(250) NOT NULL,
IS_DURABLE VARCHAR(1) NOT NULL,
IS_NONCONCURRENT VARCHAR(1) NOT NULL,
IS_UPDATE_DATA VARCHAR(1) NOT NULL,
REQUESTS_RECOVERY VARCHAR(1) NOT NULL,
JOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP))
ENGINE=InnoDB;
 
CREATE TABLE QRTZ_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
JOB_NAME VARCHAR(200) NOT NULL,
JOB_GROUP VARCHAR(200) NOT NULL,
DESCRIPTION VARCHAR(250) NULL,
NEXT_FIRE_TIME BIGINT(13) NULL,
PREV_FIRE_TIME BIGINT(13) NULL,
PRIORITY INTEGER NULL,
TRIGGER_STATE VARCHAR(16) NOT NULL,
TRIGGER_TYPE VARCHAR(8) NOT NULL,
START_TIME BIGINT(13) NOT NULL,
END_TIME BIGINT(13) NULL,
CALENDAR_NAME VARCHAR(200) NULL,
MISFIRE_INSTR SMALLINT(2) NULL,
JOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP))
ENGINE=InnoDB;
 
CREATE TABLE QRTZ_SIMPLE_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
REPEAT_COUNT BIGINT(7) NOT NULL,
REPEAT_INTERVAL BIGINT(12) NOT NULL,
TIMES_TRIGGERED BIGINT(10) NOT NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;
 
CREATE TABLE QRTZ_CRON_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
CRON_EXPRESSION VARCHAR(120) NOT NULL,
TIME_ZONE_ID VARCHAR(80),
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;
 
CREATE TABLE QRTZ_SIMPROP_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    STR_PROP_1 VARCHAR(512) NULL,
    STR_PROP_2 VARCHAR(512) NULL,
    STR_PROP_3 VARCHAR(512) NULL,
    INT_PROP_1 INT NULL,
    INT_PROP_2 INT NULL,
    LONG_PROP_1 BIGINT NULL,
    LONG_PROP_2 BIGINT NULL,
    DEC_PROP_1 NUMERIC(13,4) NULL,
    DEC_PROP_2 NUMERIC(13,4) NULL,
    BOOL_PROP_1 VARCHAR(1) NULL,
    BOOL_PROP_2 VARCHAR(1) NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;
 
CREATE TABLE QRTZ_BLOB_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
BLOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
INDEX (SCHED_NAME,TRIGGER_NAME, TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;
 
CREATE TABLE QRTZ_CALENDARS (
SCHED_NAME VARCHAR(120) NOT NULL,
CALENDAR_NAME VARCHAR(200) NOT NULL,
CALENDAR BLOB NOT NULL,
PRIMARY KEY (SCHED_NAME,CALENDAR_NAME))
ENGINE=InnoDB;
 
CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;
 
CREATE TABLE QRTZ_FIRED_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
ENTRY_ID VARCHAR(95) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
INSTANCE_NAME VARCHAR(200) NOT NULL,
FIRED_TIME BIGINT(13) NOT NULL,
SCHED_TIME BIGINT(13) NOT NULL,
PRIORITY INTEGER NOT NULL,
STATE VARCHAR(16) NOT NULL,
JOB_NAME VARCHAR(200) NULL,
JOB_GROUP VARCHAR(200) NULL,
IS_NONCONCURRENT VARCHAR(1) NULL,
REQUESTS_RECOVERY VARCHAR(1) NULL,
PRIMARY KEY (SCHED_NAME,ENTRY_ID))
ENGINE=InnoDB;
 
CREATE TABLE QRTZ_SCHEDULER_STATE (
SCHED_NAME VARCHAR(120) NOT NULL,
INSTANCE_NAME VARCHAR(200) NOT NULL,
LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
CHECKIN_INTERVAL BIGINT(13) NOT NULL,
PRIMARY KEY (SCHED_NAME,INSTANCE_NAME))
ENGINE=InnoDB;
 
CREATE TABLE QRTZ_LOCKS (
SCHED_NAME VARCHAR(120) NOT NULL,
LOCK_NAME VARCHAR(40) NOT NULL,
PRIMARY KEY (SCHED_NAME,LOCK_NAME))
ENGINE=InnoDB;
 
CREATE INDEX IDX_QRTZ_J_REQ_RECOVERY ON QRTZ_JOB_DETAILS(SCHED_NAME,REQUESTS_RECOVERY);
CREATE INDEX IDX_QRTZ_J_GRP ON QRTZ_JOB_DETAILS(SCHED_NAME,JOB_GROUP);
 
CREATE INDEX IDX_QRTZ_T_J ON QRTZ_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_JG ON QRTZ_TRIGGERS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_C ON QRTZ_TRIGGERS(SCHED_NAME,CALENDAR_NAME);
CREATE INDEX IDX_QRTZ_T_G ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);
CREATE INDEX IDX_QRTZ_T_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_N_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_N_G_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_NEXT_FIRE_TIME ON QRTZ_TRIGGERS(SCHED_NAME,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_ST ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE_GRP ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_GROUP,TRIGGER_STATE);
 
CREATE INDEX IDX_QRTZ_FT_TRIG_INST_NAME ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME);
CREATE INDEX IDX_QRTZ_FT_INST_JOB_REQ_RCVRY ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME,REQUESTS_RECOVERY);
CREATE INDEX IDX_QRTZ_FT_J_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_FT_JG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_FT_T_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP);
CREATE INDEX IDX_QRTZ_FT_TG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);
 
 
 
-- 定时任务
DROP TABLE IF EXISTS schedule_job;
 
CREATE TABLE schedule_job(
 
 ID BIGINT (50) NOT NULL AUTO_INCREMENT COMMENT '任务id',
 JOB_NAME VARCHAR (100) NOT NULL COMMENT '任务名称',
 JOB_GROUP VARCHAR (100) NOT NULL COMMENT '任务分组',
 DESCRIPTION VARCHAR (100) NOT NULL COMMENT '任务描述',
 cron_expression VARCHAR (200) NOT NULL COMMENT 'cron表达式',
 TASK_STATUS VARCHAR (20) NOT NULL COMMENT '任务状态',
 REQUEST_TYPE VARCHAR (50) NOT NULL COMMENT '请求类型{GET或POST请求}',
 HTTP_URL VARCHAR (256) NOT NULL COMMENT '请求url',
 HTTP_PARAMS VARCHAR (20000) COMMENT '请求参数',
 CREATE_TIME datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
 UPDATE_TIME datetime COMMENT '修改时间',
 PRIMARY KEY (ID)
 
) ENGINE = INNODB DEFAULT CHARSET = utf8 COMMENT = '定时任务';
 
 
 
--  定时任务日志
DROP TABLE IF EXISTS schedule_job_log;
 
CREATE TABLE schedule_job_log(
 
ID BIGINT (50) NOT NULL AUTO_INCREMENT COMMENT '日志id',
JOB_ID BIGINT (100) NOT NULL COMMENT '任务id',
JOB_NAME VARCHAR (100) NOT NULL COMMENT '任务名称',
JOB_GROUP VARCHAR (100) NOT NULL COMMENT '任务分组',
DESCRIPTION VARCHAR (100) COMMENT '任务描述',
cron_expression VARCHAR (100) NOT NULL COMMENT 'cron表达式',
TASK_STATUS VARCHAR (20) NOT NULL COMMENT '任务状态 0：成功,1：失败',
REQUEST_TYPE VARCHAR (50) NOT NULL COMMENT '请求类型',
HTTP_URL VARCHAR (256) NOT NULL COMMENT '请求url',
HTTP_PARAMS VARCHAR (20000) COMMENT '请求参数',
times INT (11) COMMENT '耗时(单位：毫秒)',
CREATE_TIME datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
UPDATE_TIME datetime COMMENT '修改时间',
PRIMARY KEY (ID)
 
) ENGINE = INNODB DEFAULT CHARSET = utf8 COMMENT = '定时任务日志表';
 
ALTER TABLE schedule_job ADD UNIQUE INDEX `UNIQUEIDX_SCHEDULE_JOB`(`JOB_NAME`, `JOB_GROUP`);
ALTER TABLE schedule_job_log ADD INDEX `IDX_SCHEDULE_JOB_LOG`(`JOB_NAME`, `JOB_GROUP`);
 
INSERT INTO `httpjob_details` VALUES ('1', 'task_ce', 'web', '测试无参数job', '* * * * * ?' , null,'POST_JSON', 'http://localhost:8080/quartz/test/job', '', '2021-09-22 10:33:00', null);
INSERT INTO `httpjob_details` VALUES ('9', 'task3', 'adce', '测试有参数job' , '* * * * * ?', '0' ,'POST_JSON', 'http://localhost:8080/quartz/test/job', '	\r\n{\r\n  \"jobName\": \"task3\",\r\n  \"jobGroup\": \"adce\"\r\n}', '2021-09-24 16:28:11', null);
 
 
commit;

2.添加依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>

3.配置yml文件

server:
  port: 8003


spring:
  http:
    encoding:
      UTF-8
  application:
    name: quartz

  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/quartz?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowPublicKeyRetrieval=true
    username: root
    password: root
    druid:
      initial-size: 5
      min-idle: 5
      max-active: 20
      max-wait: 6000
      time-between-eviction-runs-millis: 60000
      min-evictable-idle-time-millis: 30000
      test-on-borrow: false
      test-on-return: false
      pool-prepared-statements: true
      max-pool-prepared-statement-per-connection-size: 20

  quartz:
    # 任务存储类型
    job-store-type: JDBC
    # 关闭时等待任务完成
    wait-for-jobs-to-complete-on-shutdown: false
    # 是否覆盖已有的任务
    overwrite-existing-jobs: true
    # 是否自动启动计划程序
    auto-startup: true
    # 延迟启动
    startup-delay: 0s
    jdbc:
      # 数据库架构初始化模式（never：从不进行初始化；always：每次都清空数据库进行初始化；embedded：只初始化内存数据库（默认值））
      initialize-schema: never
    # 相关属性配置
    properties:
      org:
        quartz:
          scheduler:
            # 调度器实例名称
            instanceName: QuartzScheduler
            # 分布式节点ID自动生成
            instanceId: AUTO
          jobStore:
            class: org.springframework.scheduling.quartz.LocalDataSourceJobStore
            driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
            # 表前缀
            tablePrefix: QRTZ_
            # 是否开启集群
            isClustered: true
            # 数据源别名（自定义）
            dataSource: quartz
            # 分布式节点有效性检查时间间隔（毫秒）
            clusterCheckinInterval: 10000
            useProperties: false
          # 线程池配置
          threadPool:
            class: org.quartz.simpl.SimpleThreadPool
            threadCount: 10
            threadPriority: 5
            threadsInheritContextClassLoaderOfInitializingThread: true



mybatis-plus:
  mapper-locations: classpath:mapper/**/*.xml
  typeAliasesPackage: com.pojo
  configuration:
    # 驼峰命名
    map-underscore-to-camel-case: true
    cache-enabled: false
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #日志
  global-config:
    db-config:
      column-underline: true
      id-type: auto

4.自定义 Job 类

@Slf4j
@Component
public class TaskJob implements Job {


    /*
     * 1.在Quartz中，Job的执行逻辑是通过实现org.quartz.Job接口的execute方法来定义的。execute方法接收一个JobExecutionContext参数，该参数包含了执行上下文信息，如JobDetail、Trigger等。
     * 2.可以在execute方法中编写你的任务逻辑，例如调用其他服务或执行数据库操作。
     * */
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        log.info("=========================自定义业务逻辑====================");
        String jobName = context.getJobDetail().getKey().getName();
        log.info("jobName:{}", jobName);
        String jobGroup = context.getJobDetail().getKey().getGroup();
        log.info("jobGroup:{}", jobGroup);
        String triggerName = context.getTrigger().getKey().getName();
        log.info("triggerName:{}", triggerName);
        String triggerGroup = context.getTrigger().getKey().getGroup();
        log.info("triggerGroup:{}", triggerGroup);
        String sccfsj = DateUtil.formatDateTime(context.getPreviousFireTime());
        log.info("上次触发时间:{}", sccfsj);
        String bccfsj = DateUtil.formatDateTime(context.getFireTime());
        log.info("本次触发时间:{}", bccfsj);
        String xccfsj = DateUtil.formatDateTime(context.getNextFireTime());
        log.info("下次触发时间:{}", xccfsj);
        String ddsj = DateUtil.formatDateTime(context.getScheduledFireTime());
        log.info("调度时间:{}", ddsj);

        String msg = "【jobName:" + jobName + ",jobGroup:" + jobGroup + ",triggerName:" + triggerName + ",triggerGroup:" + triggerGroup + "】";
        log.info("job -> {}",msg);

        String description = context.getJobDetail().getDescription();
        ClientParams clientParams = JSON.parseObject(description, ClientParams.class);
        get_client(clientParams);
    }



    public void get_client(ClientParams clientParams){
        String url = clientParams.getUrl();

        CloseableHttpClient httpClient = HttpClients.createDefault();
        HttpGet httpGet = new HttpGet(url);
        // 设置请求超时时间
        RequestConfig config = RequestConfig.custom().setConnectTimeout(5000).build();
        httpGet.setConfig(config);
        //设置请求头
        httpGet.setHeader("Accept", "application/json");

        CloseableHttpResponse response = null;
        try {
            response = httpClient.execute(httpGet);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        int statusCode = response.getStatusLine().getStatusCode();
        String entStr = null;
        try {
            entStr = EntityUtils.toString(response.getEntity());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        if (statusCode != 200) {
            throw new CustomException("请求失败");
        }
    }



}

传参实体类

@Data
public class QuartzData {

    private String jobName;//任务名称
    private String jobGroup;//任务组名
    private String cron;// 定时任务的cron表达式
    private String triggerName;//Trigger 名称
    private String triggerGroup;// Trigger 组名
    private ClientParams clientParams;

}

@Data
public class ClientParams {
    private String url;
    private String method;
    private Map<String,Object> params;
}

5.Controller层

@RestController
@RequestMapping("/quartz")
public class QuartzController {

    @Resource
    private QuartzService quartzService;

    @PostMapping("/createJob")
    public String createJob(@RequestBody QuartzData quartzData) {
        String str = quartzService.addCronJob(quartzData);
        return str;
    }

    @PostMapping("/deleteJob")
    public String deleteJob(@RequestBody QuartzData quartzData) {
        String str = quartzService.deleteCronJob(quartzData);
        return str;
    }


}

6.Service层

public interface QuartzService {
    /**
     * 新增
     */
    String addCronJob(QuartzData quartzData);

    /**
     * 停止
     */
    String deleteCronJob(QuartzData quartzData);

}

7.ServiceImpl实现层

@Slf4j
@Service
public class QuartzServiceImpl implements QuartzService {

    @Resource
    private Scheduler scheduler;

    /**
     * 新增
     */
    @Override
    public String addCronJob(QuartzData quartzData) {

        try {
            //jobKey属性：当trigger触发时被执行的job的身份；
            JobKey jobKey = JobKey.jobKey(quartzData.getJobName(), quartzData.getJobGroup());
            if (scheduler.checkExists(jobKey)) {
                log.info("[添加定时任务]已存在该作业，jobkey为：{}", jobKey);
                return "已存在该作业";
            }

            //todo: 1. 创建JobDetail对象
            //JobDetail job = JobBuilder.newJob(getClass(quartzData.getJobClassName()).getClass()).withIdentity(jobKey).build();
            String param = "";
            if (quartzData.getClientParams() != null){
                param = JSON.toJSONString(quartzData.getClientParams());
            }
            JobDetail job = JobBuilder.newJob(TaskJob.class)
                    .withDescription(param)//任务描述
                    .withIdentity(jobKey)//指定任务
                    .build();

            //todo: 2. Trigger（触发器：什么时候去做），这里 triggerbuilder 也是用建造者模式封装。触发条件分为两种
            //todo: 2.1 简单的 trigger 触发时间，通过 Quartz 提供方法完成简单的重复调用。如下一个例子：每秒触发一次
            //Trigger build = TriggerBuilder.newTrigger().withSchedule(SimpleScheduleBuilder.repeatSecondlyForever()).build();
            //todo: 2.2 按照 cron 的表达式来给定触发时间
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(quartzData.getCron());
            Trigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity(TriggerKey.triggerKey(quartzData.getTriggerName(), quartzData.getTriggerGroup()))
                    .withSchedule(cronScheduleBuilder).build();


            /*
            * 1.使用：Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
            * 2.使用：上面注入的 private Scheduler scheduler;
            * */
            //todo: 3. scheduler（任务调度：你什么时候需要做什么事） 将上面的job 和 trigger进行组装 这里使用工厂模式。
            scheduler.scheduleJob(job, trigger);
            //启动
            scheduler.start();
            return "SUCCESS";

        } catch (Exception e) {
            log.error("[新增定时任务]失败，报错：", e);
            return "FAIL";
        }
    }

    /**
     * 停止
     */
    @Override
    public String deleteCronJob(QuartzData quartzData) {
        try {

            JobKey jobKey = JobKey.jobKey(quartzData.getJobName(), quartzData.getJobGroup());

            TriggerKey triggerKey = TriggerKey.triggerKey(quartzData.getTriggerName(), quartzData.getTriggerGroup());

            Trigger trigger = scheduler.getTrigger(triggerKey);

            if (null == trigger) {
                log.info("[停止定时任务]根据triggerName:{}和triggerGroup:{}未查询到相应的trigger！");
                return "SUCCESS";
            }
            //暂停触发器
            scheduler.pauseTrigger(triggerKey);
            // 移除触发器
            scheduler.unscheduleJob(triggerKey);
            // 删除任务
            scheduler.deleteJob(jobKey);

            log.info("[停止定时任务]jobName:{},jobGroup:{}, triggerName:{}, triggerGroup:{},停止--------------",
                    quartzData.getJobName(), quartzData.getJobGroup(),
                    quartzData.getTriggerName(), quartzData.getTriggerGroup());

            return "SUCCESS";

        } catch (SchedulerException e) {
            log.error("[停止定时任务]失败，报错：", e);
            return "FAIL";
        }

    }

}

8.测试接口

@RestController
@RequestMapping("/utils")
public class UtilsController {

    @GetMapping("/quartz_test")
    public void quartz_test(){
        System.err.println("quartz_test —> 调用成功,time: " + new Date());
    }

}

测试

任务开始

任务停止

结尾

        本篇文章就到此结束了，本文主要记录如何快速上手，有不足的地方多多包涵，欢迎留言共同学习进步。