SpringBoot整合Quartz任务，java对任务创建、删除、修改、查询

已于 2024-01-28 18:10:29 修改
阅读量797 收藏 10
点赞数 3
文章标签： spring boot 后端 java
于 2024-01-28 17:04:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41919486/article/details/135851422
版权

SpringBoot整合Quartz定时任务

1、定时任务相关概念

SpringBoot中的@Schedule定时任务并不支持动态管理定时任务，且项目重启后，任务相当于重新创，实际重新创建对任务影响也不大。

而Quartz则支持对定时任务的创建，删除，修改，查询，很灵活的管理了定时任务,Quartz任务也支持分布式部署和任务信息持久化，重启项目后任务仍然存在。

2、SpringBoot集成Quartz

下面整合的代码，直接复制在企业级项目中使用即可，完全符合企业项目的使用，很灵活，很动态。

2.1、Quartz相关表

Quartz自定11张表，直接导入即可

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;

CREATE TABLE QRTZ_JOB_DETAILS(
SCHED_NAME VARCHAR(120) NOT NULL,
JOB_NAME VARCHAR(190) NOT NULL,
JOB_GROUP VARCHAR(190) 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(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
JOB_NAME VARCHAR(190) NOT NULL,
JOB_GROUP VARCHAR(190) 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(190) 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(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) 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(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) 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(190) NOT NULL,
    TRIGGER_GROUP VARCHAR(190) 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(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) 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(190) 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(190) 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(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
INSTANCE_NAME VARCHAR(190) 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(190) NULL,
JOB_GROUP VARCHAR(190) 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(190) 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);

commit;

2.2、pom.xml

    <dependencies>
        <!--引入web starter-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!--引入lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>
    </dependencies>

2.3、application.yml

server:
  port: 8080

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: root
    url: jdbc:mysql://127.0.0.1:3306/quartz_test?useUnicode=true&autoReconnect=true&failOverReadOnly=false&characterEncoding=UTF-8&allowMultiQueries=true&useSSL=false&serverTimezone=Asia/Shanghai&zeroDateTimeBehavior=CONVERT_TO_NULL
  quartz:
    job-store-type: jdbc #数据库方式
    jdbc:
      initialize-schema: never #不初始化表结构
    properties:
      org:
        quartz:
          scheduler:
            instanceId: AUTO #默认主机名和时间戳生成实例ID,可以是任何字符串，但对于所有调度程序来说，必须是唯一的 对应qrtz_scheduler_state INSTANCE_NAME字段
            #instanceName: clusteredScheduler #quartzScheduler
          jobStore:
            class: org.springframework.scheduling.quartz.LocalDataSourceJobStore # springboot>2.5.6后使用这个
            driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate #仅为数据库制作了特定于数据库的代理
            useProperties: false #以指示JDBCJobStore将JobDataMaps中的所有值都作为字符串，因此可以作为名称 - 值对存储而不是在BLOB列中以其序列化形式存储更多复杂的对象。从长远来看，这是更安全的，因为您避免了将非String类序列化为BLOB的类版本问题。
            tablePrefix: qrtz_  #数据库表前缀
            misfireThreshold: 60000 #在被认为“失火”之前，调度程序将“容忍”一个Triggers将其下一个启动时间通过的毫秒数。默认值（如果您在配置中未输入此属性）为60000（60秒）。
            clusterCheckinInterval: 5000 #设置此实例“检入”*与群集的其他实例的频率（以毫秒为单位）。影响检测失败实例的速度。
            isClustered: true #打开群集功能
          threadPool: #连接池
            class: org.quartz.simpl.SimpleThreadPool
            threadCount: 10
            threadPriority: 5
            threadsInheritContextClassLoaderOfInitializingThread: true

2.4、java对任务增删改查

在这里插入图片描述

2.4.1、common相关配置类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
@Service
public class InitHandler {

    @Autowired
    private TaskInitHandler taskInitHandler;

    /**
     * 系统初始化任务入口。
     * 如果系统在启动时需要添加一些定时任务，把业务逻辑写到taskInitHandler.init()方法里即可
     */
    @PostConstruct
    public void init() {
        taskInitHandler.init();
    }
}

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

@Component
@Slf4j
public class TaskInitHandler {

    public void init() {
      log.info("初始化定时任务业务逻辑......");
    }
}

import cn.yx.zg.pojo.QuartzBean;
import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

/**
 * 该类提供对quartz任务的创建、删除、查询、修改
 */
@Service
public class QuartzJobService {

    @Resource
    private Scheduler scheduler;

    /**
     * 查询定时任务列表
     *
     * @return
     */
    public List<QuartzBean> getScheduleJobList() {
        List<QuartzBean> list = new ArrayList<>();
        try {
            for (String groupJob : scheduler.getJobGroupNames()) {
                for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher.<JobKey>groupEquals(groupJob))) {
                    List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
                    for (Trigger trigger : triggers) {
                        QuartzBean quartzBean = new QuartzBean();
                        Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                        JobDetail jobDetail = scheduler.getJobDetail(jobKey);
                        String cronExpression = "";
                        if (trigger instanceof CronTrigger) {
                            CronTrigger cronTrigger = (CronTrigger) trigger;
                            cronExpression = cronTrigger.getCronExpression();
                            quartzBean.setCronExpression(cronExpression);
                        }
                        quartzBean.setStartTime(trigger.getStartTime());
                        quartzBean.setEndTime(trigger.getEndTime());
                        quartzBean.setJobName(jobKey.getName());
                        quartzBean.setJobGroup(jobKey.getGroup());
                        quartzBean.setJobDescription(jobDetail.getDescription());
                        quartzBean.setJobStatus(triggerState.name());
                        quartzBean.setJobClass(jobDetail.getJobClass().toGenericString());
                        quartzBean.setJobDataMap(jobDetail.getJobDataMap());
                        list.add(quartzBean);
                    }
                }
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return list;
    }

    /**
     * 创建简单调度任务
     *
     * @param quartzBean
     * @throws Exception
     */
    public void createScheduleSimpleJob(QuartzBean quartzBean) throws Exception {
        Class<? extends Job> jobClass = (Class<? extends Job>) Class.forName(quartzBean.getJobClass());
        //job
        JobDetail jobDetail = JobBuilder.newJob(jobClass)
                .withIdentity(quartzBean.getJobName(), quartzBean.getJobGroup())
                .setJobData(quartzBean.getJobDataMap())
                .withDescription(quartzBean.getJobDescription())
                .build();
        //trigger
        Trigger trigger = null;
        //单次还是循环
        if (quartzBean.getInterval() == null) {
            trigger = TriggerBuilder.newTrigger()
                    .withIdentity(quartzBean.getJobName(), quartzBean.getJobGroup())
                    .withSchedule(SimpleScheduleBuilder.simpleSchedule().withMisfireHandlingInstructionNextWithExistingCount())
                    .startAt(quartzBean.getStartTime())
                    .build();
        } else {
            trigger = TriggerBuilder.newTrigger()
                    .withIdentity(quartzBean.getJobName(), quartzBean.getJobGroup())
                    .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(quartzBean.getInterval())
                            .withMisfireHandlingInstructionNextWithExistingCount())
                    .startAt(quartzBean.getStartTime())
                    .endAt(quartzBean.getEndTime())
                    .build();
        }
        scheduler.scheduleJob(jobDetail, trigger);
        if (!scheduler.isShutdown()) {
            scheduler.start();
        }
    }

    /**
     * 创建cron调度任务
     *
     * @param quartzBean
     * @throws Exception
     */
    public void createScheduleCronJob(QuartzBean quartzBean) throws Exception {
        Class<? extends Job> jobClass = (Class<? extends Job>) Class.forName(quartzBean.getJobClass());
        // job
        JobDetail jobDetail = JobBuilder.newJob(jobClass)
                .withIdentity(quartzBean.getJobName(), quartzBean.getJobGroup())
                .setJobData(quartzBean.getJobDataMap())
                .withDescription(quartzBean.getJobDescription())
                .build();
        // trigger
        CronTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity(quartzBean.getJobName(), quartzBean.getJobGroup())
                .withSchedule(CronScheduleBuilder.cronSchedule(quartzBean.getCronExpression()))
                .build();
        scheduler.scheduleJob(jobDetail, trigger);
        if (!scheduler.isShutdown()) {
            scheduler.start();
        }
    }

    /**
     * 暂停任务
     *
     * @param jobName
     * @param jobGroup
     * @throws Exception
     */
    public void pauseScheduleJob(String jobName, String jobGroup) throws Exception {
        JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
        scheduler.pauseJob(jobKey);
    }

    /**
     * 立即执行任务
     *
     * @param jobName
     * @param jobGroup
     * @throws Exception
     */
    public void runJob(String jobName, String jobGroup) throws Exception {
        JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
        scheduler.triggerJob(jobKey);
    }

    /**
     * 更新简单任务
     *
     * @param quartzBean
     * @throws Exception
     */
    public void updateScheduleSimpleJob(QuartzBean quartzBean) throws Exception {
        //原任务触发器
        TriggerKey triggerKey = TriggerKey.triggerKey(quartzBean.getJobName(), quartzBean.getJobGroup());
        //trigger
        Trigger trigger = null;
        //单次还是循环
        if (quartzBean.getInterval() == null) {
            trigger = TriggerBuilder.newTrigger()
                    .withIdentity(quartzBean.getJobName(), quartzBean.getJobGroup())
                    .withSchedule(SimpleScheduleBuilder.simpleSchedule().withMisfireHandlingInstructionNextWithExistingCount())
                    .startAt(quartzBean.getStartTime())
                    .build();
        } else {
            trigger = TriggerBuilder.newTrigger()
                    .withIdentity(quartzBean.getJobName(), quartzBean.getJobGroup())
                    .withSchedule(SimpleScheduleBuilder.repeatMinutelyForever(quartzBean.getInterval()).withMisfireHandlingInstructionNextWithExistingCount())
                    .startAt(quartzBean.getStartTime())
                    .endAt(quartzBean.getEndTime())
                    .build();
        }
        //重置对应的job
        scheduler.rescheduleJob(triggerKey, trigger);
        //用该方法一样可以修改定时任务
        //scheduler.scheduleJob(jobDetail, trigger, true);
    }

    /**
     * 更新定时任务Cron
     *
     * @param quartzBean 定时任务信息类
     * @throws SchedulerException
     */
    public void updateScheduleCronJob(QuartzBean quartzBean) throws Exception {
        //原任务触发器
        TriggerKey triggerKey = TriggerKey.triggerKey(quartzBean.getJobName());
        // trigger
        CronTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity(quartzBean.getJobName())
                .withSchedule(CronScheduleBuilder.cronSchedule(quartzBean.getCronExpression()))
                .build();
        //重置对应的job
        scheduler.rescheduleJob(triggerKey, trigger);
    }

    /**
     * 删除定时任务
     *
     * @param jobName
     * @param jobGroup
     * @throws Exception
     */
    public void deleteScheduleJob(String jobName, String jobGroup) throws Exception {
        JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
        scheduler.deleteJob(jobKey);
    }

    /**
     * 获取任务状态
     * (" BLOCKED ", " 阻塞 ");
     * ("COMPLETE", "完成");
     * ("ERROR", "出错");
     * ("NONE", "不存在");
     * ("NORMAL", "正常");
     * ("PAUSED", "暂停");
     */
    public String getScheduleJobStatus(String jobName, String jobGroup) throws Exception {
        TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
        Trigger.TriggerState state = scheduler.getTriggerState(triggerKey);
        return state.name();
    }

    /**
     * 检查任务是否存在
     *
     * @param jobName
     * @param jobGroup
     * @return
     * @throws Exception
     */
    public Boolean checkExistsScheduleJob(String jobName, String jobGroup) throws Exception {
        JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
        return scheduler.checkExists(jobKey);
    }
}

2.4.2、pojo类

import lombok.Data;
import org.quartz.JobDataMap;

import java.util.Date;

@Data
public class QuartzBean {

    private String id;

    private String jobName;

    private String jobGroup;

    private String jobDescription;

    private String jobClass;

    private String jobStatus;
    /**
     * 设置表示指定时间后任务开始执行
     * 一般都是设置当前时间，表示立即执行
     */
    private Date startTime;
    /**
     * 为null表示任务执行一次
     * 为数字n表示每隔n秒后执行一次
     */
    private Integer interval;
    /**
     * 表示在指定时间后任务结束
     * 如果不设置，表示任务不会结束，
     * 一般我们都会默认为null
     */
    private Date endTime;

    private String cronExpression;

    private JobDataMap jobDataMap;
}

2.4.3、task类

import lombok.extern.slf4j.Slf4j;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;

import java.text.SimpleDateFormat;
import java.util.Date;

@Slf4j
public class MyTask implements Job {
    @Override
    public void execute(JobExecutionContext context) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        log.info("springboot-quartz-cluster-a" + ">>" + sdf.format(new Date()) + ":" + context.getJobDetail().getKey() + "执行中..." + context.getJobDetail().getDescription());
        JobDataMap mergedJobDataMap = context.getMergedJobDataMap();
        log.info(mergedJobDataMap.getString("jobDataMapParam"));
    }
}

