springboot实现quartz管理

最新推荐文章于 2024-09-14 18:17:39 发布
最新推荐文章于 2024-09-14 18:17:39 发布
阅读量5.8k 收藏 17
点赞数 2
分类专栏： quartz spring框架 文章标签： springboot_quartz
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tuesdayma/article/details/81538270
版权

简介

看完上篇之后，你会发现spring自带的schedule确实方便，而且十分简洁。但是我们在平常开发中时常会有面临着需求的改变，比如这个方法本来是中午12点执行的，现在要变成下午1点去执行，然而项目已经上线了，修改源码中@Scheduled注解中的cron表达式显然是不科学的。那么面对这种情况quartz给我们提供了很好的管理功能。

springboot整合quartz

github：：https://github.com/mzd123/springboot_quartz

版本： boot:1.5.9.RELEASE

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.3.0</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>HikariCP-java6</artifactId>
                    <groupId>com.zaxxer</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.31</version>
        </dependency>
        <!-- MySQL驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.7-dmr</version>
        </dependency>
        <!-- mybatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.9</version>
        </dependency>
        <!-- 通用mapper -->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>1.1.5</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

创建表结构： 刚开始学这个的时候，我发现所有关于quartz动态管理的项目表都是一样，最开始我以为都是抄的。每一个有自己想法的，后来我发现，这个表结构是quartz自带的。sql脚本位于：org.quartz.impl.jdbcjobstore包中。
这里写图片描述
quartz表： 这里我用的是：mysql_innodb.sql
这里写图片描述

配置quartz.properties： 

#这个东西随便取的，自己开心就好
org.quartz.scheduler.instanceName=MyScheduler
#最多有5个任务同时在执行，如果有第六个任务将会被搁置
org.quartz.threadPool.threadCount=5
#如果用内存记录定时任务信息，应用重新启动后，定时任务信息将会丢失。
# 比如，用户A通过系统设置1小时后执行Z操作，设置好后的，因系统重新启动，新启动的系统将会丢失“1小时后执行Z操作”的定时任务。
#org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore
#如果，我们需要在系统意外（或非意外）重新启动后，仍保留定时任务信息，可以使用数据库存储定时任务信息。
org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
#方言：org.quartz.impl.jdbcjobstore.StdJDBCDelegate---用于完全符合JDBC的驱动程序
org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#表的前缀--- 默认就是QRTZ_
org.quartz.jobStore.tablePrefix=QRTZ_
#配置quartz数据库，优势就是可以和业务数据库分开，相当于配置了两个数据库
org.quartz.jobStore.dataSource=myDS
org.quartz.dataSource.myDS.driver=com.mysql.cj.jdbc.Driver
org.quartz.dataSource.myDS.URL=jdbc:mysql://localhost:3307/test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&useSSL=false
org.quartz.dataSource.myDS.user=root
org.quartz.dataSource.myDS.password=root
#最大连接数
org.quartz.dataSource.myDS.maxConnections=5

配置quartz.config： 

@Configuration
public class SchedulerConfig {
    @Bean(name = "SchedulerFactory")
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setAutoStartup(true);
        factory.setStartupDelay(5);//延时5秒启动
        factory.setQuartzProperties(quartzProperties());
        return factory;
    }
    @Bean
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        //这个东西如果不配置的话，quartz有自己默认的配置文件
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }
    /*
     * 通过SchedulerFactoryBean获取Scheduler
     */
    @Bean(name = "Scheduler")
    public Scheduler scheduler() throws IOException {
        return schedulerFactoryBean().getScheduler();
    }

}

编写quartz的接口： 

@RestController
public class JobController {
    private final static Logger LOGGER = LoggerFactory.getLogger(JobController.class);
    private final String baseuri = "/job";
    @Autowired
    @Qualifier("Scheduler")
    private Scheduler scheduler;
    @Autowired
    private JobService jobService;

