springboot 整合quartz (三):jobStores

最新推荐文章于 2023-12-22 16:53:41 发布
最新推荐文章于 2023-12-22 16:53:41 发布
阅读量8.6k 收藏 10
点赞数 3
分类专栏： quartz
本文为博主原创文章，欢迎转载，欢迎更正，QQ:270698050
本文链接：https://blog.csdn.net/qq_21434959/article/details/83119981
版权

layout: blog
istop: true
title: “springboot 整合quartz (三):jobStores”
date: 2018-10-09
category: springboot
tags:

  • springboot
  • quartz

JobStore介绍

JobStore是负责跟踪调度器中所有的工作数据：作业任务、触发器、日历等。在配置文件(quartz.properties)中定义JobStore的形式，JobStore有两种RAMJobStore和JDBCJobSTore

  • RAMJobStore :配置简单，速度快，但程序停止，数据丢失
  • JDBCJobSTore :配置略微复杂，可以保存数据

RAMJobStore

quartz.properties

org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore

OK了，不需要别的配置，直接启动正常运行?就好。

JDBCJobStore

下载sql文件

下载地址:点击下方的Download now

  • sql位置：quartz解压根目录/docs/dbTables
  • mysql中创建test数据库执行sql文件

配置文件

quartz.properties(这里只给出主要配置,全部配置:参见github源码)

# 持久化配置（存储方式使用JobStoreTX，也就是数据库）
org.quartz.jobStore.class:org.quartz.impl.jdbcjobstore.JobStoreTX

#数据库中quartz表的表名前缀
org.quartz.jobStore.tablePrefix:qrtz_
org.quartz.jobStore.dataSource:myQuartzDB

#是否使用集群（如果项目只部署到 一台服务器，就不用了）
org.quartz.jobStore.isClustered = true

#============================================================================
# Configure Datasources配置数据源(可被覆盖，如果在schedulerFactoryBean指定数据源)
#============================================================================

org.quartz.dataSource.myQuartzDB.driver:com.mysql.jdbc.Driver
org.quartz.dataSource.myQuartzDB.URL:jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8
org.quartz.dataSource.myQuartzDB.user:root
org.quartz.dataSource.myQuartzDB.password:root123
org.quartz.dataSource.myQuartzDB.maxConnections:10

OK了，正常启动运行。

数据库查看

cronTrigger运行的话，数据保存部分表如下：

QRTZ_CRON_TRIGGERS：
    TRIGGER_NAME、 
    TRIGGER_GROUP、
    TRIGGER_EXPRESSION
QRTZ_JOB_DETAIL:
    JOB_NAME、
    JOB_GROUP、
    JOB_CLASS_NAME
QRTZ_TRIGGERS:
    TRIGGER_NAME、
    TRIGGER_GROUP、
    JOB_NAME、
    JOB_GROUP、
    JOB_CLASS_NAME、
    START_TIME、
    NEXT_FIRE_TIME、
    PREV_FIRE_TIM、
    MISFIRE_INSTR

注：从字段可以看出QRTZ_TRIGGERS是一个整合表

springboot-quartz配置JDBCJobStore

pom.xml

        <!-- quartz -->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>


        <!-- MySQL驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

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


        <!-- druid数据源驱动 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>

注：spring-context-support是spring为了整合quartz及其他框架的中间环境包

applicatin.yml

server:
  port: 8080
  tomcat:
    uri-encoding: utf-8
spring:
  datasource:
    druid:
      # 数据库访问配置, 使用druid数据源 
      type: com.alibaba.druid.pool.DruidDataSource
      driverClassName: com.mysql.jdbc.Driver
      url: jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8
      username: root
      password: root123
    name: anhusky

quartz.properties

#============================================================================
#基础配置
#============================================================================

# 设置调度器的实例名(instanceName) 和实例ID (instanceId)
org.quartz.scheduler.instanceName: MyScheduler
#如果使用集群，instanceId必须唯一，设置成AUTO
org.quartz.scheduler.instanceId = AUTO

#============================================================================
#调度器线程池配置
#============================================================================

org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
# 指定多少个工作者线程被创建用来处理 Job
org.quartz.threadPool.threadCount: 20
# 设置工作者线程的优先级（最大值10，最小值1，常用值5）
org.quartz.threadPool.threadPriority: 5


#============================================================================
#Configure JobStore 作业存储配置
#============================================================================

# 持久化配置（存储方式使用JobStoreTX，也就是数据库）
org.quartz.jobStore.class:org.quartz.impl.jdbcjobstore.JobStoreTX

#数据库中quartz表的表名前缀
org.quartz.jobStore.tablePrefix:qrtz_
org.quartz.jobStore.misfireThreshold: 5000