2.4.4、Controller类

import cn.yx.zg.common.QuartzJobService;
import cn.yx.zg.pojo.QuartzBean;
import org.quartz.JobDataMap;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

@RestController
public class QuartzJobController {

    @Resource
    private QuartzJobService quartzJobService;

    /**
     * 查询定时任务列表
     *
     * @return
     */
    @GetMapping("get")
    public List<QuartzBean> getQuartzList() {
        return quartzJobService.getScheduleJobList();
    }

    /**
     * 创建简单的任务
     *
     * @param jobName        任务名称
     * @param jobGroup       任务组名称
     * @param jobDescription 任务描述
     * @return
     * @throws Exception
     */
    @GetMapping("createSimpleJob")
    public String createSimpleJob(String jobName, String jobGroup, String jobDescription) throws Exception {
        QuartzBean quartzBean = new QuartzBean();
        quartzBean.setJobClass("cn.yx.zg.task.MyTask");
        quartzBean.setJobName(jobName);
        quartzBean.setJobGroup(jobGroup);
        quartzBean.setJobDescription(jobDescription);

        JobDataMap map = new JobDataMap();
        map.put("jobDataMapParam", "aaa");
        quartzBean.setJobDataMap(map);
        //10s中后开始
        Calendar newTimeStart = Calendar.getInstance();
        newTimeStart.setTime(new Date());
        newTimeStart.add(Calendar.SECOND, 10);
        quartzBean.setStartTime(newTimeStart.getTime());
        //50s后结束
        Calendar newTimeEnd = Calendar.getInstance();
        newTimeEnd.setTime(new Date());
        newTimeEnd.add(Calendar.SECOND, 50);
        quartzBean.setEndTime(newTimeEnd.getTime());
        quartzBean.setEndTime(null);
        //每隔3秒钟一次
        quartzBean.setInterval(3);
        quartzJobService.createScheduleSimpleJob(quartzBean);
        return "SUCCESS";
    }

