Spring MVC、Spring Boot 分别集成 Quartz 动态定时任务

最新推荐文章于 2024-06-07 00:08:34 发布
最新推荐文章于 2024-06-07 00:08:34 发布
阅读量339 收藏 1
点赞数
分类专栏： Spring Boot 文章标签： Spring Boot Quartz 定时器 Spring MVC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33576276/article/details/88867625
版权

为什么要用Quartz

我们都知道Spring Boot自带定时器：@Scheduled(cron="0/1 * * * * ?")（记得在启动类加上注解@EnableScheduling），这样就已经实现了定时器的功能。
那么为什么还要用Quartz呢？ Quartz更容易管理，在多任务时，更方便的去动态配置，能实现动态关闭开启效果。

Quartz表达式（Cron）

cron="0/1 * * * * ?"

名称是否必须允许值特殊字符
秒是0-59- * /
分是0-59- * /
时是0-23- * /
日是1-31- * ? / L W C
月是1-12 或 JAN-DEC- * /
周是1-7 或 SUN-SAT- * ? / L C #
年否空 或 1970-2099- * /

特殊字符

特殊字符意义
*表示所有值
?表示未说明的值，即不关心它为何值
-表示一个指定的范围
,表示附加一个可能值
/符号前表示开始时间，符号后表示每次递增的值

实例

表达式意义
“0 0 12 * * ?”每天中午12点触发
“0 15 10 ? * *”每天上午10:15触发
“0 15 10 * * ?”每天上午10:15触发
“0 15 10 * * ? *”每天上午10:15触发
“0 15 10 * * ? 2005”2005年的每天上午10:15触发
“0 * 14 * * ?”在每天下午2点到下午2:59期间的每1分钟触发
“0 0/5 14 * * ?”在每天下午2点到下午2:55期间的每5分钟触发
“0 0/5 14,18 * * ?”在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发
“0 0-5 14 * * ?”在每天下午2点到下午2:05期间的每1分钟触发
“0 10,44 14 ? 3 WED”每年三月的星期三的下午2:10和2:44触发
“0 15 10 ? * MON-FRI”周一至周五的上午10:15触发
“0 15 10 15 * ?”每月15日上午10:15触发
“0 15 10 L * ?”每月最后一日的上午10:15触发
“0 15 10 ? * 6L”每月的最后一个星期五上午10:15触发
“0 15 10 ? * 6L 2002-2005”2002年至2005年的每月的最后一个星期五上午10:15触发
“0 15 10 ? * 6#3”每月的第三个星期五上午10:15触发

代码走起

pom文件添加依赖包

		<!-- quartz 定时器 -->
		<dependency>
			<groupId>org.quartz-scheduler</groupId>
			<artifactId>quartz</artifactId>
			<version>2.3.0</version>
		</dependency>

初始注入scheduler

Spring Boot是在启动类加上@Bean的注入

	/**
	 * 初始注入scheduler
	 * @return
	 * @throws SchedulerException
	 */
	@Bean
	public Scheduler scheduler() throws SchedulerException {
		SchedulerFactory schedulerFactoryBean = new StdSchedulerFactory();
		return schedulerFactoryBean.getScheduler();
	}

Spring MVC是在applicationContext.xml加上下面代码

    <!-- ============================================定时任务========================= -->
    <!-- -------------这段是为了项目启动自动执行定时任务-----开始----------- -->
    <!-- 这个类用来做需要完成的业务-->
     <bean id="myJob2" class="com.xxx.xxxx.xxxxx.myJob2"></bean>
     <!--定义调用对象和调用对象的方法，这个配置和普通的一样的,id是JobDetail的名字-->
    <bean id="jobtask" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <!-- 调用的类  -->
        <property name="targetObject" ref="myJob2" />
        <!-- 调用类中的方法  -->
        <property name="targetMethod" value="doSomething" />
        <!-- 是否并发  -->
        <property name ="concurrent" value ="false"  />
    </bean>
     <!--定义触发时间 ，这边就不同了，这里必须将时间设置成无限长，因为我们要去读取数据库的时间来做为定时器的触发时间-->
     <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean ">
        <property name="jobDetail" ref="jobtask" />
        <!-- cron表达式  -->
        <property name="cronExpression" value="0/1 * * * * ?" />
    </bean>
