springboot整合quartz定时任务

最新推荐文章于 2025-06-06 15:24:09 发布

一个阿拉丁神灯

最新推荐文章于 2025-06-06 15:24:09 发布

阅读量408

点赞数 3

CC 4.0 BY-SA版权

分类专栏：技术记录分享文章标签： java quartz 定时任务 springboot整合quartz springboot

本文链接：https://blog.csdn.net/LEIFEI0123/article/details/92196774

技术记录分享专栏收录该内容

4 篇文章

订阅专栏

本文介绍如何在SpringBoot框架中整合Quartz实现定时任务。通过导入必要的依赖，配置Quartz参数，创建任务抽象类、任务工厂、任务管理器及具体任务，最终在Controller中调用任务。涉及SpringBoot、Quartz、依赖管理、任务调度等关键概念。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

今天介绍一下springboot框架整合quartz。

首先导入依赖，注意：一下依赖缺一不可

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>4.2.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
            <version>2.2.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
        </dependency>

接下来创建quartz的配置文件

# 固定前缀org.quartz
# 主要分为scheduler、threadPool、jobStore、plugin等部分
#
#
org.quartz.scheduler.instanceName = DefaultQuartzScheduler
org.quartz.scheduler.rmi.export = false
org.quartz.scheduler.rmi.proxy = false
org.quartz.scheduler.wrapJobExecutionInUserTransaction = false

# 实例化ThreadPool时，使用的线程类为SimpleThreadPool
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool

# threadCount和threadPriority将以setter的形式注入ThreadPool实例
# 并发个数
org.quartz.threadPool.threadCount = 5
# 优先级
org.quartz.threadPool.threadPriority = 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true
org.quartz.jobStore.misfireThreshold = 5000

# 默认存储在内存中
org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore

#持久化
#org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
#org.quartz.jobStore.tablePrefix = QRTZ_
#org.quartz.jobStore.dataSource = qzDS
#org.quartz.dataSource.qzDS.driver = com.mysql.cj.jdbc.Driver
#org.quartz.dataSource.qzDS.URL = jdbc:mysql://localhost:3306/quartz?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8
#org.quartz.dataSource.qzDS.user = root
#org.quartz.dataSource.qzDS.password = 19970121
#org.quartz.dataSource.qzDS.maxConnections = 10

接着创建一下三个类

import org.quartz.Job;
import org.quartz.JobExecutionContext;

public abstract class AbstractTask implements Job {

    protected abstract void executeInternal(JobExecutionContext context);

    protected String cronExpression;

    @Override
    public void execute(JobExecutionContext context) {
        try {
            executeInternal(context);
        } catch (Exception e) {
        }
    }

    public String getCronExpression() {
        return cronExpression;
    }

}

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;
import org.springframework.stereotype.Component;

@Component
public class AutowiringSpringBeanJobFactory extends SpringBeanJobFactory implements ApplicationContextAware {
    private transient AutowireCapableBeanFactory beanFactory;

    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        final Object jobInstance = super.createJobInstance(bundle);
        beanFactory.autowireBean(jobInstance);
        return jobInstance;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.beanFactory = applicationContext.getAutowireCapableBeanFactory();
    }
}

package com.example.reader.quartz;

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

import java.util.Map;

@Component
@Scope("singleton")
public class QuartzManager implements ApplicationContextAware {

    private static SchedulerFactory schedulerFactory = new StdSchedulerFactory();

    private static final String JOB_DEFAULT_GROUP_NAME = "JOB_DEFAULT_GROUP_NAME";

    private static final String TRIGGER_DEFAULT_GROUP_NAME = "TRIGGER_DEFAULT_GROUP_NAME";

    private ApplicationContext applicationContext;

    private Scheduler scheduler;

    @Autowired
    private AutowiringSpringBeanJobFactory autowiringSpringBeanJobFactory;