    /**
     * 获取任务状态
     *
     * @param jobName
     * @param jobGroup
     * @return
     * @throws Exception
     */
    @GetMapping("/getScheduleJobStatus")
    public String getScheduleJobStatus(String jobName, String jobGroup) throws Exception {
        /**
         * ("BLOCKED", " 阻塞 ");
         * ("COMPLETE", "完成");
         * ("ERROR", "出错");
         * ("NONE", "不存在");
         * ("NORMAL", "正常");
         * ("PAUSED", "暂停");
         */
        return quartzJobService.getScheduleJobStatus(jobName, jobGroup);
    }

    /**
     * 创建Cron的任务
     *
     * @param jobName
     * @param jobGroup
     * @param jobDescription
     * @return
     * @throws Exception
     */
    @GetMapping("/createCronJob")
    public String createCronJob(String jobName, String jobGroup, String jobDescription) throws Exception {
        QuartzBean quartzBean = new QuartzBean();
        quartzBean.setJobClass("cn.yx.zg.task.MyTask");
        quartzBean.setJobName(jobName);
        quartzBean.setJobGroup(jobGroup);
        quartzBean.setJobDescription(jobDescription);
        quartzBean.setCronExpression("*/10 * * * * ?");
        JobDataMap map = new JobDataMap();
        map.put("jobDataMapParam", "aaa");
        quartzBean.setJobDataMap(map);
        quartzJobService.createScheduleCronJob(quartzBean);
        return "SUCCESS";
    }

