SprinBoot整合Quart实现定时调度的示例代码
更新时间：2020年10月26日 10:11:23 作者：赫赫有安
这篇文章主要介绍了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实现定时调度的大致步骤实现就如上，在很多微服务商城项目上都会用到定时调度，在根据实际的项目业务需要，我们只需要把以上的一些配置做适当的修改来满足自己业务的需要。
到此这篇关于SprinBoot整合Quart实现定时调度的示例代码的文章就介绍到这了,更多相关SprinBoot整合Quart内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
java 编写程序获取已知文件的扩展名. 注意: abc.txt的扩展名是txt, abc.java.txt的扩展名也是txt.,需要的朋友可以参考下2017-02-02
详解Java中的File文件类以及FileDescriptor文件描述类
在Java中File类可以用来新建文件和目录对象,而FileDescriptor类则被用来表示文件或目录的可操作性,接下来我们就来详解Java中的File文件类以及FileDescriptor文件描述类2016-06-06
这篇文章主要介绍了Java设计模式编程中的工厂方法模式和抽象工厂模式,设计模式的建立有利于团队协作时代码的共同维护,需要的朋友可以参考下2016-01-01
一般项目中需要对入参进行校验,比如必须是一个合法的日期,本文就来介绍一下Java日期工具类时间校验实现,具有一定的参考价值,感兴趣的可以了解一下2023-12-12
这篇文章主要介绍了dart类详细讲解,实例讲解的很清晰，有对于这方面不太清楚的同学可以跟着学习下2021-02-02
这篇文章主要介绍了Java 编程之IO流资料详细整理的相关资料,需要的朋友可以参考下2017-02-02
这篇文章主要介绍了如何解决SpringMVC不能访问html页面问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教2023-09-09
这篇文章主要介绍了Springboot中如何自动转JSON输出，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教2022-06-06
Java 数据库时间返回前端显示错误(差8个小时)的解决方法
本文主要介绍了Java 数据库时间返回前端显示错误(差8个小时)的解决方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧2023-08-08
Dubbo retries 超时重试机制的问题原因分析及解决方案
这篇文章主要介绍了Dubbo retries 超时重试机制的问题,解决方案是通过修改dubbo服务提供方，将timeout超时设为20000ms或者设置retries=“0”，禁用超时重试机制，感兴趣的朋友跟随小编一起看看吧2022-04-04
最新评论