#是否使用集群（如果项目只部署到 一台服务器，就不用了）
org.quartz.jobStore.isClustered = false

SchduleConfig:为ScheduleFactoryBean配置mysql数据源

/**
 * 定时任务配置
 *
 * @author Administrator
 */
@Configuration
public class ScheduleConfig {

    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(DataSource dataSource) throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setDataSource(dataSource);


        // quartz参数
        factory.setQuartzProperties(quartzProperties());

        factory.setSchedulerName("MyScheduler");
        // 延时启动
        factory.setStartupDelay(1);
        factory.setApplicationContextSchedulerContextKey("applicationContextKey");
        // 可选，QuartzScheduler
        // 启动时更新己存在的Job，这样就不用每次修改targetObject后删除qrtz_job_details表对应记录了
        factory.setOverwriteExistingJobs(true);
        // 设置自动启动，默认为true
        factory.setAutoStartup(true);


        /*
        CronTriggerFactoryBean cronTriggerFactoryBean = new CronTriggerFactoryBean();
        cronTriggerFactoryBean.setJobDetail(
                JobBuilder.newJob(ScheduleJob.class).build());
        cronTriggerFactoryBean.setStartDelay(3000);
        cronTriggerFactoryBean.setCronExpression("0/10 * * * * ?");
        // 通过这个设置 在项目启动时启动
        factory.setTriggers(cronTriggerFactoryBean.getObject());
        */

        return factory;
    }

    /**
     * 加载Quartz配置
     *
     * @return
     * @throws IOException
     */
    @Bean
    public Properties quartzProperties() throws IOException {
        //使用Spring的PropertiesFactoryBean对属性配置文件进行管理
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        //注意：quartz的配置文件从指定系统目录中获取，而不是从classpath中获取
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        //propertiesFactoryBean.setLocation(new FileSystemResource(propertiesPath));
        //重要：保证其初始化
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }
}

JobController

@RequestMapping(value = "/job")
@Controller
public class JobController {

    @Autowired
    private Scheduler scheduler;
 ``/**
     * 添加定时任务
     */
    @PostMapping("/addJob")
    @ResponseBody
    public Map<String, String> addJob(@RequestParam(value = "jobClassName") String jobClassName,
                                      @RequestParam(value = "jobGroupName") String jobGroupName,
                                      @RequestParam(value = "cronExpression") String cronExpression) {
        Map<String, String> returnData = new HashMap<>();
        try {

            JobDetail jobDetail = JobBuilder
                    .newJob(getClass(jobClassName).getClass())
                    .withIdentity("测试-1-jojobdetailbdetail")
                    .build();

            //构建CronTrigger触发器
            CronTrigger cronTrigger = TriggerBuilder
                    .newTrigger()
                    .withSchedule(cronSchedule(cronExpression)
                           .withMisfireHandlingInstructionDoNothing()
                    )
                    .withIdentity("测试-1-cronTrigger")
                    .build();

            //注册调度任务
            scheduler.scheduleJob(jobDetail, cronTrigger);
            //启动任务
            scheduler.start();

            returnData.put("msg", "添加调度任务成功");
        } catch (Exception e) {
            returnData.put("msg", "添加调度任务异常：" + e.getMessage());
        }
        return returnData;
    }
    /**
     * 暂停定时任务
     *
     * @param jobClassName
     * @param jobGroupName
     * @return
     */
    @PutMapping(value = "/pauseJob")
    @ResponseBody
    public Map<String, String> pauseJob(@RequestParam(value = "jobClassName") String jobClassName,
                                        @RequestParam(value = "jobGroupName") String jobGroupName) {
        Map<String, String> returnData = new HashMap<String, String>();
        try {
            //JobKey定义了job的名称和组别
            JobKey jobKey = JobKey.jobKey(jobClassName, jobGroupName);
            //暂停任务
            scheduler.pauseJob(jobKey);

            returnData.put("msg", "暂停调度任务成功");
        } catch (SchedulerException e) {
            returnData.put("msg", "暂停调度任务异常：" + e.getMessage());
        } catch (Exception e) {
            returnData.put("msg", "暂停调度任务异常：" + e.getMessage());
        }

        return returnData;
    }

    /**
     * 启动已经暂停的任务
     *
     * @param jobClassName
     * @param jobGroupName
     * @return
     */
    @PutMapping(value = "/resumeJob")
    @ResponseBody
    public Map<String, String> resumeJob(String jobClassName,
                                         String jobGroupName) {
        Map<String, String> returnData = new HashMap<String, String>();
        try {
            //JobKey定义了job的名称和组别
            JobKey jobKey = JobKey.jobKey(jobClassName, jobGroupName);
            //继续任务
            scheduler.resumeJob(jobKey);
            returnData.put("msg", "继续调度任务成功");
        } catch (SchedulerException e) {
            returnData.put("msg", "继续调度任务异常：" + e.getMessage());
        } catch (Exception e) {
            returnData.put("msg", "继续调度任务异常：" + e.getMessage());
        }

        return returnData;
    }