    /**
     * 新增任务
     *
     * @param quartz
     * @return
     */
    @RequestMapping(value = baseuri + "/addschedule")
    public Result save(QuartzBean quartz) throws Exception {
        LOGGER.info("新增任务");
        int i = 100 / 0;
        if (quartz.getOldJobGroup() != null) {
            JobKey key = new JobKey(quartz.getOldJobName(), quartz.getOldJobGroup());
            scheduler.deleteJob(key);
        }
        //获取.class
        Class cls = Class.forName(quartz.getJobClassName());
        cls.newInstance();
        //创建jobdetail
        JobDetail job = JobBuilder.newJob(cls).withIdentity(quartz.getJobName(),
                quartz.getJobGroup())
                //设置参数
                //.usingJobData("aa", "ceshi")
                //描述
                .withDescription(quartz.getDescription())
                .build();
        // 使用cron表达式
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(quartz.getCronExpression());
        Trigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger" + quartz.getJobName(), quartz.getJobGroup())
                .startNow()
                .withSchedule(cronScheduleBuilder)
                .build();
        //交由Scheduler安排触发
        scheduler.scheduleJob(job, trigger);
        return new Result("200", "", null);
    }

    /**
     * 获取任务列表
     *
     * @param name
     * @return
     */
    @RequestMapping(value = baseuri + "/getlist4schedule")
    public Result list(String name) {
        LOGGER.info("任务列表");
        List<QuartzBean> list = jobService.listQuartzBean(name);
        return new Result("200", "", list);
    }

    /**
     * 立即执行
     *
     * @param quartz
     * @return
     */
    @RequestMapping(value = baseuri + "/doschedule")
    public Result trigger(QuartzBean quartz) throws Exception {
        LOGGER.info("立即执行");
        JobKey key = new JobKey(quartz.getJobName(), quartz.getJobGroup());
        scheduler.triggerJob(key);
        return new Result("200", "", null);
    }

    /**
     * 暂停任务
     *
     * @param quartz
     * @return
     */
    @RequestMapping(value = baseuri + "/pauseschedule")
    public Result pause(QuartzBean quartz) throws Exception {
        LOGGER.info("停止任务");
        JobKey key = new JobKey(quartz.getJobName(), quartz.getJobGroup());
        scheduler.pauseJob(key);
        return new Result("200", "", null);
    }

    /**
     * 从暂停中恢复过来
     *
     * @param quartz
     * @return
     */
    @RequestMapping(value = baseuri + "/recoverschedule")
    public Result resume(QuartzBean quartz) throws Exception {
        LOGGER.info("恢复任务");
        JobKey key = new JobKey(quartz.getJobName(), quartz.getJobGroup());
        scheduler.resumeJob(key);
        return new Result("200", "", null);
    }

    /**
     * 删除任务
     *
     * @param quartz
     * @return
     */
    @RequestMapping(value = baseuri + "/deleteschedule")
    public Result remove(QuartzBean quartz) throws Exception {
        LOGGER.info("删除任务");
        TriggerKey triggerKey = TriggerKey.triggerKey(quartz.getJobName(), quartz.getJobGroup());
        // 停止触发器
        scheduler.pauseTrigger(triggerKey);
        // 移除触发器
        scheduler.unscheduleJob(triggerKey);
        // 删除任务
        scheduler.deleteJob(JobKey.jobKey(quartz.getJobName(), quartz.getJobGroup()));
        System.out.println("removeJob:" + JobKey.jobKey(quartz.getJobName()));
        return new Result("200", "", null);
    }
}

编写接口错误拦截返回： 

@ControllerAdvice
public class ErrorController {
    private final static Logger logger = LoggerFactory.getLogger(ErrorController.class);
    @ExceptionHandler(Exception.class)
    @ResponseBody
    public Result error(Throwable throwable) {
        System.out.println("aaa");
        logger.error(throwable.toString());
        return new Result("500", throwable.toString(), null);
    }
}

