springboot quartz动态任务处理

最新推荐文章于 2024-05-31 06:29:39 发布
最新推荐文章于 2024-05-31 06:29:39 发布
阅读量504 收藏
点赞数 1
分类专栏： spring cloud 文章标签： springboot quartz 动态任务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zwx19921215/article/details/89401790
版权

现实中的很多定时任务并不像网上的那种写法那么简单都是直接通过注解的形式实现（@Scheduled(fixedRate = 10000)）。我就遇到了从数据库读取相关的数据（可能有n条）然后根据数据的触发时间生成多个动态任务添加到Scheduler中，当到达触发点时自动触发该任务。

废话不多说，直接上代码：

核心调度类：

package com.xx.task;

import org.apache.commons.lang3.StringUtils;
import org.quartz.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Map;

/**
 * @author xiaofeng
 * @version V1.0
 * @title: CustomQuartzScheduler
 * @package: com.xx.task
 * @description: 自定义job
 * @date 2019/4/19 10:32
 */
@Component
public class CustomQuartzScheduler {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private Scheduler scheduler;

    /**
     * 开始执行所有任务
     */
    public void startJob() {
        try {
            scheduler.start();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取job信息
     *
     * @param jobName
     * @param groupName
     * @return
     */
    public String getJobInfo(String jobName, String groupName) {
        TriggerKey triggerKey = new TriggerKey(jobName, groupName);
        CronTrigger cronTrigger = null;
        try {
            cronTrigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            return String.format("time:%s,state:%s", cronTrigger.getCronExpression(),
                    scheduler.getTriggerState(triggerKey).name());
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 修改某个任务的执行时间
     *
     * @param jobName
     * @param groupName
     * @param cronExpress
     * @return
     */
    public boolean modifyJobWithCronExpress(String jobName, String groupName, String cronExpress) {
        Date date = null;
        TriggerKey triggerKey = new TriggerKey(jobName, groupName);
        CronTrigger cronTrigger = null;
        try {
            cronTrigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            String oldTime = cronTrigger.getCronExpression();
            if (!oldTime.equalsIgnoreCase(cronExpress)) {
                CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpress);
                CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobName, groupName).withSchedule(cronScheduleBuilder).build();
                date = scheduler.rescheduleJob(triggerKey, trigger);
            }
            return date != null;
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 修改某个任务的执行时间
     *
     * @param jobName
     * @param groupName
     * @param startAt
     * @param endAt
     * @return
     */
    public boolean modifyJobWithTime(String jobName, String groupName, Date startAt, Date endAt) {
        Date date = null;
        TriggerKey triggerKey = new TriggerKey(jobName, groupName);
        Trigger oldTrigger = null;
        try {
            oldTrigger = scheduler.getTrigger(triggerKey);
            Date startTime = oldTrigger.getStartTime();
            Date endTime = oldTrigger.getEndTime();
            TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger().withIdentity(jobName, groupName);
            if (startTime.compareTo(startAt) != 0) {
                triggerBuilder.startAt(startAt);
            }
            if (endTime.compareTo(endAt) != 0) {
                triggerBuilder.endAt(endAt);
            }
            Trigger trigger = triggerBuilder.build();
            date = scheduler.rescheduleJob(triggerKey, trigger);
            return date != null;
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 暂停所有任务
     */
    public void pauseAllJob() {
        try {
            scheduler.pauseAll();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * 暂停某个任务
     *
     * @param jobName
     * @param groupName
     */
    public void pauseJob(String jobName, String groupName) {
        JobKey jobKey = new JobKey(jobName, groupName);
        JobDetail jobDetail = null;
        try {
            jobDetail = scheduler.getJobDetail(jobKey);
            if (jobDetail == null) {
                return;
            }
            scheduler.pauseJob(jobKey);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * 恢复所有任务
     */
    public void resumeAllJob() {
        try {
            scheduler.resumeAll();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * 恢复某个任务
     *
     * @param jobName
     * @param groupName
     */
    public void resumeJob(String jobName, String groupName) {
        JobKey jobKey = new JobKey(jobName, groupName);
        JobDetail jobDetail = null;
        try {
            jobDetail = scheduler.getJobDetail(jobKey);
            if (jobDetail == null) {
                return;
            }
            scheduler.resumeJob(jobKey);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * 删除某个任务
     *
     * @param jobName
     * @param groupName
     */
    public void deleteJob(String jobName, String groupName) {
        JobKey jobKey = new JobKey(jobName, groupName);
        JobDetail jobDetail = null;
        try {
            jobDetail = scheduler.getJobDetail(jobKey);
            if (jobDetail == null) {
                return;
            }
            scheduler.deleteJob(jobKey);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * add job
     *
     * @param jobName
     * @param groupName
     * @param cronExpress
     * @param clz         execute class
     * @param params      jobData
     */
    public void addJobByCron(String jobName, String groupName, String cronExpress, Class clz, Map<String, String> params) {
        if (StringUtils.isBlank(cronExpress)) {
            logger.error("{} cronExpress can't be null, CronScheduleBuilder need cronExpress to execute ~ ");
            return;
        }
        // build job
        JobBuilder jobBuilder = JobBuilder.newJob(clz);
        if (params != null) {
            params.entrySet().stream().forEach(stringObjectEntry -> {
                jobBuilder.usingJobData(stringObjectEntry.getKey(), stringObjectEntry.getValue());
            });
        }
        JobDetail jobDetail = jobBuilder.withIdentity(jobName, groupName).build();
        // build trigger base on CronTrigger
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpress);
        CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity(jobName, groupName)
                .withSchedule(cronScheduleBuilder).build();
        try {
            scheduler.scheduleJob(jobDetail, cronTrigger);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }

    }

    /**
     * add job
     *
     * @param jobName
     * @param groupName
     * @param clz       execute class
     * @param startAt   startTime
     * @param endAt     endTime
     * @param params    jobData
     */
    public void addJob(String jobName, String groupName, Class clz, Date startAt, Date endAt, Map<String, String> params) {
        if (startAt == null) {
            logger.error("{} startAt can't be null, TriggerBuilder need trigger time to execute ~ ");
            return;
        }
        //build job
        JobBuilder jobBuilder = JobBuilder.newJob(clz);
        if (params != null) {
            params.entrySet().stream().forEach(stringObjectEntry -> {
                jobBuilder.usingJobData(stringObjectEntry.getKey(), stringObjectEntry.getValue());
            });
        }
        JobDetail jobDetail = jobBuilder.withIdentity(jobName, groupName).build();
        //build trigger base time
        TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger().startAt(startAt).withIdentity(jobName, groupName);
        if (endAt != null) {
            triggerBuilder.endAt(endAt);
        }
        Trigger trigger = triggerBuilder.build();
        try {
            scheduler.scheduleJob(jobDetail, trigger);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

}

其中注意需要传递参数可以使用usingJobData这个方法。

通过启动加载所有的任务到容器中：

package com.xx.init;

import com.google.common.collect.Maps;
import com.lema.rakeback.model.extra.CompanyInfoVo;
import com.lema.rakeback.service.superm.CompanyInfoService;
import com.lema.rakeback.task.CustomQuartzScheduler;
import com.lema.rakeback.task.job.EnterpriseGrantEndJob;
import com.lema.rakeback.task.job.EnterpriseGrantStartJob;
import com.lema.rakeback.utils.DateUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Map;

/**
 * @author xiaofeng
 * @version V1.0
 * @title: AppStartupRunner.java
 * @package: com.xx.init
 * @description: 服务器启动加载数据
 * @date 2019/4/19 10:41
 */
@Component
@Order(value = 0)
public class AppStartupRunner implements ApplicationRunner {
    Logger logger = LoggerFactory.getLogger(getClass());
    @Autowired
    private CustomQuartzScheduler quartzScheduler;
    @Autowired
    private CompanyInfoService companyInfoService;

    @Override
    public void run(ApplicationArguments applicationArguments) {
        logger.info(">>>>>>>>>服务启动后初始化操作，执行后台job操作<<<<<<<<<");
        List<CompanyInfoVo> companyInfoVos = companyInfoService.queryForList(0, null, null, null, 0, Integer.MAX_VALUE);
        if (!CollectionUtils.isEmpty(companyInfoVos)) {
            companyInfoVos.stream().forEach(companyInfoVo -> {
                String jobName1 = "job_" + companyInfoVo.getId() + "_start";
                String groupName1 = "group_" + companyInfoVo.getId() + "_start";
                String jobName2 = "job_" + companyInfoVo.getId() + "_end";
                String groupName2 = "group_" + companyInfoVo.getId() + "_end";
                Map<String, String> params = Maps.newHashMap();
                params.put("id", String.valueOf(companyInfoVo.getId()));
//                quartzScheduler.addJob(jobName1, gropName1, EnterpriseGrantStartJob.class, DateUtil.string2date2(companyInfoVo.getStartTime()), null, params);
//                quartzScheduler.addJob(jobName2, groupName2, EnterpriseGrantEndJob.class, DateUtil.string2date2(companyInfoVo.getEndTime()), null, params);
                quartzScheduler.addJobByCron(jobName1, groupName1, DateUtil.getCron(DateUtil.string2date2(companyInfoVo.getStartTime())), EnterpriseGrantStartJob.class, params);
                quartzScheduler.addJobByCron(jobName2, groupName2, DateUtil.getCron(DateUtil.string2date2(companyInfoVo.getEndTime())), EnterpriseGrantEndJob.class, params);

            });
        }
        logger.info(">>>>>>>>>后台job任务已经启动...<<<<<<<<<");
    }
}

业务执行相关类：

package com.xx.task.job;

import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author xiaofeng
 * @version V1.0
 * @title: EnterpriseGrantStartJob
 * @package: com.xx.task.job
 * @description: 企业授权开始job
 * @date 2019/4/19 11:40
 */
public class EnterpriseGrantStartJob implements Job {

    private Logger logger = LoggerFactory.getLogger(getClass());

    private void before() {
        logger.info("=================StartJob before===============");
    }

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        before();
        JobDataMap jobDataMap = jobExecutionContext.getJobDetail().getJobDataMap();
        /**
         * @// TODO: 2019/4/19 获取参数，执行业务 
         */
        Long id = jobDataMap.getLong("id");
        after();

    }

    private void after() {
        logger.info("=================StartJob before===============");
    }

}

注意：需要引入的pom依赖

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

ok，启动即可

Garry1115
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Springboot2-Quartz 后台可动态配置的定时任务
02-28
SpringBoot2 与 Quartz 整合的Demo。 后台可添加、修改、移除 定时任务。 也可查看当前任务的状态 灵活的定时任务
Spring boot + Quartz 动态任务调度
qq_38029917的博客
07-05 312
测试页面@Component public class TestTimeTask { /**     * 首次延时1s，然后每2秒执行一次     initialDelay = 1000,fixedRate = 2000     * cron 表达式   和    (10/2 * * * * ?)  initialDelay = 1000,fixedRate = 2000 一样的效果     */...
动态添加xxljob任务-xxljob源码改造
最新发布
qq_30166465的博客
05-31 874
在实际开发中，很多时候需要在代码中动态添加和执行xxljob的任务，那么原来的xxljob任务调度平台不能完成这项需求，就需要对源码进行改造。
Spring Boot Quartz 动态任务实现方式
Little_fxc的博客
12-25 929
1.项目结构 2.Maven &amp;lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&amp;gt; &amp;lt;project xmlns=&quot;http://maven.apache.org/POM/4.0.0&quot; xmlns:xsi=&quot;http://www.w3.org/2001/XMLSche
Springboot使用Quartz定时任务删除redis中的物品
qq_49195366的博客
11-06 160
/缓存的配置 @Configuration public class RedisConfig {//使用JSON进行序列化 @Bean public RedisTemplate < Object , Object > redisTemplate() {//JSON格式序列化 GenericFastJsonRedisSerializer serializer = new GenericFastJsonRedisSerializer();
SpringBoot+quartz实现定时任务的创建、删除、查询操作
m0_57037182的博客
08-27 1440
2、配置quartz的数据源等操作 需要对父类的方法进行重写。 做调度问题，不应该把任务写在配置类里面，应该用控制台增加，以下的文件直接拿来用就行。 5、DOM类的相关定义
springboot+quartz 定时处理数据任务
11-06
本文将详细解析如何利用SpringBoot和Quartz框架构建一个定时处理数据任务的项目，以及如何根据实际需求进行修改和扩展。 首先，SpringBoot是一个流行的Java微服务框架，它简化了Spring应用程序的开发过程，提供了...
Springboot2.0.1整合Quartz动态定时任务
09-15
本文将深入探讨如何在SpringBoot 2.0.1版本中整合Quartz，实现动态定时任务，并结合MyBatis-Plus进行数据操作。 首先，我们要在SpringBoot项目中引入Quartz和MyBatis-Plus的依赖。在`pom.xml`文件中，添加如下依赖...
SpringBoot实现动态定时任务
04-21
在Spring Boot框架中，动态定时任务的实现是一个重要的功能，尤其对于需要实时处理或调度的业务场景至关重要。本文将深入探讨如何使用Spring Boot来构建一个能够动态管理的任务调度系统，包括暂停、恢复、添加和删除...
Springboot整合Quartz实现定时任务数据库动态配置
03-17
在IT行业中，定时任务是许多应用不可或缺的一部分，用于执行定期的后台处理，如数据同步、报表生成、清理任务等。Spring Boot作为一个轻量级的Java框架，提供了与各种定时任务库集成的能力，其中Quartz是一个广泛...
Quartz架构篇 - 分布式任务调度Quartz
The Secret
01-15 2483
本文介绍分布式任务调度 Quartz
Java 定时任务调度器
weixin_39793432的博客
04-16 595
前台发来请求,后台创建并添加job,scheduler.scheduleJob(jobDetail, trigger); 到调度器 调度器读取,trigger 判断执行周期, 读取jobDetail判读执行内容. 依次创建了scheduler（调度器）、job（任务）、trigger（触发器），其中，job指定了MyJob，trigger保存job的触发执行策略（每隔3s执行一次），sche...
Quartz的重要接口API(二)
两个蝴蝶飞
04-28 1692
>勿以恶小而为之，勿以善小而不为--------------------------刘备 >劝诸君，多行善事积福报，莫作恶 主要内容: API的讲解
Spring Boot集成Quartz实现定时任务的动态创建、启动、暂停、恢复、删除。
毅呀毅呀哟
10-10 1万+
看了好多文章，都只讲了基础的demo用法，也就是简单的创建运行定时任务，对定时任务的管理却很少。我这里从0开始搭建一个简单的demo，包括定时任务的各种操作，以及API的一些用法，可以实现大多场景的需求。如： 普通定时任务的创建、启动、停止。 动态创建定时任务，如创建一个订单，5分钟后执行某某操作。 一、整个Quartz 的代码流程基本基本如下： 首先需要创建我们的任务(Job)，比如取消订单、定时发送短信邮件之类的，这是我们的任务主体，也是写业务逻辑的地方。 创建任务调度器(Schedul..
Quartz
取名为猫的狗的博客
07-06 445
文章目录1.job2.TaskManagement3.Task3.1 SimpleTrigger3.2 CalendarIntervalTrigger3.3 DailyTimeIntervalTrigger3.4 CronTrigger 依赖 <dependency> <groupId>org.quartz-scheduler</groupId> ...
SingleDateFormat--使用/教程/实例
IT利刃出鞘的博客
11-01 597
本文用示例介绍Java中的日期格式化类SimpleDateFormat的用法。 SimpleDateFormat的toString方法返回的String格式示例：Mon May 04 09:51:52 CDT 2013
初识Quartz之Job组件
carson0408的博客
04-08 678
        Quartz是一个开源的任务调度框架，它有别于Timer，有比Timer更好的性能。由于故障切换以及负载均衡能力使得Quartz框架具有如下特点：1.强大的调度功能。2.灵活的应用方式。3.分布式和集群能力。以上三个特点使得Quartz在多任务调度以及分布式中具有很大的作用，以下通过Quart框架中几个重要的组件来了解Quartz框架是如何工作的。关于Quartz框架，我们需要了解...
Spring boot 集成Quartz的使用（解决quartz的job无法注入spring对象的问题）
mengruobaobao的博客
01-19 7445
Spring Boot 整合 Quartz 实现定时任务1，添加Maven依赖 org.quartz-scheduler quartz 2.2.1 org.springframework spring-context-support 2，新建一个MyJobFacto
xxl-job通过代码的方式动态添加任务，修改任务，执行任务，停止任务等
热门推荐
lsqingfeng的博客
09-01 3万+
Xxl-job 是目前比较主流的轻量级定时任务框架，该框架以相对简单的使用方式，灵活的配置，和可读性强的源码 等优势，深得广大开发者的喜欢。让我们的定时任务实现起来变得简单。具体的使用方法这里就不介绍了，想了解的可以直接访问官网：https://www.xuxueli.com/xxl-job/ 今天我们主要解决一下使用xxl-job中的一个痛点，就是动态创建任务。使用过xxl-job的朋友们都知道，xxl-job给我们提供一个管理后台，我们可以在管理后台上，配置执行器，配置任务，管理任务。如下图。 这种
SpringBoot Quartz查询数据库动态创建定时任务
05-11
在Spring Boot中，可以通过集成Quartz框架来实现动态创建定时任务。下面是一个简单的示例，演示如何查询数据库来创建定时任务。 首先，需要在pom.xml文件中添加Quartz和MySQL的依赖： ```xml <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-quartz</artifactId> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency> </dependencies> ``` 然后，需要在application.properties文件中配置数据库连接信息： ```properties spring.datasource.url=jdbc:mysql://localhost:3306/mydb spring.datasource.username=root spring.datasource.password=root spring.datasource.driver-class-name=com.mysql.jdbc.Driver ``` 接下来，可以定义一个ScheduledJob实体类，用于映射数据库中的定时任务数据： ```java @Entity @Table(name = "scheduled_job") public class ScheduledJob { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name; private String group; private String cronExpression; private String description; // getters and setters } ``` 然后，创建一个JobFactory类，继承SpringBeanJobFactory，并重写createJobInstance方法，用于将Job实例交给Spring容器进行管理： ```java public class JobFactory extends SpringBeanJobFactory implements ApplicationContextAware { private transient AutowireCapableBeanFactory beanFactory; @Override public void setApplicationContext(final ApplicationContext context) { beanFactory = context.getAutowireCapableBeanFactory(); } @Override protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception { final Object job = super.createJobInstance(bundle); beanFactory.autowireBean(job); return job; } } ``` 最后，创建一个JobScheduler类，用于从数据库中读取定时任务数据，并创建对应的定时任务： ```java @Component public class JobScheduler { @Autowired private SchedulerFactory schedulerFactory; @Autowired private JobFactory jobFactory; @Autowired private DataSource dataSource; @PostConstruct public void init() throws Exception { final Scheduler scheduler = schedulerFactory.getScheduler(); scheduler.setJobFactory(jobFactory); final String sql = "select * from scheduled_job"; try (final Connection connection = dataSource.getConnection(); final PreparedStatement statement = connection.prepareStatement(sql); final ResultSet resultSet = statement.executeQuery()) { while (resultSet.next()) { final JobDetail jobDetail = JobBuilder.newJob(QuartzJob.class) .withIdentity(resultSet.getString("name"), resultSet.getString("group")) .withDescription(resultSet.getString("description")) .build(); final Trigger trigger = TriggerBuilder.newTrigger() .withIdentity(resultSet.getString("name"), resultSet.getString("group")) .withSchedule(CronScheduleBuilder.cronSchedule(resultSet.getString("cron_expression"))) .build(); scheduler.scheduleJob(jobDetail, trigger); } scheduler.start(); } } } ``` 在上面的代码中，首先通过SchedulerFactory获取Scheduler实例，并设置JobFactory。然后，通过数据库查询语句从数据库中获取定时任务数据，并创建对应的JobDetail和Trigger实例。最后，将JobDetail和Trigger实例添加到Scheduler中，并启动Scheduler。 需要注意的是，QuartzJob类需要继承QuartzJobBean，并实现executeInternal方法，用于执行定时任务的具体逻辑： ```java public class QuartzJob extends QuartzJobBean { @Override protected void executeInternal(final JobExecutionContext context) throws JobExecutionException { // 定时任务逻辑 } } ``` 至此，一个动态创建定时任务的示例就完成了。需要注意的是，该示例仅供参考，实际应用中还需要考虑很多细节问题，如异常处理、任务状态管理等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值