    /**
     * 更新定时任务：
     * --传入的triggerKey有与之匹配的
     * --旧触发器的触发时间没有完成
     *
     * @param jobClassName
     * @param jobGroupName
     * @param cronExpression
     * @return
     */
    @PutMapping(value = "/rescheduleJob")
    @ResponseBody
    public Map<String, String> rescheduleJob(String jobClassName,
                                             String jobGroupName,
                                             String cronExpression) {
        Map<String, String> returnData = new HashMap<String, String>();
        try {

            //构建旧的TriggerKey
            TriggerKey triggerKey = TriggerKey.triggerKey(jobClassName, jobGroupName);

            //通过cron表达式构建CronScheduleBuilder
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

            //从调度容器中获取旧的CronTrigger
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

            //更新CronTrigger
            trigger = trigger.getTriggerBuilder()
                    .withIdentity(triggerKey)
                    //工作项1：job名以及所属组
                    .withSchedule(scheduleBuilder)
                    //工作项2：指定调度参数
                    .build();//构建

            //更新调度任务
            scheduler.rescheduleJob(triggerKey, trigger);

            returnData.put("msg", "更新调度任务成功");
        } catch (Exception e) {
            returnData.put("msg", "更新调度任务异常：" + e.getMessage());
        }

        return returnData;
    }


    /**
     * @param jobClassName
     * @param jobGroupName
     * @return
     */
    @DeleteMapping(value = "/removeJob")
    @ResponseBody
    public Map<String, String> removeJob(String jobClassName,
                                         String jobGroupName) {
        Map<String, String> returnData = new HashMap<String, String>();
        try {
            //获得调度容器
            //Scheduler scheduler = getCurrentScheduler();
            //TriggerKey定义了trigger的名称和组别
            TriggerKey triggerKey = TriggerKey.triggerKey(jobClassName, jobGroupName);

            //暂停触发器
            scheduler.resumeTrigger(triggerKey);
            //暂停触发器
            scheduler.unscheduleJob(triggerKey);
            //移除任务
            scheduler.deleteJob(JobKey.jobKey(jobClassName, jobGroupName));

            returnData.put("msg", "删除调度任务成功");
        } catch (SchedulerException e) {
            returnData.put("msg", "删除调度任务异常：" + e.getMessage());
        } catch (Exception e) {
            returnData.put("msg", "删除调度任务异常：" + e.getMessage());
        }

        return returnData;
    }


    /**
     * 获得指定的类实例
     *
     * @param classname
     * @return
     * @throws ServerException
     */
    private Job getClass(String classname) throws ServerException {
        Job baseJob = null;
        try {
            //加载参数指定的类
            Class<?> classTmp = Class.forName(classname);
            //实例化
            baseJob = (Job) classTmp.newInstance();
        } catch (Exception e) {
            System.out.println(classname + "......找不到相应的类");
        }

        return baseJob;
    }
}

源码地址：

github地址

