quartz的使用

最新推荐文章于 2024-05-12 23:36:43 发布

昱宸星光

最新推荐文章于 2024-05-12 23:36:43 发布

阅读量338

点赞数 6

分类专栏： quartz 文章标签： mfc c++

本文链接：https://blog.csdn.net/qq_39203337/article/details/137815750

版权

quartz 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

简介

是OpenSymphony开源组织在Job scheduling领域又一个开源项目，完全由Java开发，可以用来执行定时任务，类似于java.util.Timer。功能更强大

常规

依赖

<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.2</version>
</dependency>

编写核心逻辑

public class FirstJob implements Job {

    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("this is first job!");
    }
}

quartz的核心逻辑在org.quartz.Job#execute中，其中JobExecutionContext是任务执行上下文，可以从中获取到相关的调度参数

定式调度

public static void main(String[] args) throws Exception{
        SchedulerFactory factory = new StdSchedulerFactory();
        Scheduler scheduler = factory.getScheduler();

        JobKey jobKey = new JobKey("triggerTX2", "groupTX1"); // 任务(Job)的唯一标识，如果在创建任务时没有设置该项，由框架生成
        List<? extends Trigger> triggersOfJob = scheduler.getTriggersOfJob(jobKey);

        if (Objects.nonNull(triggersOfJob) && triggersOfJob.size() > 0) {
            scheduler.resumeJob(jobKey);

        } else {
            JobDetail jobDetail = JobBuilder.newJob(FirstJob.class)
                    .withIdentity(jobKey)
                    .usingJobData("userName", "zhangsan") // 此处可以添加需要的调度参数，然后会把参数封装到JobExecutionContent中
                    .build();

            CronTrigger trigger = TriggerBuilder
                    .newTrigger()
                    .withIdentity(jobKey.getName(),jobKey.getGroup()) // 设置标识
                    .usingJobData("address","123")  // 此处可以添加需要的调度参数，然后会把参数封装到JobExecutionContent中
                    .withSchedule(CronScheduleBuilder.cronSchedule("0 0/1 * * * ?"))
                    .startNow()
                    .build();

            scheduler.scheduleJob(jobDetail,trigger);
        }
        scheduler.start();
    }

此处需要注意，如果使用把job信息记录在内存中(默认方式),job信息随着程序启停而结束，每次重新启动程序其实是心创建一个Job！

持久化

依赖

<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.2</version>
</dependency>

配置文件

需要在项目的resource目录下创建quartz.properties文件，内容如下：

# Default Properties file for use by StdSchedulerFactory
# to create a Quartz Scheduler Instance, if a different
# properties file is not explicitly specified.
#

org.quartz.scheduler.instanceName= DefaultQuartzScheduler
org.quartz.scheduler.rmi.export= false
org.quartz.scheduler.rmi.proxy= false
org.quartz.scheduler.wrapJobExecutionInUserTransaction= false

org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount= 10
org.quartz.threadPool.threadPriority= 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread= true

org.quartz.jobStore.misfireThreshold= 60000

#数据持久化 内存配置：org.quartz.simpl.RAMJobStore
org.quartz.jobStore.class= org.quartz.impl.jdbcjobstore.JobStoreTX

#驱动代理为 标准的jdbc
org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate

#数据库表前缀
org.quartz.jobStore.tablePrefix=QRTZ_

#数据源 该数据源名称可以随意取，只需要和下面的配置项的数据源相同即可
org.quartz.jobStore.dataSource=quartz_test

#JDBC驱动 驱动相关参数中quartz_test和上面配置的相同即可
org.quartz.dataSource.quartz_test.driver=com.mysql.cj.jdbc.Driver
org.quartz.dataSource.quartz_test.URL=jdbc:mysql://{your mysql ip}:3306/quartz
org.quartz.dataSource.quartz_test.user=xxxx
org.quartz.dataSource.quartz_test.password=xxxx

配置自己的数据库地址、用户名、密码即可

执行ddl建表

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(100) NOT NULL,
    JOB_GROUP VARCHAR(100) 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)
);

