SpringBoot整合Quartz实现定时任务动态自定义和可视化

最新推荐文章于 2024-07-25 22:44:17 发布
最新推荐文章于 2024-07-25 22:44:17 发布
阅读量2.1k 收藏 7
点赞数 1
文章标签： spring boot 后端 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61496760/article/details/134239302
版权

最近项目需要使用动态的定时任务，而且还需要在后台进行可视化管理动态任务。这里其实有两个实现思路：第一个就是xxlJob动态任务、第二个就是Quartz框架，这两个的技术路线与框架都是很成熟的技术，都是可以提供动态可支持的定时任务，而且都支持分布式开发。大体的区别就是在于：xxlJob对于分布式和微服务的模式更加的友好，自身就提供了可管理任务的可视化界面，而且配置与使用以及开大起来都是相对便捷一些。Quartz其实也可以用于分布式，但是微服务的话就不推荐使用了。如果你的项目是模块化项目或者是多个项目组成的那就可以使用Quartz这个技术，我个人认为用起来比较舒服，能满足动态定时的基本操作，实现起来也不是很难。接下来就介绍一下springboot怎么整合Quartz实现动态定时任务。

第一步：依然是常规化的导入依赖

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

第二步：在.yml文件中增加配置

quartz:
#    job-store-type: jdbc
#    properties:
#      org:
#        quartz:
#          scheduler:
#            instanceName: clusteredScheduler
#            instanceId: AUTO
#          jobStore:
#            selectWithLockSQL: SELECT * FROM {0}LOCKS UPDLOCK WHERE LOCK_NAME = ?
#            class: org.springframework.scheduling.quartz.LocalDataSourceJobStore
#            tablePrefix: QRTZ_
#            isClustered: false # 打开集群配置
#            clusterCheckinInterval: 2000 # 设置集群检查间隔20s
#            useProperties: false
#          threadPool:
#            class: org.quartz.simpl.SimpleThreadPool
#            threadCount: 10
#            threadPriority: 5
#            threadsInheritContextClassLoaderOfInitializingThread: true

导入之后把注释去掉，其他的都不用改，需要注意一点tablePrefix这个配置，这个是Quartz需要用到的表的表名前缀，最好不要改，当前你想改也是可以的，但是改起来会很麻烦，要改很多的文件。

第三步：导入需要用到的表（直接从资源里面下载，导入到数据库中即可）

简单介绍一下表的作用

qrtz开头的表示Quartz动态任务调用时的必须要用到的表，千万不要随意增减字段，有调度任务表，时间表达式存储表，正在运行任务的表等等。下面的这个sys_schedule表，里面的字段不要删，但是你可以增加你想要的字段。这里面记录了你自己系统里面发起任务的数据。相当于前端form表单提交的任务数据就会保存到这个表里面，导入这个表后，使用工具生成最基本的实体类，controller类等基本类，跟平时开发是一样的。但需要特别注意的是，我们需要设置数据库忽略大小写的配置，在mysql配置文件中增加一个属性就行，网上很多。

第四步：代码配置Task任务：

@DisallowConcurrentExecution
public abstract class Task implements Job {

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        run();
        System.out.println("任务在" + DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").format(LocalDateTime.now()) + " 时运行");
    }


    public abstract void run();
}

这是一个抽象类，实现了Job任务类，当前端调用你的controller层方法时，任务触发会先执行这个execute这个方法，这个方法里面会先用这个run方法，关键点就是这个run的抽象方法是我们自己定义的。以后你想实现什么定时任务，就需要要继承这个Task类并且实现这个run方法，就可调用你的代码了，例如下面：

@DisallowConcurrentExecution
public class TestSchedule extends Task {

    @Override
    public void run() {
        System.out.println("=============定时任务被调用了====================");
    }


}

在这个实现了父类的run方法里面写你的具体逻辑。每写一个定时任务类，你都要继承这个Task类，实现run方法。

