SprinBoot整合Quart实现定时调度的示例代码
作者：赫赫有安 发布时间：2021-12-07 21:30:59
标签：SprinBoot,Quart,定时调度
Quartz是一款开源的定时任务调度框架，Quartz的官网是：http://www.quartz-scheduler.org/。本文主要是讲诉使用springboot整合quartz实现定时任务调度管理的用例。主要的内容有如下三部分：
1. springboot整合quartz的相关配置
2. 实现基于simpleTrigger的定时任务
3. 实现基于cronTrigger的定时任务
一、导入相关的pom依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.bruce.quartz.springboot.demo</groupId>
<artifactId>Quartz-SpringBoot-0426</artifactId>
<version>1.0-SNAPSHOT</version>
<!--导入SpringBoot-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.2.RELEASE</version>
<relativePath />
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!--Quartz任务调度的包 -->
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>
<version>2.2.1</version>
</dependency>
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz-jobs</artifactId>
<version>2.2.1</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
二、创建SpringBoot的启动类
package com.anhong;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
/**
* @BelongsProject: Quartz-SpringBoot-0426
* @BelongsPackage: com.anhong
* @Author: anhong
* @CreateTime: 2020-10-24 09:24
* @Description: TODO
*/
@SpringBootApplication
public class APP {
public static void main(String[] args) {
SpringApplication.run(APP.class,args);
}
/**
* 向Spring容器中初始注入scheduler
*/
@Bean
public Scheduler scheduler() throws SchedulerException {
SchedulerFactory schedulerFactoryBean = new StdSchedulerFactory();
return schedulerFactoryBean.getScheduler();
}
}
三、创建quartz的作业类
package com.anhong.job;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* @BelongsProject: Quartz-SpringBoot-0426
* @BelongsPackage: com.anhong.job
* @Author: anhong
* @CreateTime: 2020-10-24 09:35
* @Description: 任务类，实现JOB接口，重写其中的方法
*/
public class MyJob implements Job {
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
String time=simpleDateFormat.format(new Date());
System.out.println("各位老铁,早上好！节日快乐啊！"+time);
}
}
四、创建quartz的配置类
package com.anhong.config;
import com.anhong.bean.TaskInfo;
import com.bruce.job.MyJob;
import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringBootConfiguration;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Set;
/**
* @BelongsProject: Quartz-SpringBoot-0426
* @BelongsPackage: com.anhong.config
* @Author: anhong
* @CreateTime: 2020-10-24 10:10
* @Description: Quartz配置类
*/
@SpringBootConfiguration
public class QuartzConfig {
//任务调度器
@Autowired
private Scheduler scheduler;
/**
* 01-开启任务
*/
public void startJob(){
try {
openJob(scheduler);
//启动任务
scheduler.start();
} catch (SchedulerException e) {
e.printStackTrace();
}
}
/**
* 02-暂停某个任务
*/
public void pauseJob(String name,String group) throws Exception{
//任务的标识类
JobKey jobKey=new JobKey(name,group);
JobDetail jobDetail = scheduler.getJobDetail(jobKey);
if(jobDetail!=null){
//暂停某个任务
scheduler.pauseJob(jobKey);
}else{
System.out.println("该任务不存在!");
}
}
/**
* 03-查询所有的任务基本信息
* @return
*/
public List<TaskInfo> getAllJobsInfo() throws Exception{
List<TaskInfo> list=new ArrayList<TaskInfo>();
//所有任务组
List<String> jobGroupNames = scheduler.getJobGroupNames();
for (String jobGroupName : jobGroupNames) {
Set<JobKey> jobKeys = scheduler.getJobKeys(GroupMatcher.<JobKey>groupEquals(jobGroupName));
for (JobKey jobKey : jobKeys) {
List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
for (Trigger trigger : triggers) {
Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
JobDetail jobDetail = scheduler.getJobDetail(jobKey);
String cronExpression=""; //cron表达式
String cronDescription=""; //描述信息
if(trigger instanceof CronTrigger){
CronTrigger cronTrigger=(CronTrigger)trigger;
//cron表达式
cronExpression = cronTrigger.getCronExpression();
cronDescription=cronTrigger.getDescription();
}
TaskInfo taskInfo=new TaskInfo();
taskInfo.setJobName(jobKey.getName());
taskInfo.setJobGroup(jobKey.getGroup());
taskInfo.setJobDescrption(jobDetail.getDescription());
taskInfo.setStatus(triggerState.name()); //任务的状态
taskInfo.setCronExpression(cronExpression);
taskInfo.setCronDescription(cronDescription);
list.add(taskInfo);
}
}
}
return list;
}
/**
* 开启一个任务
* @param scheduler
*/
private void openJob(Scheduler scheduler){
try {
//1.创建一个JobDetail
JobDetail jobDetail = JobBuilder.newJob(MyJob.class).withIdentity("job1", "group1").build();
//2.触发器表达式对象
CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0/4 * * * * ?");
//CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("30 25 16 * * ?");
//3.准备一个触发器对象
CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "triggergroup1")
.withSchedule(cronScheduleBuilder).build();
//4.开始调度
scheduler.scheduleJob(jobDetail,cronTrigger);
} catch (SchedulerException e) {
e.printStackTrace();
} finally {
}
}
/**
* 04-恢复某个任务的执行
* @param name
* @param group
*/
public void resumeJob(String name,String group) throws Exception{
JobKey jobKey=new JobKey(name,group);
JobDetail jobDetail = scheduler.getJobDetail(jobKey);
if(jobDetail!=null){
scheduler.resumeJob(jobKey);
}else{
System.out.println("要恢复的任务不存在！");
}
}
/**
* 05-删除某一个任务
* @param name
* @param group
* @throws Exception
*/
public void deleteJob(String name,String group) throws Exception{
JobKey jobKey=new JobKey(name,group);
JobDetail jobDetail = scheduler.getJobDetail(jobKey);
if(jobDetail!=null){
scheduler.deleteJob(jobKey);
}else{
System.out.println("要删除的任务不存在！");
}
}
/**
* 06-动态的修改任务执行的表达式，触发规则
* @param name
* @param group
* @return
*/
public boolean modifyJob(String name,String group,String newTime) throws Exception{
Date date=null;
TriggerKey triggerKey=new TriggerKey(name,group);
Trigger trigger = scheduler.getTrigger(triggerKey);
CronTrigger cronTrigger=null;
if(trigger instanceof CronTrigger){
cronTrigger=(CronTrigger)trigger;
//表达式
String cronExpression = cronTrigger.getCronExpression();
if(!cronExpression.equalsIgnoreCase(newTime)){
System.out.println("需要修改原来的表达式："+cronExpression+"为:"+newTime);
CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(newTime);
//新的触发器
CronTrigger cronTrigger1 = TriggerBuilder.newTrigger().withIdentity(name, group).withSchedule(cronScheduleBuilder).build();
date = scheduler.rescheduleJob(triggerKey, cronTrigger1);
}else{
System.out.println("不用修改！和原来的一样！");
}
}
if(date!=null){
return true;
}else{
return false;
}
}
}
任务对象
package com.anhong.bean;
/**
* @BelongsProject: Quartz-SpringBoot-0426
* @BelongsPackage: com.anhong.bean
* @Author: anhong
* @CreateTime: 2020-10-24 10:24
* @Description: 任务对象
*/
public class TaskInfo {
private String jobName;
private String jobGroup;
private String jobDescrption;
private String status;
private String cronExpression;
private String cronDescription;
public String getJobName() {
return jobName;
}
public void setJobName(String jobName) {
this.jobName = jobName;
}
public String getJobGroup() {
return jobGroup;
}
public void setJobGroup(String jobGroup) {
this.jobGroup = jobGroup;
}
public String getJobDescrption() {
return jobDescrption;
}
public void setJobDescrption(String jobDescrption) {
this.jobDescrption = jobDescrption;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public String getCronExpression() {
return cronExpression;
}
public void setCronExpression(String cronExpression) {
this.cronExpression = cronExpression;
}
public String getCronDescription() {
return cronDescription;
}
public void setCronDescription(String cronDescription) {
this.cronDescription = cronDescription;
}
}
五、创建Quartz的监听类
package com.anhong;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ContextRefreshedEvent;
@Configuration
public class ApplicationStartQuartzJobListener implements ApplicationListener<ContextRefreshedEvent> {
@Autowired
private QuartzScheduler quartzScheduler;
/**
* 初始启动quartz
*/
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
try {
quartzScheduler.startJob();
System.out.println("任务已经启动...");
} catch (SchedulerException e) {
e.printStackTrace();
}
}
/**
* 初始注入scheduler
* @return
* @throws SchedulerException
*/
@Bean
public Scheduler scheduler() throws SchedulerException{
SchedulerFactory schedulerFactoryBean = new StdSchedulerFactory();
return schedulerFactoryBean.getScheduler();
}
}
六、创建控制器
package com.anhong.controller;
import com.anhong.bean.TaskInfo;
import com.anhong.config.QuartzConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* @BelongsProject: Quartz-SpringBoot-0426
* @BelongsPackage: com.anhong.controller
* @Author: anhong
* @CreateTime: 2020-10-24 10:43
* @Description: TODO
*/
@RestController
@RequestMapping("/quartz")
public class QuartzController {
@Autowired
QuartzConfig quartzConfig;
/**
* 01-开启一个定时任务
*
* @return
*/
@RequestMapping("/start")
public String startQuartzJob() {
try {
quartzConfig.startJob();
} catch (Exception e) {
e.printStackTrace();
return "定时任务开启异常~~~";
}
return "定时任务开启成功~~~";
}
/**
* 02-暂停任务
*
* @param name
* @param group
* @return
*/
@RequestMapping("/pauseJob")
public String pauseJob(String name, String group) {
try {
quartzConfig.pauseJob(name, group);
} catch (Exception e) {
e.printStackTrace();
return name + "任务暂停异常";
} finally {
}
return name + "任务被暂停";
}
/**
* 03-查询所有的任务基本信息
*
* @return
*/
@RequestMapping("/infos")
public List<TaskInfo> getAllJobsInfo() {
try {
return quartzConfig.getAllJobsInfo();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 04-恢复某个任务的执行
*
* @param name
* @param group
*/
@RequestMapping("/resumeJob")
public String resumeJob(String name, String group) {
try {
quartzConfig.resumeJob(name, group);
} catch (Exception e) {
e.printStackTrace();
return name + "任务被恢复异常!";
} finally {
}
return name + "任务被恢复啦!";
}
/**
* 05-删除某一个任务
*
* @param name
* @param group
* @throws Exception
*/
@RequestMapping("/deleteJob")
public String deleteJob(String name, String group) {
try {
quartzConfig.deleteJob(name, group);
} catch (Exception e) {
e.printStackTrace();
return name + "任务删除异常!";
} finally {
}
return name + "任务被删除啦!";
}
/**
* 06-动态的修改任务执行的表达式，触发规则
*
* @param name
* @param group
* @return
*/
@RequestMapping("/modifyJob")
public String modifyJob(String name, String group, String newTime) {
boolean flag = false;
try {
flag = quartzConfig.modifyJob(name, group, newTime);
} catch (Exception e) {
e.printStackTrace();
} finally {
}
if (flag) {
return name + "任务时间表达式修改为:" + newTime;
} else {
return name + "任务时间表达式失败!";
}
}
}
总结：SpringBoot整合Quertz实现定时调度的大致步骤实现就如上，在很多微服务商城项目上都会用到定时调度，在根据实际的项目业务需要，我们只需要把以上的一些配置做适当的修改来满足自己业务的需要。
来源：https://blog.csdn.net/weixin_41979664/article/details/109254889
0
投稿猜你喜欢
前言 短时间提升自己最快的手段就是背面试题，最近总结了Java常用的面试题，分享给大家，希望大家都能圆梦大厂，加油，我命由我不由天- 引入spring-cloud-starter-openfeign失败引入下面jar包总是报错jar包丢失<dependency>
- 在游戏项目中我们常常看到商城的广告牌，几张广告图片循环滚动，类似跑马灯，现在我将讨论一种实现方法，并提供一个管理类，大家可以直接使用。实现原
- 重新指定分配默认值的参数时，可以显式地为指定参数名称赋值，隐式指定的时候，是根据方法参数的顺序，靠c#编译器的推断。 代码示例： void
- maven插件主要是为maven中生命周期中的阶段服务的，maven中只是定义了3套生命周期，以及每套生命周期中有哪些阶段，具体每个阶段中执
- 一、LINQ的体系结构语言集成查询 (LINQ) (C#) | Microsoft 官方文档LINQ总共包括五个部分： 程序集命名
- 首先给大家展示下效果图，感觉还不错，请继续往下阅读：下拉刷新： 上划加载 &n
- 随着互联网的发展，传统的HTTP协议已经很难满足Web应用日益复杂的需求了。近年来，随着HTML5的诞生，WebSocket协议被提出，它实
- 由于近来学习java，遇到了一些在c++上没有的概念，将它记录下，以自己复习使用，如有不理解妥之处，望大家批评指导。资料均由网上经过自己整合
- 这篇文章主要介绍了Java并发编程预防死锁过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可
- 我们经常看到使用了ViewPager的App，在每页上面都会有一个滑块来标志当前处于哪一页。在PagerView包里有android.sup
- 一、IO流的分类字符流ReaderInputStreamReader（节点流）BufferedReader（处理流）WriterOutput
- 本文实例为大家分享了QT实现用户登录注册的具体代码，供大家参考，具体内容如下#include "widget.h"#in
- 一、单独使用MyBatis（1）在mybatis.xml配置文件中添加如下配置<setting name="logImpl&
- 前言记得几年前有一次栈长去面试，问到了这么一个问题:Java中的对象都是在堆中分配吗？说明为什么！当时我被问得一脸蒙逼，瞬间被秒杀得体无完肤
- TCP/IP、UDP、Socket对TCP/IP、UDP、Socket编程这些词你不会很陌生吧？随着网络技术的发展，这些词充斥着我们的耳朵。
- 自动登录，是为了帮助用户多次使用这个网页时，不用再次输入用户名和密码就可以登录。自动登录是指用户将用户的登录信息，人，保存到本地的文件中Co
- 1、#{}是预编译处理，MyBatis在处理#{ }时，它会将sql中的#{ }替换为？，然后调用PreparedStatement的set
- Selenium.WebDriverSelenium WebDriver 是一组开源 API，用于自动测试 Web 应用程序，利用它可以通过
- SpringBoot的自动装配是拆箱即用的基础，也是微服务化的前提。这次主要的议题是，来看看它是怎么样实现的，我们透过源代码来把握自动装配的