    public void start() {
        //启动所有任务
        try {
            this.scheduler = schedulerFactory.getScheduler();
            scheduler.setJobFactory(autowiringSpringBeanJobFactory);
            //启动所有任务,这里获取AbstractTask的所有子类
            Map<String, AbstractTask> tasks = applicationContext.getBeansOfType(AbstractTask.class);
            tasks.forEach((k, v) -> {
                String cronExpression = v.getCronExpression();
                if (cronExpression != null) {
                    addJob(k, v.getClass().getName(), cronExpression);
                }
            });
        } catch (SchedulerException e) {
            throw new RuntimeException("init Scheduler failed");
        }
    }

    public boolean addJob(String jobName, String jobClass, String cronExp) {
        boolean result = false;
        if (!CronExpression.isValidExpression(cronExp)) {
            return result;
        }
        try {
            JobDetail jobDetail = JobBuilder.newJob().withIdentity(new JobKey(jobName, JOB_DEFAULT_GROUP_NAME))
                    .ofType((Class<Job>) Class.forName(jobClass))
                    .build();
            Trigger trigger = TriggerBuilder.newTrigger()
                    .forJob(jobDetail)
                    .withSchedule(CronScheduleBuilder.cronSchedule(cronExp))
                    .withIdentity(new TriggerKey(jobName, TRIGGER_DEFAULT_GROUP_NAME))
                    .build();
            scheduler.scheduleJob(jobDetail, trigger);
            scheduler.start();
        } catch (Exception e) {
        }
        result = true;
        return result;
    }

    public boolean updateJob(String jobName, String cronExp) {
        boolean result = false;
        if (!CronExpression.isValidExpression(cronExp)) {
            return result;
        }
        JobKey jobKey = new JobKey(jobName, JOB_DEFAULT_GROUP_NAME);
        TriggerKey triggerKey = new TriggerKey(jobName, TRIGGER_DEFAULT_GROUP_NAME);
        try {
            if (scheduler.checkExists(jobKey) && scheduler.checkExists(triggerKey)) {
                JobDetail jobDetail = scheduler.getJobDetail(jobKey);
                Trigger newTrigger = TriggerBuilder.newTrigger()
                        .forJob(jobDetail)
                        .withSchedule(CronScheduleBuilder.cronSchedule(cronExp))
                        .withIdentity(new TriggerKey(jobName, TRIGGER_DEFAULT_GROUP_NAME))
                        .build();
                scheduler.rescheduleJob(triggerKey, newTrigger);
                result = true;
            } else {
            }
        } catch (SchedulerException e) {
        }
        return result;
    }

    public boolean deleteJob(String jobName) {
        boolean result = false;
        JobKey jobKey = new JobKey(jobName, JOB_DEFAULT_GROUP_NAME);
        try {
            if (scheduler.checkExists(jobKey)) {
                result = scheduler.deleteJob(jobKey);
            } else {
            }
        } catch (SchedulerException e) {
        }
        return result;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

最后，创建一个任务

import com.example.reader.utils.util;
import org.quartz.JobExecutionContext;
import org.springframework.stereotype.Component;

@Component("testTask")
public class TestTask extends AbstractTask {
    util ut = new util();
    @Override
    protected void executeInternal(JobExecutionContext context) {
        System.out.println("任务开启++");
        ut.reader();//此处写任务，大家可以用输出语句进行测试
        System.out.println("任务结束");
    }
}

下面是controller

 @RequestMapping("/readdate")
    public String testCronTest(String date)  {
        String flag = "";
        String cron = du.getCron(date);
       /* TimeUnit.SECONDS.sleep(10);
        //修改任务
        quartzManager.updateJob("testTask", "0/3 * * * * ? ");
        //删除任务
        quartzManager.deleteJob("testTask");
        *///添加任务
        quartzManager.start();
         //cron = "0/1 * * * * ?";
        boolean testTask = quartzManager.addJob("testTask",             
        this.testTask.getClass().getName(), cron);
       /* //修改任务
        quartzManager.updateJob("testTask", "0/3 * * * * ?");
        //删除任务
        quartzManager.deleteJob("testTask");*/
        System.out.println(testTask);
        if(testTask == true){
           flag = "OK";
       }else{
           flag = "NO";
       }
         return JSON.toJSONString(flag);
    }
//我只使用了添加任务，大家有其他需求可以把注释去掉