第五步：核心任务调度的contorller与services层的调用任务代码，直接粘进行用即可。

 /**
     * 暂停任务
     */
    @PostMapping("stop")
    public ResponseJson stop(SysSchedule scheduleJob) {
        sysScheduleService.stopJob(scheduleJob);
        return buildSuccessResult("暂停成功!");
    }


    /**
     * 立即运行一次
     */
    @PostMapping("startNow")
    public ResponseJson stratNow(SysSchedule scheduleJob) {
        sysScheduleService.startNowJob(scheduleJob);
        return buildSuccessResult("运行成功");
    }

    /**
     * 恢复
     */
    @PostMapping("resume")
    public ResponseJson resume(SysSchedule scheduleJob, RedirectAttributes redirectAttributes) {
        sysScheduleService.restartJob(scheduleJob);
        //恢复之后，立即触发一次激活定时任务，不然定时任务有可能不会执行
        sysScheduleService.startNowJob(scheduleJob);
        return buildSuccessResult("恢复成功");
    }

    /**
     * 批量删除定时任务
     */
    @DeleteMapping("delete")
    public ResponseJson deleteAll(String ids, RedirectAttributes redirectAttributes) {
        String idArray[] = ids.split(",");
        for (String id : idArray) {
            sysScheduleService.deleteByIds(sysScheduleService.getById(id));
        }
        return buildSuccessResult("删除成功");
    }
