Quartz+Spring Boot实现动态管理定时任务

最新推荐文章于 2024-05-04 00:39:05 发布
最新推荐文章于 2024-05-04 00:39:05 发布
阅读量573 收藏 1
点赞数
分类专栏： quartz
原文链接：https://blog.csdn.net/wang704987562/article/details/80634531
版权

在实践中遇到动态管理定时任务的需求，场景通常是动态添加、更新、删除任务，借助Quartz，可方便实现功能。 
以下使用Quartz结合Spring Boot方式使用。

POM依赖


<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.2.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context-support</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>

    <dependency>
        <groupId>org.quartz-scheduler</groupId>
        <artifactId>quartz</artifactId>
        <version>2.3.0</version>
    </dependency>

</dependencies>

代码

QuartzManager类管理任务的增删改查。

/**
 * @author wzx
 * @time 2018/6/9
 */
@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 Logger logger = LoggerFactory.getLogger(QuartzManager.class);

    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);
                }
            });
            logger.info("start jobs finished.");
        } catch (SchedulerException e) {
            logger.error(e.getMessage(), e);
            throw new RuntimeException("init Scheduler failed");
        }
    }

    public boolean addJob(String jobName, String jobClass, String cronExp) {
        boolean result = false;
        if (!CronExpression.isValidExpression(cronExp)) {
            logger.error("Illegal cron expression format({})", 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) {
            logger.error(e.getMessage(), e);
            logger.error("QuartzManager add job failed");
        }
        return result;
    }

    public boolean updateJob(String jobName, String cronExp) {
        boolean result = false;
        if (!CronExpression.isValidExpression(cronExp)) {
            logger.error("Illegal cron expression format({})", 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 {
                logger.error("update job name:{},group name:{} or trigger name:{},group name:{} not exists..",
                        jobKey.getName(), jobKey.getGroup(), triggerKey.getName(), triggerKey.getGroup());
            }
        } catch (SchedulerException e) {
            logger.error(e.getMessage(), e);
            logger.error("update job name:{},group name:{} failed!", jobKey.getName(), jobKey.getGroup());
        }
        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 {
                logger.error("delete job name:{},group name:{} not exists.", jobKey.getName(), jobKey.getGroup());
            }
        } catch (SchedulerException e) {
            logger.error(e.getMessage(), e);
            logger.error("delete job name:{},group name:{} failed!", jobKey.getName(), jobKey.getGroup());
        }
        return result;
    }

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

定义抽象任务类AbstractTask，实现Job接口，子类Job实例需实现executeInternal方法。

/**
 * @author wzx
 * @time 2018/6/9
 */
public abstract class AbstractTask implements Job {

    private Logger logger = LoggerFactory.getLogger(AbstractTask.class);

    protected abstract void executeInternal(JobExecutionContext context);

    protected String cronExpression;

    @Override
    public void execute(JobExecutionContext context) {
        try {
            executeInternal(context);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            logger.error("job execute failed!");
        }
    }

    public String getCronExpression() {
        return cronExpression;
    }
}

测试TestTask类，继承AbstractTask类，实现executeInternal方法。

/**
 * @author wzx
 * @time 2018/6/9
 */
@Component("testTask")
public class TestTask extends AbstractTask {

    private Logger logger = LoggerFactory.getLogger(TestTask.class);

    @PostConstruct
    public void init() {
        this.cronExpression = "0/2 * * * * ? ";
    }

    @Override
    protected void executeInternal(JobExecutionContext context) {
        logger.info("test task start execute.");
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            logger.info("test task execute interrupted.");
        }
        logger.info("test task execute end.");
    }
}