    /**
     * 删除任务
     *
     * @param jobName
     * @param jobGroup
     * @return
     * @throws Exception
     */
    @GetMapping(value = "/delete")
    public String delete(String jobName, String jobGroup) throws Exception {
        quartzJobService.deleteScheduleJob(jobName, jobGroup);
        return "SUCCESS";
    }

    /**
     * 立即执行定时任务
     *
     * @param jobName
     * @param jobGroup
     * @return
     * @throws Exception
     */
    @GetMapping(value = "/runJob")
    public String runJob(String jobName, String jobGroup) throws Exception {
        quartzJobService.runJob(jobName, jobGroup);
        return "SUCCESS";
    }

    /**
     * 暂停定时任务
     *
     * @param jobName
     * @param jobGroup
     * @return
     * @throws Exception
     */
    @GetMapping(value = "/pauseScheduleJob")
    public String pauseScheduleJob(String jobName, String jobGroup) throws Exception {
        quartzJobService.pauseScheduleJob(jobName, jobGroup);
        return "SUCCESS";
    }

    /**
     * 校验定时任务是否存在
     *
     * @param jobName
     * @param jobGroup
     * @return
     * @throws Exception
     */
    @GetMapping(value = "check")
    public String check(String jobName, String jobGroup) throws Exception {
        if (quartzJobService.checkExistsScheduleJob(jobName, jobGroup)) {
            return "存在定时任务：" + jobName;
        } else {
            return "不存在定时任务：" + jobName;
        }
    }

