springboot SpringCloud quartz 集群搭建

最新推荐文章于 2022-07-06 23:05:53 发布
最新推荐文章于 2022-07-06 23:05:53 发布
阅读量526 收藏 1
点赞数 1
文章标签： SpringBoot Quartz
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21480147/article/details/116701746
版权

1. 基本概念

Quartz（任务调度框架）核心的概念：scheduler任务调度、Job任务、Trigger触发器、JobDetail任务细节。

scheduler任务调度：

是最核心的概念，需要把JobDetail和Trigger注册到scheduler中，才可以执行。

Job任务：

  • 其实Job是接口，其中只有一个execute方法；每一个业务任务 创建一个job
  • 不同的Job在定义jobname和jobgroup时不能相同

Trigger触发器

  • a)作用:它是来执行工作任务，在什么条件下触发，什么时间执行，多久执行一次。
  • b)四大类型：SimpleTrigger，CronTirgger，DateIntervalTrigger， 和 NthIncludedDayTrigger。

SimpleTrigger 一般用于实现每隔一定时间执行任务，以及重复多少次，如每 2 小时执行一次，重复执行 5 次。SimpleTrigger 内部实现机制是通过计算间隔时间来计算下次的执行时间，这就导致其不适合调度定时的任务。例如我们想每天的 1：00AM 执行任务，如果使用 SimpleTrigger 的话间隔时间就是一天。注意这里就会有一个问题，即当有 misfired 的任务并且恢复执行时，该执行时间是随机的（取决于何时执行 misfired 的任务，例如某天的 3：00PM）。这会导致之后每天的执行时间都会变成 3：00PM，而不是我们原来期望的 1：00AM。

CronTirgger 类似于 LINUX 上的任务调度命令 crontab，即利用一个包含 7 个字段的表达式来表示时间调度方式。例如，“0 15 10 * * ? *” 表示每天的 10：15AM 执行任务。对于涉及到星期和月份的调度，CronTirgger 是最适合的，甚至某些情况下是唯一选择。例如，“0 10 14 ? 3 WED” 表示三月份的每个星期三的下午 14：10PM 执行任务。读者可以在具体用到该 trigger 时再详细了解每个字段的含义。

JobDetail

JobDetail，顾名思义，就是表示关于每个Job的相关信息，它主要包括两个核心组件，即Job Task和JobData Map

流程介绍

  1. 首先我们需要定义实现一个定时功能的接口，我们可以称之为Task（或Job），如定时发送邮件的task（Job），重启机器的task（Job），优惠券到期发送短信提醒的task（Job），实现接口如下：
    在这里插入图片描述

  2. 有了任务之后，还需要一个能够实现触发任务去执行的触发器，触发器Trigger最基本的功能是指定Job的执行时间，执行间隔，运行次数等。
    在这里插入图片描述

  3. 有了Job和Trigger后，怎么样将两者结合起来呢？即怎样指定Trigger去执行指定的Job呢？这时需要一个Schedule，来负责这个功能的实现。
    上面三个部分就是Quartz的基本组成部分：
    调度器：Scheduler
    任务：JobDetail
    触发器：Trigger，包括SimpleTrigger和CronTrigger
    在这里插入图片描述

2. 导入数据库图表

介绍

首先要在mysql里面建一个数据库，这里起名：quartz_test，并导入以下sql内容
以下的sql为实现quartz集群必须要的表，quartz集群就是通过共享一个数据库来实现的，不像redis那样的集群，节点与节点需要通信；quartz集群的节点之间是不需要通信的。

表格

# 创建数据库时需要选择 utf8格式 

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(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);
commit;

3. 引入Quartz依赖

此次采用的是 SpringBoot 2.2.5.RELEASE 版本
mysql用的为5.x

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

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

<!--spring quartz依赖-->
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.2.3</version>
</dependency>
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz-jobs</artifactId>
    <version>2.2.3</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>3.2.3.RELEASE</version>
</dependency> 

# 此处还需要引入以下其中一个依赖 
# 在配置文件中配置数据源(可以不跟quartz_test一个数据库 此处未展示数据库配置)

