SprinBoot整合Quart实现定时调度

 

 

                            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