@Transactional(readOnly = false)
    @Override
    public void stopJob(SysSchedule SysSchedule) {
        JobKey key = new JobKey(SysSchedule.getName(), SysSchedule.getSchGroup());
        try {
            scheduler.pauseJob(key);
            SysSchedule.setStatus("0");
            super.updateById(SysSchedule);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    @Transactional(readOnly = false)
    @Override
    public void startNowJob(SysSchedule SysSchedule) {
        JobKey key = new JobKey(SysSchedule.getName(), SysSchedule.getSchGroup());
        try {
            scheduler.triggerJob(key);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }


    /**
     * 恢复任务
     */
    @Transactional(readOnly = false)
    @Override
    public void restartJob(SysSchedule SysSchedule) {
        JobKey key = new JobKey(SysSchedule.getName(), SysSchedule.getSchGroup());
        try {
            scheduler.resumeJob(key);
            SysSchedule.setStatus("1");
            super.updateById(SysSchedule);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    @Transactional(readOnly = false)
    @Override
    public void saveJob(SysSchedule SysSchedule) {
        SysSchedule t = this.getById(SysSchedule.getId());
        if (Objects.nonNull(t)) {
            JobKey key = new JobKey(t.getName(), t.getSchGroup());
            try {
                scheduler.deleteJob(key);
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
        }
        this.add(SysSchedule);
        super.save(SysSchedule);
    }

    @Override
    public void deleteByIds(SysSchedule scheduleJob) {
        JobKey key = new JobKey(scheduleJob.getName(), scheduleJob.getSchGroup());
        try {
            scheduler.deleteJob(key);
            super.removeById(scheduleJob);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }

    }
@Transactional(readOnly = false)
    public void add(SysSchedule SysSchedule) {
        Class job = null;
        try {
            job = Class.forName(SysSchedule.getClassname());
        } catch (ClassNotFoundException e1) {
            e1.printStackTrace();
        }
        JobDetail jobDetail = JobBuilder.newJob(job).withIdentity(SysSchedule.getName(), SysSchedule.getSchGroup())
                .build();
        jobDetail.getJobDataMap().put("SysSchedule", SysSchedule);

        // 表达式调度构建器（可判断创建SimpleScheduleBuilder）
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(SysSchedule.getExpression());

        // 按新的cronExpression表达式构建一个新的trigger
        CronTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity(SysSchedule.getName(), SysSchedule.getSchGroup()).withSchedule(scheduleBuilder).build();
        try {
            scheduler.scheduleJob(jobDetail, trigger);
            JobKey key = new JobKey(SysSchedule.getName(), SysSchedule.getSchGroup());
            if (SysSchedule.getStatus().equals("0")) {
                scheduler.pauseJob(key);
            } else {
                scheduler.resumeJob(key);
            }

        } catch (SchedulerException e) {
            e.printStackTrace();
        }

    }

    /**
     * 获取所有JobDetail
     *
     * @return 结果集合
     */
    public List<JobDetail> getJobs() {
        try {
            GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
            Set<JobKey> jobKeys = scheduler.getJobKeys(matcher);
            List<JobDetail> jobDetails = new ArrayList<JobDetail>();
            for (JobKey key : jobKeys) {
                jobDetails.add(scheduler.getJobDetail(key));
            }
            return jobDetails;
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取所有计划中的任务
     *
     * @return 结果集合
     */
    public List<SysSchedule> getAllSysSchedule() {
        List<SysSchedule> SysScheduleList = new ArrayList<SysSchedule>();
        ;
        GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
        try {
            Set<JobKey> jobKeys = scheduler.getJobKeys(matcher);
            for (JobKey jobKey : jobKeys) {
                List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
                for (Trigger trigger : triggers) {
                    SysSchedule SysSchedule = new SysSchedule();
                    SysSchedule.setName(jobKey.getName());
                    SysSchedule.setSchGroup(jobKey.getGroup());
                    Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                    SysSchedule.setStatus(triggerState.name());
                    //获取要执行的定时任务类名
                    JobDetail jobDetail = scheduler.getJobDetail(jobKey);
                    SysSchedule.setClassname(jobDetail.getJobClass().getName());
                    //判断trigger
                    if (trigger instanceof SimpleTrigger) {
                        SimpleTrigger simple = (SimpleTrigger) trigger;
                        SysSchedule.setExpression("重复次数:" + (simple.getRepeatCount() == -1 ?
                                "无限" : simple.getRepeatCount()) + ",重复间隔:" + (simple.getRepeatInterval() / 1000L));
                        SysSchedule.setDescription(simple.getDescription());
                    }
                    if (trigger instanceof CronTrigger) {
                        CronTrigger cron = (CronTrigger) trigger;
                        SysSchedule.setExpression(cron.getCronExpression());
                        SysSchedule.setDescription(cron.getDescription() == null ? ("触发器:" + trigger.getKey()) : cron.getDescription());
                    }
                    SysScheduleList.add(SysSchedule);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return SysScheduleList;
    }

    /**
     * 获取所有运行中的任务
     *
     * @return 结果集合
     */
    public List<SysSchedule> getAllRuningSysSchedule() {
        List<SysSchedule> SysScheduleList = null;
        try {
            List<JobExecutionContext> executingJobs = scheduler.getCurrentlyExecutingJobs();
            SysScheduleList = new ArrayList<SysSchedule>(executingJobs.size());
            for (JobExecutionContext executingJob : executingJobs) {
                SysSchedule SysSchedule = new SysSchedule();
                JobDetail jobDetail = executingJob.getJobDetail();
                JobKey jobKey = jobDetail.getKey();
                Trigger trigger = executingJob.getTrigger();
                SysSchedule.setName(jobKey.getName());
                SysSchedule.setSchGroup(jobKey.getGroup());
                //SysSchedule.setDescription("触发器:" + trigger.getKey());
                Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                SysSchedule.setStatus(triggerState.name());
                //获取要执行的定时任务类名
                SysSchedule.setClassname(jobDetail.getJobClass().getName());
                //判断trigger
                if (trigger instanceof SimpleTrigger) {
                    SimpleTrigger simple = (SimpleTrigger) trigger;
                    SysSchedule.setExpression("重复次数:" + (simple.getRepeatCount() == -1 ?
                            "无限" : simple.getRepeatCount()) + ",重复间隔:" + (simple.getRepeatInterval() / 1000L));
                    SysSchedule.setDescription(simple.getDescription());
                }
                if (trigger instanceof CronTrigger) {
                    CronTrigger cron = (CronTrigger) trigger;
                    SysSchedule.setExpression(cron.getCronExpression());
                    SysSchedule.setDescription(cron.getDescription());
                }
                SysScheduleList.add(SysSchedule);
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return SysScheduleList;
    }

    /**
     * 获取所有的触发器
     *
     * @return 结果集合
     */
    public List<SysSchedule> getTriggersInfo() {
        try {
            GroupMatcher<TriggerKey> matcher = GroupMatcher.anyTriggerGroup();
            Set<TriggerKey> Keys = scheduler.getTriggerKeys(matcher);
            List<SysSchedule> triggers = new ArrayList<SysSchedule>();

            for (TriggerKey key : Keys) {
                Trigger trigger = scheduler.getTrigger(key);
                SysSchedule SysSchedule = new SysSchedule();
                SysSchedule.setName(trigger.getJobKey().getName());
                SysSchedule.setSchGroup(trigger.getJobKey().getGroup());
                SysSchedule.setStatus(scheduler.getTriggerState(key) + "");
                if (trigger instanceof SimpleTrigger) {
                    SimpleTrigger simple = (SimpleTrigger) trigger;
                    SysSchedule.setExpression("重复次数:" + (simple.getRepeatCount() == -1 ?
                            "无限" : simple.getRepeatCount()) + ",重复间隔:" + (simple.getRepeatInterval() / 1000L));
                    SysSchedule.setDescription(simple.getDescription());
                }
                if (trigger instanceof CronTrigger) {
                    CronTrigger cron = (CronTrigger) trigger;
                    SysSchedule.setExpression(cron.getCronExpression());
                    SysSchedule.setDescription(cron.getDescription());
                }
                triggers.add(SysSchedule);
            }
            return triggers;
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return null;
    }

第六步：开发可视化界面，这个界面以及表单就是根据sys_schedule这个表生成的。具体的我把图贴出来供大家参考：

具体界面随开发进行变化，但是基本字段就这样，如果你还想加字段，也可以加。表单中的定时规则大家可以再往上找一个cron表达式的生成页面，让用户去选，然后生成表达式。在controller中，调用每一个任务时，参数都是SysSchedule这个实体类，把数据中的每个字段都让前端传到后端接收，后端只需要调用相应的任务方法即可。

当你测试或者保存的任务的时候，sys_schedule这个表就会多一条任务数据，相应的qrtz相关表里也会多出数据，测试是否集成成功了，你就测试新增成功后qrtz相关表里是否多了相应数据以及表达式的数据。

如果有什么问题，可以留言一起讨论

多余丿
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springboot整合Quartz实现动态配置定时任务的方法
08-29
本篇文章主要介绍了springboot整合Quartz实现动态配置定时任务的方法，非常具有实用价值，需要的朋友可以参考下
springboot整合quartz实现定时任务示例
08-30
spring支持多种定时任务的实现。我们来介绍下使用spring的定时器和使用quartz定时器，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。
Spring Task 上手和使用详解 +实例分析
Rockivy的博客
05-11 850
是Spring框架提供的任务调度工具，可以按照约定的时间自动执行某个代码逻辑。**定位：**定时任务框架**作用：**定时自动执行某段Java代码为什么要在Java程序中使用Spring Task？1). 信用卡每月还款提醒2). 银行贷款每月还款提醒3). 火车票售票系统处理未支付订单4). 入职纪念日为用户发送通知**强调：**只要是需要定时处理的场景都可以使用Spring Task。
SpringBoot整合Quartz实现定时任务的自定义和可视化
11-06
SpringBoot整合Quartz实现定时任务的自定义和可视化
SpringBoot系列：Spring Boot集成定时任务Quartz
2301_79963818的博客
04-17 664
首先定义定时具体执行逻辑Job，创建类QuartzJob1，这里集继承QuartzJobBean实现executeInternal即可，该方法即定时执行任务逻辑，这里简单打印了下当前时间。@Override然后创建QuartzConfig，接着定义JobDetail，JobDetail由JobBuilder构建，同时关联了任务QuartzJob1。@Bean。
SpringBoot实现quartz定时任务可视化管理
月月鸟先森的博客
08-29 1785
前言 在实际框架或产品开发过程中，springboot中集成quarzt方式基本是以job和trigger的bean对象方式直接硬编码完成的，例如以下代码示例。对于系统内定义的所有定时任务类型，具体执行类，执行策略，运行状态都没有一个动态全局的管理，所有决定将quartz做成可视化配置管理，便于统一管理，也降低了使用门槛，只需要关心job类的实现即可 @Bean public JobDetail SMSJobDetail() { return JobBuilder.newJo
Spring Boot集成持久化Quartz定时任务管理和界面展示
mark's technic world
10-11 748
前言 本文是对之前的一篇文章Spring+SpringMVC+mybatis+Quartz整合代码部分做的一个修改和补充， 其中最大的变化就是后台框架变成了Spring Boot。 本工程所用到的技术或工具有： Spring BootMybatisQuartzPageHelperVueJSElementUIMySql数据库 正文 配置 本例中仍然是使用m
SpringBoot整合Quartz定时任务持久化到数据库的开发。超详细，可用
languageStudent的博客
03-11 2903
开发环境准备 开发环境： jdk11 springboot 2.4.3 quartz 2.3.2 mysql 1. gradle导入依赖 implementation 'org.springframework.boot:spring-boot-starter-web' compile group: 'com.baomidou', name: 'mybatis-plus-boot-starter', version: '3.3.2' compile group: 'com.baomidou',
Springboot整合Quartz实现定时任务数据库动态配置
03-17
本篇文章将详细探讨如何在Spring Boot项目中整合Quartz，并通过MySQL数据库实现定时任务的动态配置。 首先，我们需要在项目中添加依赖。在Spring Boot的`pom.xml`文件中，引入Spring Boot的`spring-boot-starter-...
SpringBoot 整合Quartz（集群）实现定时任务调度
02-14
SpringBoot整合Quartz实现定时任务调度是企业级应用中常见的需求，主要用于自动化执行某些周期性的任务，例如数据备份、报表生成、系统维护等。Quartz是一个功能强大的开源作业调度框架，能够灵活地定义任务和调度...
SpringBoot集成Quartz实现持久化存储和可视化页面管理
萌新求带
11-07 2815
前言 本文主要是Springboot集成Quartz实现定时任务的数据库存储以及前端页面的可视化管理，所使用的主要工具有：Springboot、Mybatis-Plus、Quartz、Layui、Mysql等 正文 1.准备环境 1.创建数据库 因为本例子中业务数据和定时数据是分开的，所以先创建两个空数据库，一个用于业务，一个用于Quartz，数据库名字任意，我的是：bml_base（业务）、bml_quartz（定时） 2.创建项目 创建一个Springboot项目，勾选一些必需依赖，例如druid、qu
SpringBoot集成Quartz 2.3.1动态管理定时任务
weipinggg的博客
09-23 2047
我写了一个简单的Demo项目，有需要的文末可获取项目github地址，该项目我会一直保持更新。基于quartz2.3.1实现动态管理定时任务。使用swagger实现接口文档。前后端统一使用JSON格式交互。使用Hutool工具类直接连接数据库，避免Job任务中不能使用Autowired问题。swagger文档如下图：后续文章创建JobDetail（JobBuilder详解）创建CronTrigger（TriggerBuilder详解）
Springboot Quartz定时任务的动态调度使用，实战详解，java教学管理系统的实现技术
m0_54865014的博客
12-19 710
private Date updateTime; //更新时间 @Override public String toString() { return “JobEntity{” + “jobId=’” + jobId + ‘’’ + “, className=’” + className + ‘’’ + “, cronExpression=’” + cronExpression + ‘’’ + “, jobName=’” + jobName + ‘’’ + “, jobGroup=’” + jobGroup
Spring Boot集成Quartz实现定时任务的动态创建、启动、暂停、恢复、删除。
热门推荐
毅呀毅呀哟
10-10 1万+
看了好多文章，都只讲了基础的demo用法，也就是简单的创建运行定时任务，对定时任务的管理却很少。我这里从0开始搭建一个简单的demo，包括定时任务的各种操作，以及API的一些用法，可以实现大多场景的需求。如： 普通定时任务的创建、启动、停止。 动态创建定时任务，如创建一个订单，5分钟后执行某某操作。 一、整个Quartz 的代码流程基本基本如下： 首先需要创建我们的任务(Job)，比如取消订单、定时发送短信邮件之类的，这是我们的任务主体，也是写业务逻辑的地方。 创建任务调度器(Schedul..
SpringBoot 集成 xxl-job 实现定时任务管理
weixin_45626288的博客
07-05 3523
XXL-Job是一个功能强大的分布式任务调度框架，集成了Spring Boot后能够发挥更大的优势。它提供了分布式任务调度、任务执行报告、任务调度中心、良好的扩展性、分布式集群部署、监控与报警等多种优势。此外，XXL-Job是开源免费的，可以在GitHub上获取源代码和详细文档。详细的文档和使用指南可以在XXL-Job的官方文档中找到。
Spring Boot组成的分布式系统中实现日志跟踪
心猿意码
07-25 366
除了使用Sleuth和Zipkin之外，我们还可以自定义日志输出格式，以便更容易地识别请求的追踪信息。Xml深色版本1通过使用Spring Cloud Sleuth和Zipkin，我们可以轻松地为Spring Boot应用实现日志跟踪。这种方式不仅简化了日志跟踪的实现，还提供了强大的可视化工具，帮助我们更好地理解和调试分布式系统。此外，通过自定义日志输出格式和使用MDC，我们可以进一步定制日志以适应特定的需求。
Spring boot 2.0 升级到 3.3.1 的相关问题 （五）
飞一站的博客
07-24 441
解决Spring boot 2.0 升级到3.3.1 版本的druid 配置和Redis配置不生效的问题。
Spring Boot 集成 Kafka
最新发布
Casual_Lei的博客
07-25 677
Spring Boot 与 Kafka 的集成使得消息队列的使用变得更加简单和高效。通过上述步骤，你可以轻松地配置 Kafka、实现生产者和消费者，并利用 Spring Boot 提供的强大功能来处理消息流。了解 Kafka 的高级特性（如事务和异步处理）能够帮助你更好地满足业务需求，确保系统的高可用性和数据一致性。
SpringBoot搭配Quartz实现动态定时任务源码
06-06
好的，以下是 SpringBoot 搭配 Quartz 实现动态定时任务的源码： 1. 首先，我们需要引入 Quartz 和 SpringBoot 的依赖： ```xml <!-- Quartz相关依赖 --> <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.3.2</version> </dependency> <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz-jobs</artifactId> <version>2.3.2</version> </dependency> <!-- SpringBoot相关依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> ``` 2. 创建定时任务实体类，用于封装定时任务的信息，包括任务名称、任务组、任务类名、任务状态（是否启用）、任务表达式等： ```java @Entity @Table(name = "job_task") @Data public class JobTask implements Serializable { private static final long serialVersionUID = 1L; /** * ID */ @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; /** * 任务名称 */ @NotBlank(message = "任务名称不能为空") private String name; /** * 任务分组 */ @NotBlank(message = "任务分组不能为空") private String group; /** * 任务类名 */ @NotBlank(message = "任务类名不能为空") private String className; /** * 任务状态，0：禁用，1：启用 */ @NotNull(message = "任务状态不能为空") private Integer status; /** * 任务表达式 */ @NotBlank(message = "任务表达式不能为空") private String cronExpression; /** * 创建时间 */ private LocalDateTime createTime; /** * 最后一次修改时间 */ private LocalDateTime updateTime; } ``` 3. 创建定时任务的服务类，用于管理定时任务的增删改查等操作，同时也需要实现 `InitializingBean` 接口，在启动应用时加载已存在的定时任务： ```java @Service @AllArgsConstructor public class JobTaskService implements InitializingBean { private final Scheduler scheduler; private final JobTaskRepository jobTaskRepository; /** * 添加任务 * @param jobTask * @return * @throws Exception */ public boolean addJobTask(JobTask jobTask) throws Exception { if (jobTask == null || StringUtils.isBlank(jobTask.getCronExpression())) { return false; } if (StringUtils.isBlank(jobTask.getName()) || StringUtils.isBlank(jobTask.getClassName())) { throw new Exception("任务名称或任务类名不能为空"); } // 判断任务是否已存在 JobKey jobKey = JobKey.jobKey(jobTask.getName(), jobTask.getGroup()); if (scheduler.checkExists(jobKey)) { return false; } // 构建任务实例 JobDetail jobDetail = JobBuilder.newJob(getClass(jobTask.getClassName()).getClass()) .withIdentity(jobTask.getName(), jobTask.getGroup()) .build(); // 构建任务触发器 CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(jobTask.getCronExpression()); CronTrigger trigger = TriggerBuilder.newTrigger() .withIdentity(jobTask.getName(), jobTask.getGroup()) .withSchedule(cronScheduleBuilder) .build(); // 注册任务和触发器 scheduler.scheduleJob(jobDetail, trigger); // 如果任务状态为启用，则立即启动任务 if (jobTask.getStatus() == 1) { scheduler.triggerJob(jobKey); } // 保存任务信息 jobTask.setCreateTime(LocalDateTime.now()); jobTask.setUpdateTime(LocalDateTime.now()); jobTaskRepository.save(jobTask); return true; } /** * 修改任务 * @param jobTask * @return * @throws Exception */ public boolean modifyJobTask(JobTask jobTask) throws Exception { if (jobTask == null || StringUtils.isBlank(jobTask.getCronExpression())) { return false; } if (StringUtils.isBlank(jobTask.getName()) || StringUtils.isBlank(jobTask.getClassName())) { throw new Exception("任务名称或任务类名不能为空"); } // 判断任务是否存在 JobKey jobKey = JobKey.jobKey(jobTask.getName(), jobTask.getGroup()); if (!scheduler.checkExists(jobKey)) { return false; } // 修改任务触发器 CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(jobTask.getCronExpression()); CronTrigger newTrigger = TriggerBuilder.newTrigger() .withIdentity(jobTask.getName(), jobTask.getGroup()) .withSchedule(cronScheduleBuilder) .build(); scheduler.rescheduleJob(TriggerKey.triggerKey(jobTask.getName(), jobTask.getGroup()), newTrigger); // 修改任务信息 JobTask oldJobTask = jobTaskRepository.findByNameAndGroup(jobTask.getName(), jobTask.getGroup()); oldJobTask.setClassName(jobTask.getClassName()); oldJobTask.setStatus(jobTask.getStatus()); oldJobTask.setCronExpression(jobTask.getCronExpression()); oldJobTask.setUpdateTime(LocalDateTime.now()); jobTaskRepository.save(oldJobTask); return true; } /** * 删除任务 * @param name * @param group * @return * @throws Exception */ public boolean deleteJobTask(String name, String group) throws Exception { JobKey jobKey = JobKey.jobKey(name, group); if (!scheduler.checkExists(jobKey)) { return false; } scheduler.deleteJob(jobKey); jobTaskRepository.deleteByNameAndGroup(name, group); return true; } /** * 获取所有任务 * @return */ public List<JobTask> getAllJobTask() { return jobTaskRepository.findAll(); } /** * 根据任务名称和分组获取任务信息 * @param name * @param group * @return */ public JobTask getJobTaskByNameAndGroup(String name, String group) { return jobTaskRepository.findByNameAndGroup(name, group); } /** * 获取任务类实例 * @param className * @return * @throws Exception */ private Object getClass(String className) throws Exception { Class<?> clazz = Class.forName(className); return clazz.newInstance(); } /** * 实现 InitializingBean 接口，在启动应用时加载已存在的定时任务 * @throws Exception */ @Override public void afterPropertiesSet() throws Exception { List<JobTask> jobTaskList = jobTaskRepository.findAll(); for (JobTask jobTask : jobTaskList) { if (jobTask.getStatus() == 1) { addJobTask(jobTask); } } } } ``` 4. 创建定时任务的控制器类，用于处理新增、修改、删除等请求： ```java @RestController @AllArgsConstructor @RequestMapping("/job") public class JobTaskController { private final JobTaskService jobTaskService; /** * 添加任务 * @param jobTask * @return * @throws Exception */ @PostMapping public ResponseEntity addJobTask(@RequestBody JobTask jobTask) throws Exception { boolean result = jobTaskService.addJobTask(jobTask); return result ? ResponseEntity.ok("任务添加成功") : ResponseEntity.badRequest().body("任务添加失败"); } /** * 修改任务 * @param jobTask * @return * @throws Exception */ @PutMapping public ResponseEntity modifyJobTask(@RequestBody JobTask jobTask) throws Exception { boolean result = jobTaskService.modifyJobTask(jobTask); return result ? ResponseEntity.ok("任务修改成功") : ResponseEntity.badRequest().body("任务修改失败"); } /** * 删除任务 * @param name * @param group * @return * @throws Exception */ @DeleteMapping("/{name}/{group}") public ResponseEntity deleteJobTask(@PathVariable String name, @PathVariable String group) throws Exception { boolean result = jobTaskService.deleteJobTask(name, group); return result ? ResponseEntity.ok("任务删除成功") : ResponseEntity.badRequest().body("任务删除失败"); } /** * 获取所有任务 * @return */ @GetMapping public ResponseEntity getAllJobTask() { List<JobTask> jobTaskList = jobTaskService.getAllJobTask(); return ResponseEntity.ok(jobTaskList); } /** * 根据任务名称和分组获取任务信息 * @param name * @param group * @return */ @GetMapping("/{name}/{group}") public ResponseEntity getJobTaskByNameAndGroup(@PathVariable String name, @PathVariable String group) { JobTask jobTask = jobTaskService.getJobTaskByNameAndGroup(name, group); return ResponseEntity.ok(jobTask); } } ``` 5. 创建定时任务的启动类，用于启动 SpringBoot 应用： ```java @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } /** * 注册定时任务调度器 * @return * @throws SchedulerException */ @Bean public SchedulerFactoryBean schedulerFactoryBean() throws SchedulerException { SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean(); Properties properties = new Properties(); properties.put("org.quartz.scheduler.instanceName", "ChitGPTScheduler"); properties.put("org.quartz.threadPool.threadCount", "10"); schedulerFactoryBean.setQuartzProperties(properties); schedulerFactoryBean.setStartupDelay(5); return schedulerFactoryBean; } /** * 注册定时任务实例 * @return */ @Bean public Scheduler scheduler() { return schedulerFactoryBean().getScheduler(); } } ``` 以上就是 SpringBoot 搭配 Quartz 实现动态定时任务的源码，希望能对您有所帮助！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值