测试用例，测试增加、更新、删除功能。

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootdemoApplicationTests {

    private Logger logger = LoggerFactory.getLogger(SpringbootdemoApplicationTests.class);

    @Autowired
    private QuartzManager quartzManager;

    @Autowired
    private TestTask testTask;

    @Test
    public void testCronTest() throws InterruptedException {
        quartzManager.start();
        TimeUnit.SECONDS.sleep(10);
        logger.info("start update job");
        //修改任务
        quartzManager.updateJob("testTask", "0/3 * * * * ? ");
        logger.info("end update job");
        TimeUnit.SECONDS.sleep(10);
        logger.info("start delete job");
        //删除任务
        quartzManager.deleteJob("testTask");
        logger.info("end delete job");
        TimeUnit.SECONDS.sleep(10);
        //添加任务
        logger.info("start add job");
        quartzManager.addJob("testTask", testTask.getClass().getName(), "0/3 * * * * ?");
        logger.info("end add job");
        TimeUnit.SECONDS.sleep(10);
        //修改任务
        logger.info("start update job");
        quartzManager.updateJob("testTask", "0/3 * * * * ?");
        logger.info("end update job");
        TimeUnit.SECONDS.sleep(10);
        //删除任务
        logger.info("start delete job");
        quartzManager.deleteJob("testTask");
        logger.info("end delete job");
        logger.info("end.");
    }

}

结果输出，符合预期。

2018-06-09 16:43:58.052  INFO 2884 --- [           main] org.quartz.impl.StdSchedulerFactory      : Using default implementation for ThreadExecutor
2018-06-09 16:43:58.054  INFO 2884 --- [           main] org.quartz.simpl.SimpleThreadPool        : Job execution threads will use class loader of thread: main
2018-06-09 16:43:58.066  INFO 2884 --- [           main] org.quartz.core.SchedulerSignalerImpl    : Initialized Scheduler Signaller of type: class org.quartz.core.SchedulerSignalerImpl
2018-06-09 16:43:58.066  INFO 2884 --- [           main] org.quartz.core.QuartzScheduler          : Quartz Scheduler v.2.3.0 created.
2018-06-09 16:43:58.066  INFO 2884 --- [           main] org.quartz.simpl.RAMJobStore             : RAMJobStore initialized.
2018-06-09 16:43:58.067  INFO 2884 --- [           main] org.quartz.core.QuartzScheduler          : Scheduler meta-data: Quartz Scheduler (v2.3.0) 'DefaultQuartzScheduler' with instanceId 'NON_CLUSTERED'
  Scheduler class: 'org.quartz.core.QuartzScheduler' - running locally.
  NOT STARTED.
  Currently in standby mode.
  Number of jobs executed: 0
  Using thread pool 'org.quartz.simpl.SimpleThreadPool' - with 10 threads.
  Using job-store 'org.quartz.simpl.RAMJobStore' - which does not support persistence. and is not clustered.