疑问：

以上代码就能实现springboot对quartz的管理，增删改查、立即执行、暂停、恢复等操作，但是任有不少疑问。。。

1、为什么我们并没有对数据库进行操作，数据库中就有了quartz的数据？

2、 我们配置了threadCount为5，那么如果有5个任务还在执行的时候触发了第六个任务会怎么样？

3、如果任务刚执行完，把系统时间修改为任务触发时间之前，那相同时间还会再触发一次吗？

解决：https://blog.csdn.net/tuesdayma/article/details/81563011

一只仰望天空的菜鸟
关注
专栏目录
【SpringBoot】82、SpringBoot集成Quartz实现动态管理定时任务
Asurplus
06-29 3万+
Quartz 是一个开源的作业调度框架，它完全由 Java 写成，并设计用于 J2SE 和 J2EE 应用中。它提供了巨大的灵 活性而不牺牲简单性。你能够用它来为执行一个作业而创建简单的或复杂的调度。它有很多特征，如：数据库支持，集群，插件，EJB 作业预构 建，JavaMail 及其它，支持 cron-like 表达式等等
【SpringBoot】83、SpringBoot集成Quartz实现调度日志收集
Asurplus
06-29 3万+
Quartz 是一个开源的作业调度框架，它完全由 Java 写成，并设计用于 J2SE 和 J2EE 应用中。它提供了巨大的灵 活性而不牺牲简单性。你能够用它来为执行一个作业而创建简单的或复杂的调度。它有很多特征，如：数据库支持，集群，插件，EJB 作业预构 建，JavaMail 及其它，支持 cron-like 表达式等等
springBoot + Quartz
weixin_40461030的博客
05-01 4671
1. Quartz 概述 Quartz 是 OpenSymphony 开源组织在任务调度领域的一个开源项目，完全基于 Java 实现。该项目于 2009 年被 Terracotta 收购，目前是 Terracotta 旗下的一个项目。读者可以到下载Quartz 的发布版本及其源代码。 2. Quartz特点 作为一个优秀的开源调度框架，Quartz 具有以下特点： 强大的调度功能，例如支持丰富多样的调度方法，可以满足各种常规及特殊需求； 灵活的应用方式，例如支持任务和调度的多种组合方式，支持调度数
Springboot 整合 Quartz（定时任务框架）
原名：@程序员大禹
01-31 5428
Quartz是 OpenSymphony 开源组织在 Job scheduling 领域又一个开源项目，完全由 Java 开发，可以用来执行定时任务，类似于 java.util.Timer。持久性作业 - 就是保持调度定时的状态;作业管理 - 对调度作业进行有效的管理;
【SpringBoot】调度和执行定时任务--Quartz(超详细)
最新发布
qq_45687669的博客
09-14 1546
}} }Job;import org} }import org} }@Overridetry {// 模拟长时间运行的任务 Thread . sleep(5000);} }try {// 模拟长时间运行的任务 Thread . sleep(5000);} }Job;import orgtry {// 模拟长时间运行的任务 Thread . sleep(5000);
spring boot集成quartz
m0_72167535的博客
11-17 2912
创建配置文件实现ApplicationRunner接口，实现run方法，在方法中，首先通过反射方式获取到要执行定时任务的类来创建jobdetail，然后根据执行规则创建执行的触发器trigger，再将jobdetail和trigger放到scheduler容器中，按照规则进行任务的执行。定时任务的全路径名称，执行的触发器以及任务名称，可以存放在数据库中，并在前端追加可视化画面来进行修改，删除及立即执行的功能。Quartz 中需要执行的任务详情，包括了任务的唯一标识和具体要执行的任务，可以通过。
springboot项目中Quartz
PaoShan的博客
03-08 3404
从介绍到用例测试，包含依赖等。。。
springboot集成quartz
学海无涯,我用JAVA
06-14 3645
引用上一篇博客的说法springboot整合xxl-job,集群模式下,定时任务会造成很严重的事故,其次普通的任务也无法做到像xxl-job与Quartz 一样,及时启停,修改等;上一篇介绍了xxl-job,这篇搞一下Quartz,老牌分布式定时任务了;基本实现了任务的动态添加有参数的具体任务调用,修改QuartzJob中的方法获取,参数获取等,但是依旧采用代理实现任务并发执行未处理,后续完善项目地址。
SpringBoot 整合Quartz（集群）实现定时任务调度
02-14
在SpringBoot中集成Quartz，可以充分利用Spring的依赖注入和管理特性，使得任务调度更加便捷和高效。 首先，我们需要在SpringBoot项目中引入Quartz的相关依赖。在`pom.xml`文件中添加Quartz和SpringBoot对Quartz...
Springboot整合Quartz实现定时任务数据库动态配置
03-17
本篇文章将详细探讨如何在Spring Boot项目中整合Quartz，并通过MySQL数据库实现定时任务的动态配置。 首先，我们需要在项目中添加依赖。在Spring Boot的`pom.xml`文件中，引入Spring Boot的`spring-boot-starter-...
SpringBoot整合Quartz
热门推荐
桐花思雨
11-02 4万+
目录`Quartz` 简介 Quartz 简介 Quartz 是一款功能强大的开源任务调度框架，几乎可以集成到任何 Java 应用程序中（小到单机应用，大到分布式应用）。Quartz 可用于创建简单或复杂的任务调度，用以执行数以万计的任务。任务被定义为标准化的 Java 组件，Java 编写的任务都可以被执行 Quartz 是一个任务日程管理系统，一个在预先确定（被纳入日程）的时间到达时，负责执行（或者通知）其他软件组件的系统 Quartz 用一个小 Java 库发布文件（.jar文件），这个库文件包含了所
springbootQuartz
02-22
springboot+quartz集成的定时调度
spring boot集成quartz定时器
01-23
spring boot集成quartz定时器,job支持spring的依赖注入
springboot-quartz
03-17
springboot-quartz项目，下载了就可以快速集成，这是博客地址：https://blog.csdn.net/persistencegoing/article/details/88393039
springboot与quartz框架整合
04-15
个人搭建的一个利用springboot和quartz框架整合的例子，可以进行一些任务的调度。
SpringBoot使用Quartz
weixin_43816557的博客
12-03 5484
所谓"调度"就是制定好的什么时间做什么事情的计划我们使用过的最简单的调度方法就是Timer但是Timer的调度功能过于单一，只能是指定时间的延时调用和周期运行而Quartz可以更详细的指定时间，进行计划调用，是一个当今市面上流行的高效的任务调度管理工具所谓"调度"就是制定好的什么时间做什么事情的计划由OpenSymphony开源组织开发是java编写的,我们使用时需要导入依赖即可
Springboot集成Quartz
nuc_badaomen的博客
06-06 1017
同一个任务是否可以并行执行，可参考第3步设置每次项目重新部署后，自动加载数据库中的定时任务Quartz在发生异常时会重试一次，注意异常处理，可在第3步中处理参考链接：https://juejin.cn/post/7054762566035193869#heading-7。
SpringBoot 整合 Quartz
weixin_57467236的博客
09-04 3712
Spring boot 整合 Quartz 定时器框架
springboot整合Quartz
秋楓的博客
05-26 251
前言 我们在开发系统时，可能会要使用到定时任务模块，目前常用的有：jdk 自带的Timer、ScheduledExecutorService线程池、spring定时任务、Quartz、elastic-job、 XXL-JOB这几个工具，其中后两个是基于Quartz进行开发的。这里我实用的是Quartz，结合springboot。 开发 1.导maven包 <dependency> <groupId>org.springframework.boot</groupId&g
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值