CREATE TABLE QRTZ_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(100) NOT NULL,
    TRIGGER_GROUP VARCHAR(100) NOT NULL,
    JOB_NAME  VARCHAR(100) NOT NULL,
    JOB_GROUP VARCHAR(100) 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(100) 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)
);

CREATE TABLE QRTZ_SIMPLE_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(100) NOT NULL,
    TRIGGER_GROUP VARCHAR(100) 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)
);

CREATE TABLE QRTZ_CRON_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(100) NOT NULL,
    TRIGGER_GROUP VARCHAR(100) NOT NULL,
    CRON_EXPRESSION VARCHAR(100) 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)
);

CREATE TABLE QRTZ_SIMPROP_TRIGGERS
  (          
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(100) NOT NULL,
    TRIGGER_GROUP VARCHAR(100) 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)
);

CREATE TABLE QRTZ_BLOB_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(100) NOT NULL,
    TRIGGER_GROUP VARCHAR(100) NOT NULL,
    BLOB_DATA BLOB 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)
);

CREATE TABLE QRTZ_CALENDARS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    CALENDAR_NAME  VARCHAR(100) NOT NULL,
    CALENDAR BLOB NOT NULL,
    PRIMARY KEY (SCHED_NAME,CALENDAR_NAME)
);

CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_GROUP  VARCHAR(100) NOT NULL, 
    PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_FIRED_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    ENTRY_ID VARCHAR(95) NOT NULL,
    TRIGGER_NAME VARCHAR(100) NOT NULL,
    TRIGGER_GROUP VARCHAR(100) NOT NULL,
    INSTANCE_NAME VARCHAR(100) 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(100) NULL,
    JOB_GROUP VARCHAR(100) NULL,
    IS_NONCONCURRENT VARCHAR(1) NULL,
    REQUESTS_RECOVERY VARCHAR(1) NULL,
    PRIMARY KEY (SCHED_NAME,ENTRY_ID)
);

CREATE TABLE QRTZ_SCHEDULER_STATE
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    INSTANCE_NAME VARCHAR(100) NOT NULL,
    LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
    CHECKIN_INTERVAL BIGINT(13) NOT NULL,
    PRIMARY KEY (SCHED_NAME,INSTANCE_NAME)
);

CREATE TABLE QRTZ_LOCKS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    LOCK_NAME  VARCHAR(40) NOT NULL, 
    PRIMARY KEY (SCHED_NAME,LOCK_NAME)
);

commit;

核心代码&定式调度

同内存中创建定时任务一样即可

quartz结合springboot

依赖

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

添加quartz和springboot整合依赖即可

ddl建表

同上

配置文件

在springboot的配置文件application.yml中配置如下：

spring:
  quartz:
    job-store-type: jdbc
    overwrite-existing-jobs: true
    jdbc:
      schema: classpath:quartz_test.sql
    properties:
      -org.quartz.jobStore.class: org.quartz.impl.jdbcjobstore.JobStoreTX
      -org.quartz.jobStore.driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
      -org.quartz.jobStore.tablePrefix: QRTZ_
      -org.quartz.jobStore.dataSource: quartz_test
      -org.quartz.dataSource.quartz_test.driver: com.mysql.cj.jdbc.Driver
      -org.quartz.dataSource.quartz_test.URL: jdbc:mysql://xxxxx:3306/quartz_test
      -org.quartz.dataSource.quartz_test.user: xxxx
      -org.quartz.dataSource.quartz_test.password: xxxxx
      -org.quartz.scheduler.instanceName: DefaultQuartzScheduler
      -org.quartz.scheduler.rmi.export: false
      -org.quartz.scheduler.rmi.proxy: false
      -org.quartz.scheduler.wrapJobExecutionInUserTransaction: false
      -org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
      -org.quartz.threadPool.threadCount: 10
      -org.quartz.threadPool.threadPriority: 5
      -org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true
      -org.quartz.jobStore.misfireThreshold: 60000

代码配置

在spring的容器环境下，任务Job可以实现原始的Job，也可以继承QuartzJobBean。如果使用后者，可以获取更多的容器信息