<!-- -------------这段是为了项目启动自动执行定时任务-------结束--------------- -->
    <!-- 总管理类 如果将lazy-init='false'那么容器启动就会执行调度程序  -->
    <bean id="startQuertz" lazy-init="true" autowire="no" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <!--<ref bean="cronTrigger" />-->
            </list>
        </property>
    </bean>
    <!--这个类是用来设置触发时间的， startJobs方法启动调度容器，然后按照上面触发器每隔1s执行所配置的myJob2.doSomething()方法 -->
    <bean id="quartzManager" class="com.xxx.xxxxx.xxxx.QuartzScheduler" lazy-init="false" init-method="startJobs" >
        <!--这个对象一定要注入，这样类才能进行管理，还有在类型要用get set方法，不然会报错。-->
        <property name="scheduler" ref="startQuertz" />
    </bean>
    <!-- =================================定时任务================================== -->

注意：其实不管是Spring Boot 还是Spring MVC 哪种方式，都是为了交给Spring这个容器进行管理

新建一个任务调度处理类


import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;

/**
 * 任务调度处理
 * Created by LMD on 2019/3/28.
 */

@Configuration
public class QuartzScheduler {

    // 任务调度
    @Autowired
    private Scheduler scheduler;

    /**
     * @Description: 添加一个定时任务
     *
     * @param jobName 任务名
     * @param jobGroupName  任务组名
     * @param triggerName 触发器名
     * @param triggerGroupName 触发器组名
     * @param jobClass  任务
     * @param cron   时间设置，参考quartz说明文档
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public void addJob(String jobName, String jobGroupName,
                       String triggerName, String triggerGroupName, Class jobClass, String cron) {
        try {
            // 任务名，任务组，任务执行类
            JobDetail jobDetail= JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();

            // 触发器
            TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
            // 触发器名,触发器组
            triggerBuilder.withIdentity(triggerName, triggerGroupName);
            triggerBuilder.startNow();
            // 触发器时间设定
            triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
            // 创建Trigger对象
            CronTrigger trigger = (CronTrigger) triggerBuilder.build();
            // 调度容器设置JobDetail和Trigger
            scheduler.scheduleJob(jobDetail, trigger);

            // 启动
            if (!scheduler.isShutdown()) {
                scheduler.start();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @Description: 修改一个任务的触发时间
     *
     * @param jobName
     * @param jobGroupName
     * @param triggerName 触发器名
     * @param triggerGroupName 触发器组名
     * @param cron   时间设置，参考quartz说明文档
     */
    public void modifyJobTime(String jobName,
                              String jobGroupName, String triggerName, String triggerGroupName, String cron) {
        try {
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            if (trigger == null) {
                return;
            }

            String oldTime = trigger.getCronExpression();
            if (!oldTime.equalsIgnoreCase(cron)) {
                /** 方式一 ：调用 rescheduleJob 开始 */
                // 触发器
                TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
                // 触发器名,触发器组
                triggerBuilder.withIdentity(triggerName, triggerGroupName);
                triggerBuilder.startNow();
                // 触发器时间设定
                triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
                // 创建Trigger对象
                trigger = (CronTrigger) triggerBuilder.build();
                // 方式一 ：修改一个任务的触发时间
                scheduler.rescheduleJob(triggerKey, trigger);
                /** 方式一 ：调用 rescheduleJob 结束 */

                /** 方式二：先删除，然后在创建一个新的Job  */
                //JobDetail jobDetail = scheduler.getJobDetail(JobKey.jobKey(jobName, jobGroupName));
                //Class<? extends Job> jobClass = jobDetail.getJobClass();
                //removeJob(jobName, jobGroupName, triggerName, triggerGroupName);
                //addJob(jobName, jobGroupName, triggerName, triggerGroupName, jobClass, cron);
                /** 方式二 ：先删除，然后在创建一个新的Job */
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @Description: 移除一个任务
     *

     * @param jobName 任务名
     * @param jobGroupName  任务组名
     * @param triggerName 触发器名
     * @param triggerGroupName 触发器组名
     */
    public void removeJob(String jobName, String jobGroupName,
                          String triggerName, String triggerGroupName) {
        try {
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);

            scheduler.pauseTrigger(triggerKey);// 停止触发器
            scheduler.unscheduleJob(triggerKey);// 移除触发器
            scheduler.deleteJob(JobKey.jobKey(jobName, jobGroupName));// 删除任务
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @Description:启动所有定时任务
     */
    public void startJobs() {
        try {
            scheduler.start();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @Description:关闭所有定时任务
     */
    public void shutdownJobs() {
        try {
            if (!scheduler.isShutdown()) {
                scheduler.shutdown();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
测试
 @Autowired
    private QuartzScheduler quartzScheduler;
    /**
     * 开启 Quartz
     * @return
     * @throws MyException
     */
    @RequestMapping(value = "/system/quartzAll")
    public void quartzAll() throws MyException {

        try {
            System.out.println("【系统启动】开始......");

            System.out.println("【增加job1启动】开始(每1秒输出一次)...");//0/10 * * * * ?
            quartzScheduler.addJob("job1", "job1", "job1", "job1", MyJobAppoint.class, "0/1 * * * * ? *");

            Thread.sleep(5000);
            System.out.println("【修改job1时间】开始(每2秒输出一次)...");
            quartzScheduler.modifyJobTime("job1", "job1", "job1", "job1", "0/2 * * * * ?");

            Thread.sleep(10000);
            System.out.println("【移除job1定时】开始...");
            quartzScheduler.removeJob("job1", "job1", "job1", "job1");

            System.out.println("【增加job2启动】开始(每1秒输出一次)...");//0/10 * * * * ?
            quartzScheduler.addJob("job2", "job2", "job2", "job2", MyJobAppoint.class, "0/1 * * * * ? *");
        } catch (Exception e) {
            e.printStackTrace();
        }

    }


    /**
     * 关闭 Quartz
     * @return
     * @throws MyException
     */
    @RequestMapping(value = "/system/closeQuartz")
    @ResponseBody
    public void closeQuartz() throws MyException {

        try {
            System.out.println("【移除全部定时】");//0/10 * * * * ?
            // 关掉任务调度容器
            quartzScheduler.shutdownJobs();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

运行项目，调用对应的接口，控制台就打印如下日志：

2019-03-28 10:56:02.448  INFO 22948 --- [-nio-80-exec-10] c.s.companycms.config.LoginInterceptor   : request: 请求地址 path [/api/system/quartzAll] uri [/api/system/quartzAll]
【系统启动】开始......
【增加job1启动】开始(每1秒输出一次)...
2019-03-28 10:56:02.470  INFO 22948 --- [-nio-80-exec-10] org.quartz.core.QuartzScheduler          : Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED started.
2019-03-28 10:56:02: MyJobAppoint 1 doing......
2019-03-28 10:56:03: MyJobAppoint 1 doing......
2019-03-28 10:56:04: MyJobAppoint 1 doing......
2019-03-28 10:56:05: MyJobAppoint 1 doing......
2019-03-28 10:56:06: MyJobAppoint 1 doing......
2019-03-28 10:56:07: MyJobAppoint 1 doing......
【修改job1时间】开始(每2秒输出一次)...
2019-03-28 10:56:08: MyJobAppoint 1 doing......
2019-03-28 10:56:10: MyJobAppoint 1 doing......
2019-03-28 10:56:12: MyJobAppoint 1 doing......
2019-03-28 10:56:14: MyJobAppoint 1 doing......
2019-03-28 10:56:16: MyJobAppoint 1 doing......
【移除job1定时】开始...
【增加job2启动】开始(每1秒输出一次)...
2019-03-28 10:56:17.474  INFO 22948 --- [-nio-80-exec-10] org.quartz.core.QuartzScheduler          : Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED started.
2019-03-28 10:56:17: MyJobAppoint 1 doing......
2019-03-28 10:56:18: MyJobAppoint 1 doing......
2019-03-28 10:56:19: MyJobAppoint 1 doing......
2019-03-28 10:56:20: MyJobAppoint 1 doing......
2019-03-28 10:56:21: MyJobAppoint 1 doing......
2019-03-28 10:56:22: MyJobAppoint 1 doing......
2019-03-28 10:56:23: MyJobAppoint 1 doing......
2019-03-28 10:56:24: MyJobAppoint 1 doing......
2019-03-28 10:56:25: MyJobAppoint 1 doing......
2019-03-28 10:56:26: MyJobAppoint 1 doing......
2019-03-28 10:56:27: MyJobAppoint 1 doing......
2019-03-28 10:56:28: MyJobAppoint 1 doing......
2019-03-28 10:56:29: MyJobAppoint 1 doing......
2019-03-28 10:56:30: MyJobAppoint 1 doing......
2019-03-28 10:56:31: MyJobAppoint 1 doing......
2019-03-28 10:56:32: MyJobAppoint 1 doing......
2019-03-28 10:56:32.550  INFO 22948 --- [p-nio-80-exec-1] c.s.companycms.config.LoginInterceptor   : request: 请求地址 path [/api/system/closeQuartz] uri [/api/system/closeQuartz]
【移除全部定时】

最后

谢谢大家的参考、阅读；
可能大家在实际写代码的过程中有不一样的异常出错，大家可以留言一起讨论学习。

小小小丶老鼠
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[整理]在Spring MVC中使用Quartz实现定时任务动态管理
码U、me的专栏
12-12 5832
动态管理项目中的定时任务。
SpringMvc+quartz整合
inspurs06的博客
09-02 3487
一、简介：Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。Quartz的最新版本为Quartz 2.3.0。 二、因为定时调度，在很多业务上面都会涉及，想要根据...
SpringMVC：Quartz定时任务，新手完全手册
最新发布
一些平时在开发过程中遇到的常见问题，分享给大家
06-07 486
SpringMVC：Quartz定时任务，新手完全手册
springboot项目中同时使用websocket,自带定时任务@Scheduled启动项目时报错
qq_42828901的博客
08-30 282
解决办法：增加配置文件。
SpringMVC利用Quartz实现可配置的定时器
04-22
待完善。简单的例子，免费下载。参考http://www.meiriyouke.net/?p=82 谢谢原作者 也谢谢ZJ
Quartz集成springMVC 的方案二（持久化任务、集群和分布式）
Ryan Z 的技术日志
10-29 892
Quartz是一个开放源码项目，专注于任务调度器，提供了极为广泛的特性如持久化任务，集群和分布式任务等。 Quartz核心是调度器，还采用多线程管理。   1.持久化任务：当应用程序停止运行时，所有调度信息不被丢失，当你重新启动时，调度信息还存在，这就是持久化任务。   2.集群和分布式处理：当在集群环境下，当有配置Quartz的多个客户端时（节点），采用Quartz的集群
SpringMVC集成Quartz2.3.2
橙子88的博客
02-05 1852
SpringMVC集成Quartz2.3.2集成Quartz持久化下载jar导入jar包配置properties配置xml数据源导入数据表xml配置中用到的工厂类自定义JobController层Service层如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 集成Quartz持久化 Quartz是一个完
SpringBoot集成quartz实现动态定时任务
xxgaojiashuo的博客
09-11 1406
SpringBoot集成quartz实现动态定时任务 （1）Quartz简介 Quartz三大组件： 一、调度器scheduler 二、任务job 三、触发器tigger 1、job：job是一个接口，通过实现job接口，可实现需要定时执行的代码逻辑。 2、JobDetail：JobDetail主要是用来描述job的相关信息，比如任务在scheduler中的组名等信息，job的子类。 2、tigger：可以通过cron表达式设置定时任务的触发时间。 3、scheduler：JobDetail和tigger需
SpringBoot两种定时任务(Spring Schedule 与 Quartz 整合 )实现
liinux-Talk is cheap,show me the code.
05-24 408
前言 最近在项目中使用到定时任务，之前一直都是使用Quartz 来实现，最近看Spring 基础发现其实Spring 提供 Spring Schedule 可以帮助我们实现简单的定时任务功能。 下面说一下两种方式在Spring Boot 项目中的使用。 Spring Schedule 实现定时任务 Spring Schedule 实现定时任务有两种方式 1. 使用XML配置定时任务， 2. 使用 @Scheduled 注解。 因为是Spring Boot 项目 可能尽量避免使用XML配置的形式，主要说
Spring Boot+Apache Shiro+Spring MVC+MyBatis+Quartz+Druid DEMO
03-30
这是一个基于Spring Boot、Apache Shiro、Spring MVC、MyBatis、Quartz和Druid的数据源管理框架的示例项目，名为"renren-security"。这个DEMO提供了完整的权限管理和任务调度解决方案，下面是这些技术栈的核心知识点...
schedule-job：基于Spring Boot + Quartz的分布式任务调度系统
02-05
集成了分布式任务调度框架Quartz ，任务存储于数据库。 使用SpringMVC作为路由控制，集成的SWagger2提供实时RESTful API文档。 数据持久层集成Mybatis框架。 使用自定义注释解@TargetDataSource实现了多数据源动态...
IntelliJ IDEA中创建Spring boot项目，定时任务测试
01-16
4. **添加依赖**：在Dependencies（依赖）一栏，可以通过搜索框添加Spring Boot的定时任务支持，即`spring-boot-starter-quartz`或`spring-boot-starter-task`。后者是Spring Boot官方推荐的定时任务解决方案。 5. ...
Spring Boot实战派（源码）
05-31
- 使用`@Scheduled`注解实现定时任务，或者集成Quartz或CronTrigger。 11. **消息传递** - Spring Boot支持集成RabbitMQ、Kafka等消息中间件，使用`@RabbitListener`或`@KafkaListener`处理消息。 12. **缓存** ...
spring boot教程源码
03-05
它集成了大量的常用第三方库配置，如 JDBC、MongoDB、JPA、RabbitMQ、Quartz 等，使得开发者可以快速地创建出一个生产级别的基于 Spring 的应用程序。 在提供的"spring boot教程源码"中，我们可以看到按照章节进行...
java后台权限管理系统源码（spring boot+mvc+mybatis）.zip
04-22
项目基于jdk1.8整合了springboot+mvc+mybatis(通用mapper)+druid+jsp+bootstrap等技术,springboot+Listener(监听器),Filter(过滤器),Interceptor(拦截器),Servlet,springmvc静态资源,文件上传下载,多数据源切换,缓存...
spring bootweb案例
06-19
它集成了大量常用的第三方库配置，如 JDBC、MongoDB、RabbitMQ、Quartz 等，让开发者可以快速地创建出稳定且生产级别的基于 Spring 的服务。 在"spring bootweb案例"中，我们关注的是如何使用 Spring Boot 构建 Web...
如何在SpringMVC中集成quartz
zhangxing
08-22 626
1.quartz介绍    Quartz是一个完全由Java编写的开源作业调度框架，为在Java应用程序中进行作业调度提供了简单却强大的机制。Quartz允许开发人员根据时间间隔来调度作业。它实现了作业和触发器的多对多的关系，还能把多个作业与不同的触发器关联。 2.集成方案 ①pom依赖 dependency> org.quartz-scheduler quartz 1
springMVC+Quartz实现定时任务(2)—配置文件详解
城南蝈蝈
02-05 878
原文链接：这里 0.前言 项目需要使用定时任务来触发一些操作，然后接触到quartz这个。花了几分钟看懂了怎么用，这篇文章主要记录下quartz的一些配置用法。 注:本文不涉及从0开始，如何配置quartz，而是说明quartz配置好后如何使用。 需要看从0开始，如何配置quartz的，请看这篇文章。 1.配置文件 在xml配置文件中大概需要4部分。xxxx.xml 1.要调用的工作类 2.定义调用对象和调用对象的方法 3.定义触发时间 4.配置总调度类 1.定义要调用的工作类 这个地方的id的名字可以随
SpringMVC引入QUARTZ定时器原理分析学习
pengShuai007的博客
07-23 503
整体流程： 系统初始化时，加载quartz.properties配置文件，获取定时器相关配置，包括定时器相关表前缀，jobstore实现类等配置；系统启动完成后，将数据库配置的定时器信息以bean的形式注册，然后使用监听器监听Job、Trigger等。(红色字体部分暂时不是完全理解); 定时器初始化完成以后，具体定时器通过调用job接口的execute方法实现业务逻辑的定时处理； quart...
spring boot+quartz实现定时任务管理
06-10
下面是一个使用Spring Boot、Quartz和Spring MVC实现定时任务管理的示例： 首先，在你的Spring Boot应用程序中添加Quartz和Spring MVC的依赖项： ```xml <groupId>org.quartz-scheduler <artifactId>quartz ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值