<!-- mybatis-plus -->
<!--        <dependency>-->
<!--            <groupId>com.baomidou</groupId>-->
<!--            <artifactId>mybatis-plus-boot-starter</artifactId>-->
<!--            <version>3.0.5</version>-->
<!--        </dependency>-->

        <!-- MyBatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>

4. 添加配置文件

添加application.yml（不是必须的），quartz.properties文件（必须要的）

application.yml

server:
   port: 8084

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
#如果使用集群，instanceId必须唯一，设置成AUTO
org.quartz.scheduler.instanceId = AUTO
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
#============================================================================
# Configure JobStore
#============================================================================
#
#org.quartz.jobStore.class: org.quartz.simpl.RAMJobStore
#存储方式使用JobStoreTX，也就是数据库
org.quartz.jobStore.class:org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass:org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#使用自己的配置文件
org.quartz.jobStore.useProperties:true
#数据库中quartz表的表名前缀
org.quartz.jobStore.tablePrefix:QRTZ_
org.quartz.jobStore.dataSource:qzDS
#是否使用集群（如果项目只部署到 一台服务器，就不用了）
org.quartz.jobStore.isClustered = true
#============================================================================
# Configure Datasources
#============================================================================
#配置数据源
org.quartz.dataSource.qzDS.driver:com.mysql.jdbc.Driver
org.quartz.dataSource.qzDS.URL:jdbc:mysql://172.16.0.151:3306/quartz_test?useUnicode=true&characterEncoding=utf8
org.quartz.dataSource.qzDS.user:root
org.quartz.dataSource.qzDS.password:huacloudhuacloud
org.quartz.dataSource.qzDS.validationQuery=select 0 from dual

注意：如果部署的是quartz集群，必须加上org.quartz.jobStore.isClustered = true，如果只是单节点quartz可以不用加。

5. 项目结构搭建

在这里插入图片描述

1. 添加springboot启动类

package com.wd;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
public class QuartzApplication {

    public static void main(String[] args) {
        SpringApplication.run(QuartzApplication.class, args);
    }

}

2. 创建job 实例工厂，解决spring注入问题，如果使用默认会导致spring的@Autowired 无法注入问题（很重要）

package com.wd.factory;

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;
import org.springframework.stereotype.Component;

/**
 * 创建job 实例工厂，解决spring注入问题，如果使用默认会导致spring的@Autowired 无法注入问题（很重要）
 */
@Component
public class MyJobFactory extends SpringBeanJobFactory implements ApplicationContextAware {

    private transient AutowireCapableBeanFactory beanFactory;

    @Override
    public void setApplicationContext(final ApplicationContext context) {
        beanFactory = context.getAutowireCapableBeanFactory();
    }

    @Override
    protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception {
        final Object job = super.createJobInstance(bundle);
        beanFactory.autowireBean(job);
        return job;
    }

}

3. quartz的初始化配置

package com.wd.config;
import com.wd.factory.MyJobFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import java.io.IOException;
import java.util.Properties;
/**
 * @author wd
 * @date 21-5-12
 * @Des quartz的初始化配置
 */
@Configuration
public class SchedulerConfiguration {
    @Autowired
    private MyJobFactory myJobFactory;
    @Bean(name = "schedulerFactoryBean")
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
        //获取配置属性
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("quartz.properties"));
        //在quartz.properties中的属性被读取并注入后再初始化对象
        propertiesFactoryBean.afterPropertiesSet();
        //创建SchedulerFactoryBean
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        Properties pro = propertiesFactoryBean.getObject();
        factory.setOverwriteExistingJobs(true);
        factory.setAutoStartup(true);
        factory.setQuartzProperties(pro);
        factory.setJobFactory(myJobFactory);
        return factory;
    }
}

4. 新建service接口和实现类

package com.wd.service;
/**
 * @author wd
 * @date 21-5-12
 */
