脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → SprinBoot整合Quart

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分布式系统中一致性哈希算法

    详解Java分布式系统中一致性哈希算法

    这篇文章主要介绍了Java分布式系统中一致性哈希算法，对算法感兴趣的同学，可以参考下
    2021-04-04
  • Spring MVC拦截器和跨域请求使用详解

    Spring MVC拦截器和跨域请求使用详解

    SpringMVC的拦截器也是AOP思想的一种实现方式，主要用于拦截用户的请求并做相应的处理，通常应用在权限验证、记录请求信息的日志、判断用户是否登录等功能上，这篇文章主要介绍了Spring MVC拦截器和跨域请求,需要的朋友可以参考下
    2023-07-07
  • 推荐几款非常实用的IDEA插件小结

    推荐几款非常实用的IDEA插件小结

    这篇文章主要介绍了推荐几款非常实用的IDEA插件小结，解决你开发中可望而又不好找的插件，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2019-01-01
  • Java微服务实战项目尚融宝接口创建详解

    Java微服务实战项目尚融宝接口创建详解

    这篇文章主要介绍了Java微服务实战项目尚融宝的接口创建流程，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2022-08-08
  • 普通对象使用spring容器中的对象的实现方法

    普通对象使用spring容器中的对象的实现方法

    这篇文章主要介绍了普通对象使用spring容器中的对象的实现方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2019-06-06
  • Java并发编程中的ReentrantLock类详解

    Java并发编程中的ReentrantLock类详解

    这篇文章主要介绍了Java并发编程中的ReentrantLock类详解,ReentrantLock是juc.locks包中的一个独占式可重入锁,相比synchronized,它可以创建多个条件等待队列,还支持公平/非公平锁、可中断、超时、轮询等特性,需要的朋友可以参考下
    2023-12-12
  • Springboot中实现接口幂等性的4种方案小结

    Springboot中实现接口幂等性的4种方案小结

    本文主要介绍了Springboot中实现接口幂等性,包含数据库的幂等,数据库的幂等,Redis的幂等性和Token + 时间戳的幂等性,具有一定的参考价值,感兴趣的可以了解一下
    2024-03-03
  • 使用Spring的拦截器监测每个Controller或方法的执行时长

    使用Spring的拦截器监测每个Controller或方法的执行时长

    这篇文章主要介绍了使用Spring的拦截器监测每个Controller或方法的执行时长，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2021-10-10
  • 深入理解Java设计模式之解释器模式

    深入理解Java设计模式之解释器模式

    这篇文章主要介绍了JAVA设计模式之解释器模式的的相关资料，文中示例代码非常详细，供大家参考和学习，感兴趣的朋友可以了解
    2021-11-11
  • 详解SpringIOC容器相关知识

    详解SpringIOC容器相关知识

    这篇文章主要记录自己在狂神说java中的学习情况，文章里有自己学习的理解和扩展，新手难免有理解偏差或者错误，恳请大佬指正下,需要的朋友可以参考下
    2021-05-05

最新评论