简单就好喽
关注
专栏目录
【微服务】springboot整合quartz使用详解
congge_study的博客
12-07 6316
springboot整合quartz详解
Quartz jobStore
maxcode
03-24 1027
JobStore是负责跟踪调度器中所有的工作数据：作业任务、触发器、日历等。JDBCJobStore JDBCJobStore——它通过JDBC将所有的数据保存在数据库中。 JDBCJobStore几乎可以适用于任何数据库，它已经在Oracle,PostgreSQL, MySQL, MS SQLServer, HSQLDB和 DB2数据库中广泛使用。为了使用JDBCJobStore，你
Quartz之 JobStore
dengxiansuo5846的博客
09-05 180
JobStore负责跟踪所有你给scheduler的“工作数据”：jobs, triggers, calendars, 等。 RAMJobStore RAMJobStore 是使用最简单的也是最高效(依据CPU时间)的JobStore 。RAMJobStore 正如它名字描述的一样，它保存数据在RAM。 这就是为什么它是配置最简单的也是最高效的原因。缺点是你的应用结束之后所有的数据...
quartz框架(七)-JobStore
coderchenhao的博客
03-13 2454
JobStore 在之前的博文中，博主已经写了关于Job的相关内容。本篇博文，博主将介绍JobStore相关的内容。 JobStore是存放Job和Trigger的地方。当我们调用Scheduler对象的scheduleJob时就会将其存入JobStore中，然后供quartzSchedulerThread使用。 为什么需要JobStore？ 因为我们需要被Scheduler调用的任务大多数并不是一次性的任务，而是需要被定时触发，或者某个时间点才能被触发的。因此我们需要一个容器来存储Job和Trigger的
Springboot整合quartz产生错误及解决方案
08-19
2. 配置Quartz：在`application.properties`或`application.yml`中设置Quartz的相关配置，例如启动、线程池大小等。 ```properties # application.properties 示例 quartz.job-store-type=memory quartz.scheduler....
SpringBoot整合Quartz
热门推荐
桐花思雨
11-02 4万+
目录`Quartz` 简介 Quartz 简介 Quartz 是一款功能强大的开源任务调度框架，几乎可以集成到任何 Java 应用程序中（小到单机应用，大到分布式应用）。Quartz 可用于创建简单或复杂的任务调度，用以执行数以万计的任务。任务被定义为标准化的 Java 组件，Java 编写的任务都可以被执行 Quartz 是一个任务日程管理系统，一个在预先确定（被纳入日程）的时间到达时，负责执行（或者通知）其他软件组件的系统 Quartz 用一个小 Java 库发布文件（.jar文件），这个库文件包含了所
springboot整合quartz完整项目
11-02
SpringBoot整合Quartz是一个常见的企业级应用开发场景，主要用于实现定时任务管理。Quartz是一个开源的作业调度框架，而SpringBoot则是一个简化Spring应用初始搭建以及开发过程的框架。将两者结合，我们可以轻松地在...
Springboot整合quartz
最新发布
swimming_in_IT_的博客
12-22 1189
Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。官网地址:https://www.quartz-scheduler.org/
定时任务调度框架Quartz--Job Stores
大宇的博客，欢迎访问
07-16 2155
文章目录RAMJobStoreJDBCJobStore RAMJobStore         RAMJobStore是使用最简单的JobStore，它也是性能最高的，因为它直接把Job执行过程中产生的数据存放到内存中。从源码上来看，发现了RAMJobStore中大量使用了HashMap类，所以在服务器宕机重启后，所有数据都丢失了。         
Quartz学习笔记（五）—— JobStore
亦轩丶Javer的博客
03-05 373
JobStore负责跟踪所有的“工作数据”,给调度器、触发器、日历等 //配置RAMJobStore org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore//配置JDBCJobStore org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX //配置JDBCJ
Quartz:Job Stores（Job存储）-09
小贺的博客
07-15 868
Job Stores JobStore负责跟踪您提供给调度程序的所有“工作数据”：jobs，triggers，日历等。为您的Quartz调度程序实例选择适当的JobStore是重要的一步。幸运的是，一旦你明白他们之间的差异，那么选择应该是一个非常简单的选择。 您声明您提供给用于生成调度程序实例的SchedulerFactory的属性文件（或对象）中您的调度程序应使用哪个JobStore（以及它...
Quartz教程 第9课 JobStore
wusandi的专栏
10-22 2524
第9课 JobStore JobStore负责跟踪传递给scheduler的所有工作数据：job、trigger、calendar等等。为你的Quartz调度器实例选择一个合适的JobStore是很重要的一步。幸运地是，一旦你掌握它们之间的区别，选择是很容易的。你应该在配置文件（quartz.properties）中声明你使用的是哪一个JobStore。 注意：从来不要在代码中直接使用JobS
Quartz JobStore
Just for Java —— 学习、标注、分享
01-28 122
Quartz 的内存 Job 存储的能力是由一个叫做 org.quartz.simple.RAMJobStore 类提供了，当如我们所说，它实现了 JobStore 接口的。RAMJobStore 是 Quartz 的开箱即用的解决方案。对此，我们的意思是说，除非你改变了配置，否则在任何 Quartz 应用中都将使用 RAMJobStore quartz.properties [code=...
（翻译）Quartz官方教程——第九课：Job Stores
weixin_34290390的博客
04-20 171
2019独角兽企业重金招聘Python工程师标准>>> ...
Quartz 框架 教程（中文版）2.2.x 之第九课 JobStores
黄鹰的专栏
04-27 3311
第九课 JobStores
Quartz高级部分JobStore
上善若水
05-09 349
JobStore是用来保存你的工作数据的.永远不要在你的代码中使用 JobStore,它都是通过属性文件来配置的. 下面我们做一个RAMJobStore的 例子. 建一个job: package com;import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;import org.q...
SpringBoot整合Quartz实战：定时任务配置与使用解析
"本文将介绍如何在SpringBoot应用中整合Quartz框架来实现定时任务，同时也会提及Spring内置的定时任务支持。" 在Spring Boot项目中，我们常常需要执行一些定时任务，例如定时发送邮件、数据统计或者清理缓存等。...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值