public interface JobService {
    /**
     * 添加一个定时任务
     *
     * @param jobName
     * @param jobGroup
     */
    void addCronJob(String jobName, String jobGroup);
    /**
     * 添加异步任务
     *
     * @param jobName
     * @param jobGroup
     */
    void addAsyncJob(String jobName, String jobGroup);
    /**
     * 暂停任务
     *
     * @param jobName
     * @param jobGroup
     */
    void pauseJob(String jobName, String jobGroup);
    /**
     * 恢复任务
     *
     * @param triggerName
     * @param triggerGroup
     */
    void resumeJob(String triggerName, String triggerGroup);
    /**
     * 删除job
     *
     * @param jobName
     * @param jobGroup
     */
    void deleteJob(String jobName, String jobGroup);
} 

package com.wd.service;
import com.wd.job.AsyncJob;
import com.wd.job.CronJob;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Service;
import static org.quartz.SimpleScheduleBuilder.simpleSchedule;
/**
 * @author wd
 * @date 21-5-12
 */
@Service
public class JobServiceImpl implements JobService {
    @Autowired
    private SchedulerFactoryBean schedulerFactoryBean;
    /**
     * 创建一个定时任务
     *
     * @param jobName
     * @param jobGroup
     */
    @Override
    public void addCronJob(String jobName, String jobGroup) {
        try {
            Scheduler scheduler = schedulerFactoryBean.getScheduler();
            JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
            JobDetail jobDetail = scheduler.getJobDetail(jobKey);
            if (jobDetail != null) {
                System.out.println("job:" + jobName + " 已存在");
            } else {
                //构建job信息
                jobDetail = JobBuilder.newJob(CronJob.class).withIdentity(jobName, jobGroup).build();
                //用JopDataMap来传递数据
                jobDetail.getJobDataMap().put("taskData", "hzb-cron-001");
                //表达式调度构建器(即任务执行的时间,每5秒执行一次)
                CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("*/5 * * * * ?");
                //按新的cronExpression表达式构建一个新的trigger
                CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobName + "_trigger", jobGroup + "_trigger")
                        .withSchedule(scheduleBuilder).build();
                scheduler.scheduleJob(jobDetail, trigger);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    @Override
    public void addAsyncJob(String jobName, String jobGroup) {
        try {
            Scheduler scheduler = schedulerFactoryBean.getScheduler();
            JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
            JobDetail jobDetail = scheduler.getJobDetail(jobKey);
            if (jobDetail != null) {
                System.out.println("job:" + jobName + " 已存在");
            } else {
                //构建job信息,在用JobBuilder创建JobDetail的时候，有一个storeDurably()方法，可以在没有触发器指向任务的时候，将任务保存在队列中了。然后就能手动触发了
                jobDetail = JobBuilder.newJob(AsyncJob.class).withIdentity(jobName, jobGroup).storeDurably().build();
                jobDetail.getJobDataMap().put("asyncData", "this is a async task");
                Trigger trigger = TriggerBuilder.newTrigger().withIdentity(jobName + "_trigger", jobGroup + "_trigger") //定义name/group
                        .startNow()//一旦加入scheduler，立即生效
                        .withSchedule(simpleSchedule())//使用SimpleTrigger
                        .build();
                scheduler.scheduleJob(jobDetail, trigger);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    @Override
    public void pauseJob(String jobName, String jobGroup) {
        try {
            Scheduler scheduler = schedulerFactoryBean.getScheduler();
            TriggerKey triggerKey = TriggerKey.triggerKey(jobName + "_trigger", jobGroup + "_trigger");
            scheduler.pauseTrigger(triggerKey);
            System.out.println("=========================pause job:" + jobName + " success========================");
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
    /**
     * 恢复任务
     *
     * @param jobName
     * @param jobGroup
     */
    @Override
    public void resumeJob(String jobName, String jobGroup) {
        try {
            Scheduler scheduler = schedulerFactoryBean.getScheduler();
            TriggerKey triggerKey = TriggerKey.triggerKey(jobName + "_trigger", jobGroup + "_trigger");
            scheduler.resumeTrigger(triggerKey);
            System.out.println("=========================resume job:" + jobName + " success========================");
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void deleteJob(String jobName, String jobGroup) {
        try {
            Scheduler scheduler = schedulerFactoryBean.getScheduler();
            JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
            scheduler.deleteJob(jobKey);
            System.out.println("=========================delete job:" + jobName + " success========================");
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
}

5. 新建controller

package com.wd.controller;

import com.wd.service.JobService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author wd
 * @date 21-5-12
 */
@RestController
@RequestMapping("/quartztest")
public class JobController {
    @Autowired
    private JobService jobService;


    /**
     * 创建cron任务
     *
     * @param jobName
     * @param jobGroup
     * @return
     */
    @RequestMapping(value = "/cron", method = RequestMethod.POST)
    public String startCronJob(@RequestParam("jobName") String jobName, @RequestParam("jobGroup") String jobGroup) {
        jobService.addCronJob(jobName, jobGroup);
        return "create cron task success";
    }

    /**
     * 创建异步任务
     *
     * @param jobName
     * @param jobGroup
     * @return
     */
    @RequestMapping(value = "/async", method = RequestMethod.POST)
    public String startAsyncJob(@RequestParam("jobName") String jobName, @RequestParam("jobGroup") String jobGroup) {
        jobService.addAsyncJob(jobName, jobGroup);
        return "create async task success";
    }

    /**
     * 暂停任务
     *
     * @param jobName
     * @param jobGroup
     * @return
     */
    @RequestMapping(value = "/pause", method = RequestMethod.POST)
    public String pauseJob(@RequestParam("jobName") String jobName, @RequestParam("jobGroup") String jobGroup) {
        jobService.pauseJob(jobName, jobGroup);
        return "pause job success";
    }

    /**
     * 恢复任务
     *
     * @param jobName
     * @param jobGroup
     * @return
     */
    @RequestMapping(value = "/resume", method = RequestMethod.POST)
    public String resumeJob(@RequestParam("jobName") String jobName, @RequestParam("jobGroup") String jobGroup) {
        jobService.resumeJob(jobName, jobGroup);
        return "resume job success";
    }

    /**
     * 删除务
     *
     * @param jobName
     * @param jobGroup
     * @return
     */
    @RequestMapping(value = "/delete", method = RequestMethod.PUT)
    public String deleteJob(@RequestParam("jobName") String jobName, @RequestParam("jobGroup") String jobGroup) {
        jobService.deleteJob(jobName, jobGroup);
        return "delete job success";
    }
}

6. 新建job，这里的job仅仅只是打印信息，不做复杂的业务

package com.wd.job;

/**
 * @author wd
 * @date 21-5-12
 */

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
 * @author hzb
 * @date 2018/08/28
 */
public class CronJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("=========================定时任务每5秒执行一次===============================");
        System.out.println("jobName=====:" + jobExecutionContext.getJobDetail().getKey().getName());
        System.out.println("jobGroup=====:" + jobExecutionContext.getJobDetail().getKey().getGroup());
        System.out.println("taskData=====:" + jobExecutionContext.getJobDetail().getJobDataMap().get("taskData"));
    }
} 

package com.wd.job;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
 * @author wd
 * @date 21-5-12
 */
public class AsyncJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("========================立即执行的任务，只执行一次===============================");
        System.out.println("jobName=====:" + jobExecutionContext.getJobDetail().getKey().getName());
        System.out.println("jobGroup=====:" + jobExecutionContext.getJobDetail().getKey().getGroup());
        System.out.println("taskData=====:" + jobExecutionContext.getJobDetail().getJobDataMap().get("asyncData"));
    }
}

6. Controller方式执行

  • 启动两个 集群方式
    在这里插入图片描述

  • 启动程序之后，这里用postman进行测试

  • 添加两个 以测试集群
    在这里插入图片描述
    在这里插入图片描述

注意

如果不使用Controller方式进行任务的调度, 则controller 和 service 中的类用不到 可以删除掉

若项目开启时就需要执行 则参考07

7. 项目开启时执行

1. 将cronJob.class复制一份

成为两个定时任务 方便进行测试
在这里插入图片描述

2. 创建工具类 QuartzManageKit

package com.wd.job.utils;
import com.wd.job.CronJob;
import lombok.extern.slf4j.Slf4j;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
/**
 * @author wd
 * @date 21-5-12
 */
@Slf4j
public class QuartzManageKit {
//    @Autowired
//    private SchedulerFactoryBean schedulerFactoryBean;
    /**
     * 用于启动一个Cron类型的 Job
     *
     * @param clazz
     * @param jobName
     * @param jobGroup
     * @param cron
     */
    public void startCronJob(Class<?> clazz, String jobName, String jobGroup, String cron, SchedulerFactoryBean schedulerFactoryBean) {
        try {
            Scheduler scheduler = schedulerFactoryBean.getScheduler();
            JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
            JobDetail jobDetail = scheduler.getJobDetail(jobKey);
            if (jobDetail != null) {
                log.info("定时任务: " + jobName + " 已存在");
                return;
            } else {
                //构建job信息
                jobDetail = JobBuilder.newJob((Class<? extends Job>) clazz).withIdentity(jobName, jobGroup).build();
                //表达式调度构建器(即任务执行的时间,每5秒执行一次)
                CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
                //按新的cronExpression表达式构建一个新的trigger
                CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobName + "_trigger", jobGroup + "_trigger")
                        .withSchedule(scheduleBuilder).build();
                scheduler.scheduleJob(jobDetail, trigger);
                scheduler.start();
                log.info("定时任务开启: " + jobName);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public void stopCronJob(String jobName, String jobGroup, SchedulerFactoryBean schedulerFactoryBean) {
        try {
            Scheduler scheduler = schedulerFactoryBean.getScheduler();
            JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
            if (scheduler.deleteJob(jobKey)) {
                log.info("定时任务关闭: " + jobName);
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
}

3. 创建监听器

package com.wd.listener;

import com.wd.job.Cron2Job;
import com.wd.job.CronJob;
import com.wd.job.utils.QuartzManageKit;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.event.ApplicationStartedEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Component;

/**
 * @author wd
 * @date 21-5-12
 */
@Configuration
@Component
@Slf4j
public class StartQuartzJobListener implements ApplicationListener<ApplicationStartedEvent> {


    @Autowired
    private SchedulerFactoryBean schedulerFactoryBean;

    /**
     * 初始启动quartz
     */
    @Override
    public void onApplicationEvent(ApplicationStartedEvent event) {
        log.info("定时任务监听器启动");
        QuartzManageKit quartzManageKit = new QuartzManageKit();
        // 如果cron等做了修改, 需要先stop 再start
//        quartzManageKit.stopCronJob("job1", "group1", schedulerFactoryBean);
//        quartzManageKit.stopCronJob("job2", "group2", schedulerFactoryBean);
        quartzManageKit.startCronJob(Cron2Job.class, "job2", "group2", "*/5 * * * * ?", schedulerFactoryBean);
        quartzManageKit.startCronJob(CronJob.class, "job1", "group1", "*/5 * * * * ?", schedulerFactoryBean);
    }

}

8. 使用SpringBoot的数据源

在这里插入图片描述

在这里插入图片描述

bug–0/1
关注
专栏目录
SpringBoot 整合Quartz（集群）实现定时任务调度
02-14
1、若是部署多台机器，到了时间点，只有一台会执行，其他不会执行。 2、若多个节点其中一个scheduler执行job失败，将会被另外一个scheduler执行
SpringCloud（第 010 篇）简单 Quartz-Cluster 支持集群分布式且支持动态修改时间
weixin_34199335的博客
09-18 239
SpringCloud（第 010 篇）简单 Quartz-Cluster 微服务，支持集群分布式，并支持动态修改 Quartz 任务的 cronExpression 执行时间 - 一、大致介绍 1、根据上一章节的单台测试，本章节修改 Quartz 了支持分布式，因为这是更多的企业开发场景所需要的开发模式； 2、而且在定时任务执行的过程中...
一个简单Quartz微服务————良好扩展性（springcloud,集群）
cpdiem的博客
12-09 2633
一、背景介绍     项目早期为单体应用，近期因业务量上涨，架构逐渐转为springcloud+分布式集群。原先项目中的定时任务主要采用@Scheduled注解方式实现，并且因历史原因，分布散乱，管理不便。@Scheduled注解的定时任务无法直接应用于集群环境，并且服务重启或异常时，任务容易丢失。Quartz支持对数据的持久化，并且有misfire机制，任务不易丢失，同时支持集群设置，分离出的...
SpringCloud整合Quartz
蜗牛学院重庆校区的博客
09-14 4020
一、Quartz简介 Quartz是一个完全由java编写的开源作业调度框架，隶属于OpenSymphony开源组织。Quartz广泛的应用于定时作业业务场景中。 Quartz中的重要组件： 任务（job）：用于编写定时作业完成的具体任务，所得通俗一点，该组件中的方法会在某个具体的时间点执行，该方法中需要我们自己编写工作逻辑。 触发器（Trigger）：任务触发器，用于定义任务的具体执行时机。 调度器（Scheduler）：核心组件，用于管理和调度所有的任务。 监听器（Listener）：监听器，用于动态的
Quartz 任务调用管理工具
Melody_1943的博客
07-06 307
所谓任务调用,就是执行某些具体动作的时间计划我们使用过的最简单的调度方法就是Timer但是Timer的调度功能过于单一,只能是指定时间的延时调用和周期运行而Quartz可以更详细的指定时间,进行计划调用调度器:Scheduler任务:Job触发器:Trigger​ 我们创建一个类,实现这个接口,在方法中编写要进行的操作(执行具体任务)​ 我们还需要一个JobDetail的类型的对象,Quartz每次执行job时​ 会实例化job类型对象,去调用这个方法,JobDetail是用来描述Job实现类​ 的静
springboot 集成 quartz 集群 加 sql 等
03-13
springboot 集成 quartz 集群 加 sql 等 文章介绍 单机加集群都有 https://blog.csdn.net/weixin_42749765/article/details/88532413
基于SpringBoot+Spring Cloud集成了50+个demo的项目示例.zip
最新发布
02-20
基于SpringBoot+SpringCloud集成了50+个demo的项目示例.zip spring boot demo 是一个Spring Boot、Spring Cloud的项目示例，根据市场主流的后端技术，共集成了50+个demo，未来将持续更新。该项目包含helloworld(快速...
Spring cloud spring boot spring boot admin
07-09
Spring Cloud是基于Spring Boot构建的一套微服务治理框架，它为开发者提供了在分布式系统（如配置管理、服务发现、断路器、智能路由、微代理、控制总线、一次性令牌、全局锁、领导选举、分布式会话、集群状态）操作...
spring boot + quartz 动态管理 分布式
08-29
Spring Boot简化了Spring应用的初始搭建以及开发过程，提供了开箱即用的功能，而Quartz则是一个强大的任务调度库，常用于实现定时任务。 Spring Boot是一个基于Spring框架的快速开发工具，它通过预配置的starter ...
spring-boot 定时任务集群
07-01
1. **任务调度中心**：引入Quartz或者Spring Cloud Task等第三方任务调度框架，将任务调度中心化，各节点只负责执行任务，不负责调度。 2. **任务分配与协调**：使用如Zookeeper或Etcd等分布式协调服务，来管理和...
spring + quartz 集群配置
01-18
java + quartz实现定时任务,实现集群配置,在集群环境下多节点运行定时Quartz定任务，就会存在重复处理任务的现象，为解决这一问题，下面我将介绍使用 Quartz 的 TASK （ 12 张表）实例化到数据库，基于数据库自动管理协调每个节点的定时任务的启动、关闭。
Spring Quartz Job 集群 终极解决方案
05-31
最近公司项目上线，需要把app部署在多台服务器上，但只能让其中一台服务器的job执行，一台服务器挂了，另一台还能继续执行job,通过网上查找资料，都是java工程的方式，不好部署并测试，经过二天辛苦整合，终于整理成一个单spring web方式的工程，连接oracle数据库用tomcat即可完美运行.希望能帮到大家。按网上的方法，配置了很多遍，都不成功，我这个保证你成功运行。 运行工程前需求初使化12张表，见工程下tables_oracle.sql
SpringCloud 整合 Quartz 支持集群，支持动态修改 Quartz 执行时间
YLIMH_HMILY的专栏
09-16 8148
SpringCloud 整合 Quartz 支持集群，支持动态修改 Quartz 执行时间一、添加 maven 引用包<dependencies> <!-- 访问数据库模块 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-start
quarter java_Spring系列——springboot整合quarter定时任务
weixin_36212240的博客
02-16 911
简介本文主要介绍Spring系列Springboot整合quarter定时任务，大致分为三个部分：添加jar包、创建一个定时任务的配置类、创建具体执行的任务，希望看完本文后对大家有所帮助。一、添加jar包org.springframework.bootspring-boot-starter-quartz二、创建一个定时任务的配置类可以理解为 这个类要去执行什么任务，什么时候去执行package c...
SpringCloud（第 054 篇）简单 Quartz-Cluster 微服务，采用注解配置 Quartz 分布式集群...
weixin_34320724的博客
12-17 310
SpringCloud（第 054 篇）简单 Quartz-Cluster 微服务，采用注解配置 Quartz 分布式集群 - 一、大致介绍 1、因网友提到有没有采用注解式配置的Quartz例子，因此本人就贴上了这样一个样例； 2、至于如何修改定时任务的 cronExpression 表达式值的话，大家可以参照之前的（第 010 篇）样子...
架构序列四：springCloud的Quartz调度集群搭建及使用--回馈广大朋友
qq_21761845的博客
06-25 363
首先感谢所有关注我的朋友，在此我将作出承诺：作者之前的所有文章不收费，将来发表的所有文章也永久免费。包括:订阅号、CSDN、知乎.......等。 同时我也非常感激我们一起学习，一起成长的伙伴们，是你们的激励让我不断成长。 看过我之前文章的朋友们可能会发现这次的文章标题好像和之前的一样，难道要再写一次不成？ 根据很多朋友反馈，上次那篇文章讲的不错(看到评论我真的很开心)，就是可惜没有源码。所以我非常感激"韩某"、"蒋某某"、"张某某"、"old程序员"以及"我很菜"、"ts...
spring cloud 集成 quartz (注解方式）
xgw的专栏
12-29 1200
相比于scheduler，quartz支持分布式、持久化。当你部署多个实例时，定时任务会在多个实例上调度执行，提升了处理能力，同时多个实例也不会重复执行同一任务。而且也保证了服务的可靠性和高可用。 依赖 implementation("org.springframework.boot:spring-boot-starter-quartz") 现在我都用gradle进行依赖管理，比maven简洁和智能。 gradle后台使用的也是maven源。 配置 application.yml spring:
SpringCloud Quartz-Cluster 微服务，采用注解配置 Quartz 分布式集群，一直一台服务器运行
编程之美
10-17 3332
一、大致介绍 1、因网友提到有没有采用注解式配置的Quartz例子，因此本人就贴上了这样一个样例； 2、至于如何修改定时任务的 cronExpression 表达式值的话，大家可以参照之前的（第 010 篇）样子看看如何修改； 3、注意：配置文件中的 mysql 数据库链接配置大家就各自配置自己的哈； 二、实现步骤 2.1 添加 maven 引用包 &lt;?xml version="1.0" ...
quartz定时器设置线程个数_Springcloud项目集成Quartz定时任务框架，实现批处理功能...
weixin_39584405的博客
11-23 432
一、Quartz简介 主要做定时任务，即：在指定时间点或时间段，执行某项任务，可设置执行次数、时间间隔等。二、Springcloud简介 对比传统的、庞大的、复杂的、以ssm或ssh为框架的web项目而言，springcloud显得格外轻巧，不错乱，易管理，至少模块清晰，功能明确。三、Springcloud集成quartz 就个人理解，quartz可集成到某个功能模块，也可以单独做一个服务(功能模...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值