@Slf4j
public class JobBean extends QuartzJobBean {

    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        log.info("this is springboot quartz job!");
    }
}

然后添加任务管理类：

package com.lyc.quartz.boot.core;

import lombok.AllArgsConstructor;
import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.springframework.stereotype.Component;

import java.util.*;

@Component
@AllArgsConstructor
public class YcQuartzManager {

    private final Scheduler scheduler;

    // add job with no param
    public void addJob(Class<? extends Job> clazz, String jobName, String jobGroupName, String cronExpression) throws SchedulerException {
        addJob(clazz,jobName,jobGroupName,cronExpression,null);
    }


    // add job with param
    public void addJob(Class<? extends Job> clazz, String jobName, String jobGroupName, String cronExpression, Map<String, Object> argMap) throws SchedulerException {

        // build job
        JobDetail jobDetail = JobBuilder.newJob(clazz).withIdentity(jobName, jobGroupName).build();

        // build cron Expression
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

        //cron trigger
        CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobName, jobGroupName)
                .withSchedule(scheduleBuilder).build();

        if (Objects.nonNull(argMap)) {
            trigger.getJobDataMap().putAll(argMap);
        }

        scheduler.scheduleJob(jobDetail, trigger);

        // schedule
        scheduler.start();
    }

    // pauseJob withIdentity
    public void pauseJob(String jobName, String jobGroupName) throws SchedulerException {
        scheduler.pauseJob(JobKey.jobKey(jobName, jobGroupName));
    }

    // resumeJob withIdentity
    public void resumeJob(String jobName, String jobGroupName) throws SchedulerException {
        scheduler.resumeJob(JobKey.jobKey(jobName, jobGroupName));
    }


    public void updateJob(String jobName, String jobGroupName, String cronExpression) throws SchedulerException {
        updateJob(jobName,jobGroupName,cronExpression,null);
    }


    public void updateJob(String jobName, String jobGroupName, String cronExpression, Map<String, Object> argMap) throws SchedulerException {

        TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroupName);

        CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

        if (Objects.nonNull(cronExpression)) {
            // build cron Expression
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);
            // build cron trigger
            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
        }

        if(Objects.nonNull(argMap)) {
            // param update
            trigger.getJobDataMap().putAll(argMap);
        }

        scheduler.rescheduleJob(triggerKey, trigger);

    }

    public void updateJob(String jobName, String jobGroupName, Map<String, Object> argMap) throws SchedulerException {
        updateJob(jobName,jobGroupName,null,argMap);
    }


    // delete job with
    public void deleteJob(String jobName, String jobGroupName) throws SchedulerException {
        scheduler.pauseTrigger(TriggerKey.triggerKey(jobName, jobGroupName));
        scheduler.unscheduleJob(TriggerKey.triggerKey(jobName, jobGroupName));
        scheduler.deleteJob(JobKey.jobKey(jobName, jobGroupName));
    }


    // start jobs
    public void startAllJobs() {
        try {
            scheduler.start();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    // shutdown Jobs
    public void shutdownAllJobs() {
        try {
            if (!scheduler.isShutdown()) {
                scheduler.shutdown();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }


    }

    // job list
    public List<Map<String, Object>> getAllJob() throws SchedulerException {
        GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
        Set<JobKey> jobKeys = scheduler.getJobKeys(matcher);
        List<Map<String, Object>> jobList = new ArrayList<>();
        for (JobKey jobKey : jobKeys) {
            List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
            for (Trigger trigger : triggers) {
                Map<String, Object> job = new HashMap<>();
                job.put("jobName", jobKey.getName());
                job.put("jobGroupName", jobKey.getGroup());
                job.put("trigger", trigger.getKey());
                Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                job.put("jobStatus", triggerState.name());
                if (trigger instanceof CronTrigger) {
                    CronTrigger cronTrigger = (CronTrigger) trigger;
                    String cronExpression = cronTrigger.getCronExpression();
                    job.put("cronExpression", cronExpression);
                }
                jobList.add(job);
            }
        }
        return jobList;
    }
}

就可以实现对任务的crud了