2018-06-09 16:43:58.067  INFO 2884 --- [           main] org.quartz.impl.StdSchedulerFactory      : Quartz scheduler 'DefaultQuartzScheduler' initialized from default resource file in Quartz package: 'quartz.properties'
2018-06-09 16:43:58.067  INFO 2884 --- [           main] org.quartz.impl.StdSchedulerFactory      : Quartz scheduler version: 2.3.0
2018-06-09 16:43:58.077  INFO 2884 --- [           main] org.quartz.core.QuartzScheduler          : Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED started.
2018-06-09 16:43:58.077  INFO 2884 --- [           main] c.e.s.service.task.QuartzManager         : start jobs finished.
2018-06-09 16:43:58.081  INFO 2884 --- [eduler_Worker-1] c.e.s.service.task.TestTask              : test task start execute.
2018-06-09 16:44:01.082  INFO 2884 --- [eduler_Worker-1] c.e.s.service.task.TestTask              : test task execute end.
...
2018-06-09 16:44:08.077  INFO 2884 --- [           main] c.e.s.SpringbootdemoApplicationTests     : start update job
2018-06-09 16:44:08.078  INFO 2884 --- [           main] c.e.s.SpringbootdemoApplicationTests     : end update job
2018-06-09 16:44:09.001  INFO 2884 --- [eduler_Worker-7] c.e.s.service.task.TestTask              : test task start execute.
2018-06-09 16:44:12.002  INFO 2884 --- [eduler_Worker-7] c.e.s.service.task.TestTask              : test task execute end.
...
2018-06-09 16:44:18.078  INFO 2884 --- [           main] c.e.s.SpringbootdemoApplicationTests     : start delete job
2018-06-09 16:44:18.078  INFO 2884 --- [           main] c.e.s.SpringbootdemoApplicationTests     : end delete job
2018-06-09 16:44:28.079  INFO 2884 --- [           main] c.e.s.SpringbootdemoApplicationTests     : start add job
2018-06-09 16:44:28.079  INFO 2884 --- [           main] org.quartz.core.QuartzScheduler          : Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED started.
2018-06-09 16:44:28.079  INFO 2884 --- [           main] c.e.s.SpringbootdemoApplicationTests     : end add job
2018-06-09 16:44:30.001  INFO 2884 --- [eduler_Worker-1] c.e.s.service.task.TestTask              : test task start execute.
2018-06-09 16:44:33.001  INFO 2884 --- [eduler_Worker-1] c.e.s.service.task.TestTask              : test task execute end.
...
2018-06-09 16:44:38.080  INFO 2884 --- [           main] c.e.s.SpringbootdemoApplicationTests     : start update job
2018-06-09 16:44:38.080  INFO 2884 --- [           main] c.e.s.SpringbootdemoApplicationTests     : end update job
2018-06-09 16:44:39.001  INFO 2884 --- [eduler_Worker-4] c.e.s.service.task.TestTask              : test task start execute.
2018-06-09 16:44:42.003  INFO 2884 --- [eduler_Worker-4] c.e.s.service.task.TestTask              : test task execute end.
...
2018-06-09 16:44:48.080  INFO 2884 --- [           main] c.e.s.SpringbootdemoApplicationTests     : start delete job
2018-06-09 16:44:48.080  INFO 2884 --- [           main] c.e.s.SpringbootdemoApplicationTests     : end delete job
2018-06-09 16:44:48.080  INFO 2884 --- [           main] c.e.s.SpringbootdemoApplicationTests     : end.
2018-06-09 16:44:48.083  INFO 2884 --- [       Thread-2] s.c.a.AnnotationConfigApplicationContext : Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@1da2cb77: startup date [Sat Jun 09 16:43:57 CST 2018]; root of context hierarchy

Job默认由Quartz管理，如果需要使用Spring容器管理bean，也就是依赖注入，需要指定JobFactory，也就是指定将Job由Spring容器管理。
/**
 * @author wzx
 * @time 2018/6/9
 */
@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();
    }
}

 