    /**
     * 更新定时任务，写法是一样的，直接调用quartzJobService里更新的方法即可
     */
}

3、一些理解

3.1、Quartz的集群原理以及配置？

只要在application.yml文件中配置是否为开启集群即可，Quartz的集群是通过mysql表控制的，集群节点相互之间不通信，而是通过定时任务持久化加锁的方式来实现集群。
对开发人员来说，并不需要管理集群模式下的Quartz。

北漂IT民工_程序员_ZG
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
quartz动态添加、修改和删除定时任务
01-06
附件中实现了对quartz的动态添加、修改和删除定时任务，方便通过页面动态控制执行定时任务。
Springboot整合Quartz实现定时任务数据库动态配置
03-17
Springboot整合Quartz实现定时任务数据库动态配置，新增任务、修改cron表达式、暂停任务、恢复任务、删除任务等操作
Quartz怎么简单创建一个定时执行的任务
最新发布
一个专注于技术研究创新的程序员
05-08 407
3.调用job，以指定时间策略执行。继承 IJob编辑自定义任务。如果只执行一次的话这样即可。Cron表达式下节详细介绍。1.安装Quartz包。定时600s执行一次。
Quartz 分布式定时任务动态添加&删除定时任务
K_Men的博客
01-14 6852
首先对于Quartz的原理和使用这里不再做赘述和讲解，相信大家可以自信查阅文档进行使用。先说一下个人的这个使用背景：项目中需要引入定时任务，框架是springcloud分布式系统然后调研之后决定引入Quartz,他需要基于数据库特定的表来存储定时任务相关的数据等，普通的定时任务比如：日终定时批量进行某些数据的处理扫描等也可以使用，不过那个需要项目启动后就将任务进行添加并启动。对于特定的动态生成的任务：比如前端进行提交某些数据调用服务端接口时需要根据业务需求生成一个未来的时间进行执行的任务逻辑...
Quartz 动态添加、修改和删除定时任务
_江屿_
09-01 648
Quartz动态添加、修改和删除定时任务
SpringBoot集成Quartz实现定时任务的动态创建、启动、暂停、恢复、删除
z_ssyy的博客
01-17 2761
看了好多文章，都只讲了基础的demo用法，也就是简单的创建运行定时任务，对定时任务的管理却很少。我这里从0开始搭建一个简单的demo，包括定时任务的各种操作，以及API的一些用法，可以实现大多场景的需求。如：普通定时任务的创建、启动、停止。动态创建定时任务，如创建一个订单，5分钟后执行某某操作。
ssm整合quartz定时任务实现动态增删改查，暂停任务，恢复任务
01-16
ssm整合quartz 并持久化到数据库中，实现动态增删改查，暂停任务，恢复任务等 将链接内的target文件直接放到项目ssmquartztest文件夹下 运行环境: jdk5+tomcat7+mysql+eclipse+maven lib jar包下载地址 地址1：链接：https://pan.baidu.com/s/1d3TveY 密码：g1t1 地址2：链接: https://pan.baidu.com/s/1dGoUgJv 密码: m7qx
springboot整合quartz实现定时任务动态增删改查
weixin_44860141的博客
06-12 1898
springboot整合quartz实现动态增删改查
Spring Boot集成Quartz实现定时任务的动态创建、启动、暂停、恢复、删除
Angus博客
02-15 5257
Quartz
java Quartz动态添加、删除job
qq_27106141的博客
02-07 1566
java Quartz动态添加、删除job
SpringBoot 2.2.5 整合Quartz，配置动态增删改查定时任务，并解决Job中不能注入Bean问题
qq_43659871的博客
12-14 480
*** @description Quartz创建JobFactory实例*/@Component/*** AutowireCapableBeanFactory接口是BeanFactory的子类* 可以连接和填充那些生命周期不被Spring管理的已存在的bean实例*//*** @description 构造器*//*** @description 创建Job实例*/@Override// 实例化对象// 进行注入（Spring管理该Bean）
springboot整合Quartz实现动态配置定时任务的方法
08-29
SpringBoot 整合 Quartz 实现动态配置定时任务的方法可以实现任务的动态添加、修改和删除，而不需要修改代码，非常具有实用价值。该方法可以应用于各种需要定时任务的场景，例如数据同步、日志处理等。
springboot整合quartz，实现数据库方式执行定时任务
11-19
在现代企业级应用中，定时任务的管理是一个重要的功能，它可以帮助我们自动化执行一系列周期性的任务...同时，通过数据库的方式，我们还能方便地进行任务的查询、暂停、恢复和删除，极大地提升了定时任务管理的便利性。
SpringBoot整合Quartz任务定时调度
06-08
本篇文章将详细探讨如何在Spring Boot项目中整合Quartz实现任务定时调度。 首先，我们需要理解Spring Boot与Quartz的整合基础。Spring Boot简化了Quartz的集成过程，我们可以通过添加相应的依赖来引入Quartz。在`...
SpringBoot 整合Quartz（集群）实现定时任务调度
02-14
SpringBoot整合Quartz实现定时任务调度是企业级应用中常见的需求，主要用于自动化执行某些周期性的任务，例如数据备份、报表生成、系统维护等。Quartz是一个功能强大的开源作业调度框架，能够灵活地定义任务和调度...
Quartz+SpringBoot实现一个任务对应多个触发器的添加、暂停、恢复、删除、查询所有，每个方法都有解释
qq_34690003的博客
07-26 1246
quartz
SpringBoot2.0整合quartz实现多定时任务动态配置，实现任务增删改，生成Cron表达式
振钧
08-02 2613
部分内容转载自“尔笑惹千愁”，链接https://blog.csdn.net/lx1309244704/article/details/81810373 在我们日常的开发中，很多时候，定时任务都不是写死的，而是写到数据库中，从而实现定时任务的动态配置，下面就通过一个简单的示例，来实现这个功能。 一、添加依赖包 <!-- quartz --> <dependency> ...
Quartz1.7 动态添加、修改和删除定时任务(非spring集成版)
赶路人儿
06-17 1757
一、Quartz简介 Quartz是一个由James House创立的开源项目，是一个功能强大的作业调度工具，可以计划的执行任务，定时、循环或在某一个时间来执行我们需要做的事，这可以给我们工作上带来很大的帮助。例如，你的程序中需要每个月的一号导出报表、定时发送邮件或程序需要每隔一段执行某一任务……等等，都可以用Quartz来解决。 Quartz大致可分为三个主要的核心：
SpringBoot+quartz实现定时任务的创建、删除、查询操作
m0_57037182的博客
08-27 1449
2、配置quartz的数据源等操作 需要对父类的方法进行重写。 做调度问题，不应该把任务写在配置类里面，应该用控制台增加，以下的文件直接拿来用就行。 5、DOM类的相关定义
SpringBoot整合Quartz
10-19
SpringBoot整合Quartz可以通过两种方式实现定时任务的调度。第一种是使用SpringBoot内置的简单注解方式，这种方式适用于简单的定时任务场景。第二种是使用Quartz，Quartz是Java体系中最完善的定时方案，适用于更复杂的应用场景。 在SpringBoot中整合Quartz非常简单，只需要引入Quartz的依赖即可。SpringBoot会自适配调度器，同时也可以通过新建bean来修改SchedulerFactoryBean的一些默认属性值。 使用Quartz需要定义Job和Trigger，Job是具体的任务实现，Trigger是任务的触发器。可以通过注解或者配置文件的方式来定义Job和Trigger，然后将它们注册到Scheduler中即可。 总的来说，SpringBoot整合Quartz非常方便，可以快速实现定时任务的调度。但是在选择使用哪种方式时，需要根据具体的应用场景来进行选择。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

北漂IT民工_程序员_ZG

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值