SprinBoot整合Quart实现定时调度的示例代码

网友投稿 256 2022-11-16


SprinBoot整合Quart实现定时调度的示例代码

Quartz是一款开源的定时任务调度框架,Quartz的官网是:http://quartz-scheduler.org/。本文主要是讲诉使用springboot整合quartz实现定时任务调度管理的用例。主要的内容有如下三部分:

1. springboot整合quartz的相关配置

2. 实现基于simpleTrigger的定时任务

3. 实现基于cronTrigger的定时任务

一、导入相关的pom依赖

xmlns:xsi="http://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">

4.0.0

com.bruce.quartz.springboot.demo

Quartz-SpringBoot-0426

1.0-SNAPSHOT

org.springframework.boot

spring-boot-starter-parent

1.5.2.RELEASE

org.springframework.boot

spring-boot-starter-web

org.springframework.boot

spring-boot-starter-tomcat

provided

org.springframework.boot

spring-boot-starter-test

test

org.quartz-scheduler

quartz

2.2.1

org.quartz-scheduler

quartz-jobs

2.2.1

org.springframework.boot

spring-boot-maven-plugin

xmlns:xsi="http://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">

4.0.0

com.bruce.quartz.springboot.demo

Quartz-SpringBoot-0426

1.0-SNAPSHOT

org.springframework.boot

spring-boot-starter-parent

1.5.2.RELEASE

org.springframework.boot

spring-boot-starter-web

org.springframework.boot

spring-boot-starter-tomcat

provided

org.springframework.boot

spring-boot-starter-test

test

org.quartz-scheduler

quartz

2.2.1

org.quartz-scheduler

quartz-jobs

2.2.1

org.springframework.boot

spring-boot-maven-plugin

二、创建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=simpqNJXkApzoleDateFormat.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 getAllJobsInfo() throws Exception{

List list=new ArrayList();

//所有任务组

List jobGroupNames = scheduler.getJobGroupNames();

for (String jobGroupName : jobGroupNames) {

Set jobKeys = scheduler.getJobKeys(GroupMatcher.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 {

@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 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) {

booleanhttp:// 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实现定时调度的大致步骤实现就如上,在很多微服务商城项目上都会用到定时调度,在根据实际的项目业务需要,我们只需要把以上的一些配置做适当的修改来满足自己业务的需要。


版权声明:本文内容由网络用户投稿,版权归原作者所有,本站不拥有其著作权,亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容,请联系我们jiasou666@gmail.com 处理,核实后本网站将在24小时内删除侵权内容。

上一篇:java的各种集合为什么不安全(List、Set、Map)以及代替方案
下一篇:Java 注解学习笔记
相关文章

 发表评论

暂时没有评论,来抢沙发吧~