Qgwperfect
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2021-04-28
04-28 743
2021-04-28 04:15:13.5477||INFO|Quartz.Core.QuartzScheduler|Scheduler meta-data: Quartz Scheduler (v3.0.7.0) 'DefaultQuartzScheduler' with instanceId 'NON_CLUSTERED' Scheduler class: 'Quartz.Core.QuartzScheduler' - running locally. NOT STARTED. Curren...
Quartz学习总结之核心接口Scheduler、Job
zengdongwen的博客
09-25 2335
参考文章：https://www.cnblogs.com/mengrennwpu/p/7141986.html 核心接口如下： 接口 含义 Scheduler scheduler的主要API接口 Job 任务实现接口，期望调度器能够执行 JobDetail 用于定义Job实例 Trigger 调度器基于特定时间来执行指定任务的组件 JobBui...
Springboot Quartz定时任务的动态调度使用，实战详解(1)
最新发布
2401_84153262的博客
05-04 862
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！*/@Beanpublic Properties quartzProperties() throws IOException{PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();//若不做额外配置,会有默认的配置文件加载 在jar org.quartz里面 有一份quartz.properties//propert
quartz 高级使用（quartz 二）
dengjili的专栏
01-27 1566
目录添加maven的pom配置RAMJobStore通过properties文件配置调度任务JDBC JobStore（基于mysql） 添加maven的pom配置 &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.slf4j&amp;lt;/groupId&amp;gt; &amp;lt;artifactId&amp;gt;slf4j-log4j12&amp;l
springboot的坑，如何解决
qq_33058491的博客
12-30 3369
spring boot相关问题 问题1：spring-boot-quartz启动出现问题(待解决) Scheduler meta-data: Quartz Scheduler (v2.3.2) 'quartzScheduler' with instanceId 'NON_CLUSTERED' Scheduler class: 'org.quartz.core.QuartzScheduler' - running locally. NOT STARTED. Currently in standby
Persistence in Spring 作者：Bruce A. Tate and Justin Gehtland
09-01 1976
Persistence in Springby Bruce A. Tate and Justin Gehtland Editors note: Its usually better to solve problems with simplicity and finesse rather than muscle. Thats the premise behind the recently
spring boot task实现动态创建定时任务的方法
08-26
Spring Boot Task 实现动态创建定时任务的方法 Spring Boot Task 提供了一种简单的方式来实现定时任务，但是在实际开发中，我们经常需要动态创建定时任务，以适应不同的业务需求。在这篇文章中，我们将介绍如何使用...
spring boot整合quartz实现多个定时任务的方法
08-28
Spring Boot整合Quartz实现多个定时任务的方法 在实际开发中，定时任务是非常常见的需求，例如每天凌晨执行某些任务、每小时执行某些任务等。Spring Boot提供了多种方式来实现定时任务，包括使用Quartz框架。在本文...
Springboot整合Quartz实现定时任务数据库动态配置
03-17
本篇文章将详细探讨如何在Spring Boot项目中整合Quartz，并通过MySQL数据库实现定时任务的动态配置。 首先，我们需要在项目中添加依赖。在Spring Boot的`pom.xml`文件中，引入Spring Boot的`spring-boot-starter-...
Quartz + SpringBoot 实现分布式定时任务demo
04-11
这个"Quartz + SpringBoot 实现分布式定时任务demo"是一个示例项目，用于演示如何在分布式环境中使用Quartz和Spring Boot来管理定时任务。 首先，我们需要了解Spring Boot集成Quartz的基本步骤： 1. **依赖添加**...
Quartz的简单使用
热门推荐
我的世界你不懂
04-14 2万+
quartz是开发经常使用的一种调度框架，具体介绍可以自行搜索。 本文介绍quartz的简单使用如下： 首先创建一个基本的Job类//quartz定义了一种Job，用于作为调度执行的方法 public class BaseJob implements Job{ Logger log = LoggerFactory.getLogger(Job.class); public BaseJob(
整合spring cloud 之后quartz 定时器 没有执行的BUG
chuncui2576的博客
07-28 5757
今天发现了一个 quartz 在 spring cloud 下的BUG 开始并没有 加入 spring cloud ，而是 spring boot 加上 quartz 而已。 这时候是可以执行的。 版本是 spring boot ： springBootVersion = '2.0...
springboot-Quartz定时任务并持久化
07-13 4915
新建项目，添加依赖 新建一个springboot项目，勾选下springboot，以及quartz依赖 或者我们可以直接在pom.xml文件中直接添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-quartz</artifactId>
Quartz与Spring Boot集成使用
dongjizheng9270的博客
02-21 249
上次自己搭建Quartz已经是几年前的事了，这次项目中需要定时任务，需要支持集群部署，想到比较轻量级的定时任务框架就是Quartz，于是来一波。 版本说明 通过搜索引擎很容易找到其官网，来到Document的页面，当前版本是2.2.x。 简单的搭建操作 通过Maven引入所需的包： <dependency> <groupId>org.quartz-sche...
springboot中使用quartz进行定时任务操作
赵润泽
11-22 1万+
在springboot中使用quartz进行定时结算操作，并使用feign跨服务调用数据。
解决端口被占用问题
小恶魔的博客
07-21 1701
【代码】解决端口被占用问题。
java check方法_Java Scheduler.checkExists方法代码示例
weixin_32083569的博客
03-06 1273
import org.quartz.Scheduler; //导入方法依赖的package包/类/*** Schedule the archiving job based on the interval defined in the DB.** If archiving is disabled, deletes the archiving job.*/@Overridepublic void ma...
Quartz定时任务的使用
m0_46561911的博客
11-14 1982
quartz定时任务
spring boot+quartz实现定时任务管理
06-10
使用Spring Boot和Quartz实现定时任务管理，可以让你更方便地管理和监控你的定时任务。下面是一个使用Spring Boot、Quartz和Spring MVC实现定时任务管理的示例： 首先，在你的Spring Boot应用程序中添加Quartz和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值