记:SpringBoot+quartz+jedis分布式自动任务实现

最新推荐文章于 2024-04-12 08:42:30 发布
最新推荐文章于 2024-04-12 08:42:30 发布
阅读量1k 收藏 5
点赞数 2
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32486913/article/details/85254550
版权

SpringBoot版本：2.0.4.RELEASE
redis版本:redis-5.0.3
JDK：1.8
工具：idea
版本管理：maven
quartz版本:2.2.1

前言

SpringCloud项目多实例部署中，调度中心需实现分布式调度。以避免自动任务重复执行。

实现过程

  • 创建SpringBoot项目
  • 添加依赖
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-dependencies</artifactId>
		<version>2.0.4.RELEASE</version>
		<type>pom</type>
		<scope>import</scope>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-context-support</artifactId>
	</dependency>
	<dependency>
		<groupId>net.joelinn</groupId>
		<artifactId>quartz-redis-jobstore</artifactId>
		<version>1.1.13</version>
	</dependency>
	<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
  	</dependency>

org:
  quartz:
    jobStore:
      class: net.joelinn.quartz.jobstore.RedisJobStore
      host: 192.168.1.11:7000,192.168.1.11:7000,192.168.1.11:7000
      misfireThreshold: 60000
      password:
      port: 7000
      redisCluster: true
      redisSentinel: true
      masterGroupName: quartz_redis_
      database: 0
      keyPrefix: a_prefix_quartz_key_
      lockTimeout: 30000
      ssl: false
  • 配置quartz
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.spi.JobFactory;
import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;

import java.io.IOException;
import java.util.Properties;

@Configuration
public class SchedulerConfiguration {

    @Value("${org.quartz.jobStore.class}")
    private String jobStoreClass;

    @Value("${org.quartz.jobStore.host}")
    private String jobStoreHost;

    @Value("${org.quartz.jobStore.misfireThreshold}")
    private String jobStoreMisfireThreshold;

    @Value("${org.quartz.jobStore.password}")
    private String jobStorePassword;

    @Value("${org.quartz.jobStore.port}")
    private String jobStorePort;

    @Value("${org.quartz.jobStore.redisCluster}")
    private String jobStoreRedisCluster;

    @Value("${org.quartz.jobStore.redisSentinel}")
    private String jobStoreRedisSentinel;

    @Value("${org.quartz.jobStore.masterGroupName}")
    private String jobStoreMasterGroupName;

    @Value("${org.quartz.jobStore.database}")
    private String jobStoreDataBase;

    @Value("${org.quartz.jobStore.keyPrefix}")
    private String jobStoreKeyPrefix;

    @Value("${org.quartz.jobStore.lockTimeout}")
    private String jobStoreLockTimeout;

    @Value("${org.quartz.jobStore.ssl}")
    private String jobStoreSsl;

    @Bean
    public JobFactory jobFactory(ApplicationContext applicationContext) {
        AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory();
        jobFactory.setApplicationContext(applicationContext);
        return jobFactory;
    }

    @Bean
    public Scheduler scheduler(SchedulerFactoryBean schedulerFactoryBean) throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        scheduler.start();
        return scheduler;
    }

    /**
     *
     * @param jobFactory
     * @return
     * @throws IOException
     */
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(JobFactory jobFactory) throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setOverwriteExistingJobs(true);
        //设置自行启动
        factory.setAutoStartup(true);
        factory.setJobFactory(jobFactory);
        factory.setQuartzProperties(quartzProperties());
        return factory;
    }
	
    @Bean
    public Properties quartzProperties() {
        Properties prop = new Properties();
        prop.put("org.quartz.jobStore.class", jobStoreClass);
        prop.put("org.quartz.jobStore.host", jobStoreHost);
        prop.put("org.quartz.jobStore.misfireThreshold", jobStoreMisfireThreshold);
        prop.put("org.quartz.jobStore.password", jobStorePassword);
        prop.put("org.quartz.jobStore.port", jobStorePort);
        prop.put("org.quartz.jobStore.redisCluster", jobStoreRedisCluster);
        prop.put("org.quartz.jobStore.redisSentinel", jobStoreRedisSentinel);
        prop.put("org.quartz.jobStore.masterGroupName", jobStoreMasterGroupName);
        prop.put("org.quartz.jobStore.database", jobStoreDataBase);
        prop.put("org.quartz.jobStore.keyPrefix", jobStoreKeyPrefix);
        prop.put("org.quartz.jobStore.lockTimeout", jobStoreLockTimeout);
        prop.put("org.quartz.jobStore.ssl", jobStoreSsl);
        return prop;
    }
    /**
     * 配置JobFactory,为quartz作业添加自动连接支持
     */
    public final class AutowiringSpringBeanJobFactory 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;
        }
    }
}
  • 创建实体

public class TaskInfo implements Serializable {

    private int id = 0;

    /**任务名称*/
    private String jobName;

    /**任务分组*/
    private String jobGroup;

    /**任务描述*/
    private String jobDescription;

    /**任务状态*/
    private String jobStatus;

    /**任务表达式*/
    private String cronExpression;

    private String createTime;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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 getJobDescription() {
        return jobDescription;
    }

    public void setJobDescription(String jobDescription) {
        this.jobDescription = jobDescription;
    }

    public String getJobStatus() {
        return jobStatus;
    }

    public void setJobStatus(String jobStatus) {
        this.jobStatus = jobStatus;
    }

    public String getCronExpression() {
        return cronExpression;
    }

    public void setCronExpression(String cronExpression) {
        this.cronExpression = cronExpression;
    }

    public String getCreateTime() {
        return createTime;
    }

    public void setCreateTime(String createTime) {
        this.createTime = createTime;
    }

    @Override
    public String toString() {
        return "TaskInfo{" +
                "id=" + id +
                ", jobName='" + jobName + '\'' +
                ", jobGroup='" + jobGroup + '\'' +
                ", jobDescription='" + jobDescription + '\'' +
                ", jobStatus='" + jobStatus + '\'' +
                ", cronExpression='" + cronExpression + '\'' +
                ", createTime='" + createTime + '\'' +
                '}';
    }
  • 创建service接口调用
import cn.ce.ebiz.framework.core.context.ContextHolder;
import cn.ce.ebiz.quartz.job.entity.TaskInfo;
import cn.ce.ebiz.quartz.job.util.ResponseCode;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashSet;
import java.util.List;

@RestController
@RequestMapping(value = "quartz")
public class TaskServiceImpl {
    private Logger logger = LoggerFactory.getLogger(TaskServiceImpl.class);

    @Autowired(required = false)
    private Scheduler scheduler;

    /**
     * 所有任务列表
     */
    @RequestMapping(value = "find")
    public String list() {
        List<TaskInfo> list = new ArrayList<>();
        try {
            for (String groupJob : scheduler.getJobGroupNames()) {
                for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher.<JobKey>groupEquals(groupJob))) {
                    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 = "", createTime = "";

                        if (trigger instanceof CronTrigger) {
                            CronTrigger cronTrigger = (CronTrigger) trigger;
                            cronExpression = cronTrigger.getCronExpression();
                            createTime = cronTrigger.getDescription();
                        }
                        TaskInfo info = new TaskInfo();
                        info.setJobName(jobKey.getName());
                        info.setJobGroup(jobKey.getGroup());
                        info.setJobDescription(jobDetail.getDescription());
                        info.setJobStatus(triggerState.name());
                        info.setCronExpression(cronExpression);
                        info.setCreateTime(createTime);
                        list.add(info);
                    }
                }
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
            return ResponseCode.responsebodyErr();
        }

        return ResponseCode.responsebody(list);
    }

    /**
     * 添加定时任务
     *
     * @param info
     */
    @RequestMapping(value = "add")
    @SuppressWarnings("unchecked")
    public String addJob(TaskInfo info) {
        String jobName = info.getJobName(),
                jobGroup = info.getJobGroup(),
                cronExpression = info.getCronExpression(),
                jobDescription = info.getJobDescription(),
                createTime = DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss");
        try {
            if (checkExists(jobName, jobGroup)) {
                logger.info("add job fail, job already exist, jobGroup:{}, jobName:{}", jobGroup, jobName);
                return ResponseCode.responsebodyErr("job already exist");
            }

            TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
            JobKey jobKey = JobKey.jobKey(jobName, jobGroup);

            CronScheduleBuilder schedBuilder = CronScheduleBuilder.cronSchedule(cronExpression).withMisfireHandlingInstructionDoNothing();
            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(triggerKey).withDescription(createTime).withSchedule(schedBuilder).build();


            Class<? extends Job> clazz = (Class<? extends Job>) Class.forName(jobName);
            JobDetail jobDetail = JobBuilder.newJob(clazz).withIdentity(jobKey).withDescription(jobDescription).build();
            scheduler.scheduleJob(jobDetail, trigger);
        } catch (SchedulerException | ClassNotFoundException e) {
            logger.error("类名不存在或执行表达式错误,exception:{}", e.getMessage());
            return ResponseCode.responsebodyErr("类名不存在或执行表达式错误");
        }
        return ResponseCode.responsebody();
    }

    /**
     * 修改定时任务
     *
     * @param info
     */
    @RequestMapping(value = "update")
    public String edit(TaskInfo info) {
        String jobName = info.getJobName(),
                jobGroup = info.getJobGroup(),
                cronExpression = info.getCronExpression(),
                jobDescription = info.getJobDescription(),
                createTime = DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss");
        try {
            if (!checkExists(jobName, jobGroup)) {
                logger.info("edit job fail, job is not exist, jobGroup:{}, jobName:{}", jobGroup, jobName);
                return ResponseCode.responsebodyErr("job is not exist");
            }
            TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
            JobKey jobKey = new JobKey(jobName, jobGroup);
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression).withMisfireHandlingInstructionDoNothing();
            CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity(triggerKey).withDescription(createTime).withSchedule(cronScheduleBuilder).build();

            JobDetail jobDetail = scheduler.getJobDetail(jobKey);
            jobDetail.getJobBuilder().withDescription(jobDescription);
            HashSet<Trigger> triggerSet = new HashSet<>();
            triggerSet.add(cronTrigger);

            scheduler.scheduleJob(jobDetail, triggerSet, true);
        } catch (SchedulerException e) {
            logger.error("类名不存在或执行表达式错误,exception:{}", e.getMessage());
            return ResponseCode.responsebodyErr("类名不存在或执行表达式错误");
        }
        return ResponseCode.responsebody();
    }

    /**
     * 删除定时任务
     *
     * @param jobName
     */
    @RequestMapping(value = "delete")
    public String delete(String jobName, String jobGroup) {
        TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
        try {
            if (!checkExists(jobName, jobGroup)) {
                logger.info("delete job fail, job is not exist, jobGroup:{}, jobName:{}", jobGroup, jobName);
                return ResponseCode.responsebodyErr("job is not exist");
            }
            scheduler.pauseTrigger(triggerKey);
            scheduler.unscheduleJob(triggerKey);
            logger.info("delete job, triggerKey:{},jobGroup:{}, jobName:{}", triggerKey, jobGroup, jobName);
        } catch (SchedulerException e) {
            logger.error(e.getMessage());
            return ResponseCode.responsebodyErr();
        }
        return ResponseCode.responsebody();
    }

    /**
     * 暂停定时任务
     *
     * @param jobName
     */
    @RequestMapping(value = "pause")
    public String pause(String jobName, String jobGroup) {
        TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
        try {
            if (!checkExists(jobName, jobGroup)) {
                logger.info("pause job fail, job is not exist, jobGroup:{}, jobName:{}", jobGroup, jobName);
                return ResponseCode.responsebodyErr("job is not exist");
            }
            scheduler.pauseTrigger(triggerKey);
            logger.info("pause job success, triggerKey:{},jobGroup:{}, jobName:{}", triggerKey, jobGroup, jobName);
        } catch (SchedulerException e) {
            logger.error(e.getMessage());
            return ResponseCode.responsebodyErr();
        }
        return ResponseCode.responsebody();
    }

    /**
     * 重新开始任务
     *
     * @param jobName
     */
    @RequestMapping(value = "resume")
    public String resume(String jobName, String jobGroup) {
        TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);

        try {
            if (!checkExists(jobName, jobGroup)) {
                logger.info("resume job fail, job is not exist, jobGroup:{}, jobName:{}", jobGroup, jobName);
                return ResponseCode.responsebodyErr("job is not exist");
            }
            scheduler.resumeTrigger(triggerKey);
            logger.info("resume job success,triggerKey:{},jobGroup:{}, jobName:{}", triggerKey, jobGroup, jobName);
        } catch (SchedulerException e) {
            logger.error(e.getMessage());
            return ResponseCode.responsebodyErr();
        }
        return ResponseCode.responsebody();
    }

    /**
     * 验证是否存在
     *
     * @param jobName
     * @param jobGroup
     * @throws SchedulerException
     */
    @RequestMapping(value = "checkExists")
    public boolean checkExists(String jobName, String jobGroup) throws SchedulerException {
        TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
        return scheduler.checkExists(triggerKey);
    }
}
  • 创建job
mport org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

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

public class ScheduledJobDemoOne implements Job {


    private SimpleDateFormat dateFormat() {
        return new SimpleDateFormat("HH:mm:ss");
    }

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("ScheduledJobDemoOne-----,quartz ScheduledJobOne Tasks: " + dateFormat().format(new Date()));
    }
}

测试

90后小鲜肉
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
quartz-redis-jobstore:使用Redis的Quartz Scheduler JobStore
05-13
石英-redis-jobstore 使用 JobStore。 该项目的灵感来自 ，并提供了相似的功能，但有一些主要区别： Redis数据库和密钥前缀是可配置的。 使用Redis。 该库涵盖了该库的所有功能。 要求 Java 7或更高版本 Redis 2.6.12或更高版本（Redis群集为3.0或更高版本） 安装 Maven依赖项： < dependency> < groupId>net.joelinn</ groupId> < artifactId>quartz-redis-jobstore</ artifactId> < version>1.2.0</ version> </ dependency> 配置 在quartz.properties文件中可以设置以下属性： # set the scheduler's JobStore cla
spring boot + quartz 动态管理 分布式
08-29
动态管理了定时任务的添加、修改、删除等操作，可扩展性强
Quartz + SpringBoot 实现分布式定时任务
最新发布
weixin_44111939的博客
04-12 990
Quartz + SpringBoot 实现分布式定时任务
SpringBoot集成Quartz分布式定时任务
11-01
SpringBoot集成Quartz完全分布式定时任务，即插即用，不好用直接捶我！ SpringBoot集成Quartz分布式定时任务 SpringBoot集成Quartz分布式定时任务
基于Spring Boot + Quartz 的分布式任务调度系统.zip
03-22
项目基于 jdk1.8 采用 Spring Boot 框架 集成了分布式任务调度框架 Quartz ，任务存储于数据库。 使用SpringMVC作为路由控制, 集成 Swagger2 提供实时 RESTful API文档。 数据持久层集成 Mybatis 框架。 使用自定义注解 @TargetDataSource 实现了多数据源动态切换，支持数据库读写分离。 HTTP JOB 接口调用使用 OkHttp3 替代了 HttpClient 。 Thrift JOB 接口调用实现了 Thrift client 池化管理。 集成了 Spring data redis，提供缓存服务。
使用Spring Boot + Quartz 实现分布式定时任务平台
HongYu012的博客
03-23 4248
本文将从项目实战出发来介绍分布式定时任务的实现。在某些应用场景下要求任务必须具备高可用性和可扩展性，单台服务器不能满足业务需求，这时就需要使用Quartz实现分布式定时任务。 一、分布式任务应用场景 定时任务系统在应用平台中的重要性不言而喻，特别是互联网电商、金融等行业更是离不开定时任务。在任务数量不多、执行频率不高时，单台服务器完全能够满足。 但是随着业务逐渐增加，定时任务系统必须具备高可用和水平扩展的能力，单台服务器已经不能满足需求。因此需要把定时任务系统部署到集群中，实现分布式定时任务系统集群。
springboot集成quartz 和redis做分布式锁
wlyang666的博客
11-07 2291
前段时间接了一个需求是抽离老系统中的批量任务，单独搭建一个项目实现批量任务的管理运行。 主要支持如下功能： 手动重启，关闭任务 支持水平扩展 老系统的希尔脚本管理执行 针对特定参数配置运行特定的批量任务，比如查询一段时间的数据库数据之类 选型方面： quartz是比较成熟的调度框架，经历市场的考验，加上以前用过，比较熟悉相关api,所以调度程序选择quartz 因为涉及到水平扩展，不能只保证...
springboot+Quartz实现任务调度的示例代码
08-28
SpringBoot + Quartz 实现任务调度的示例代码 本文主要介绍如何使用 SpringBoot 和 Quartz 实现任务调度的示例代码。Quartz 是一个功能强大且灵活的开源任务调度框架，广泛应用于各类 Java 项目中。下面将详细介绍...
springboot+quartz定时任务实现 纯代码
03-30
最新springboot+Quartz实现动态定时任务,源代码. 包括controller,service,impl,和配置文件,pom文件,实体类,直接导入springboot项目,配置好数据库就能使用.欢迎下载好评!
springboot+quartz实现动态定时任务调度
12-08
基于SpringBoot+Quartz实现动态任务调度，可作为单独模块镶嵌到项目中，同时还支持多数据源配置。项目运行中就可实现定时任务的动态增删改查，不用启停项目，摆脱了普通SpringBoot定时任务注解，需要重启才能生效...
springboot+quartz +mysql 核心代码
03-07
在Spring Boot中，我们可以通过Spring Job和Quartz的集成，实现对Quartz的控制，包括任务的创建、启动、停止和删除。 MySQL则是一个广泛使用的开源关系型数据库，适用于处理大量数据和高并发场景。在Spring Boot...
springboot+quartz 动态化配置定时任务
07-25
springboot+quartz 动态化配置，可在页面操作，查看、添加、修改、删除，暂停等操作
封装quartz任务调度，集成groovy，实现在线任务编辑系统
03-26
JobUtil.createJob(String jobName,String triggerName,String runTime) 封装创建任务的工具，第一个参数任务名称（唯一），第二个参数触发器名称（唯一），最后一个参数是任务运行时间，参考quartz写法。
SpringBoot集成Redis，Webservice，kafka，quartz，mybatis例子
08-22
最近学习springboot吧自己工作中需要用到的工具都做了集成例子。其中包括mybatis，cfx的webservice，定时器quartz，消息队列kafka以及redis其中redis包含了三种连接方式（单机模式，集群cluster，哨兵模式），给大家做一个参考 希望能让别人学习时少走弯路
该例子基于实际生产环境搭建，集成 springboot，zk，quartz，redis，mq插件--readme中有详细的启动步骤
08-11
基于实际项目搭建的开发环境，根据readme中能正常使用，如有问题欢迎指正
springboot+quartz以持久化的方式实现定时任务的代码
08-18
SpringBoot+Quartz实现定时任务的代码 本篇文章主要介绍了使用SpringBoot和Quartz实现定时任务的相关知识，并通过实例代码详细地介绍了相关实现方式。 Quartz简介 Quartz是一个开源的任务调度框架，提供了强大的...
Spring boot + Quartz实现分布式定时任务
即心即佛
08-29 5388
在实际项目中经常会用到定时任务，且有些定时任务同时只能运行一个实例，下面介绍一下通过Spring boot + Quartz框架实现分布式定时任务。 1. 定时任务持久化到Mysql 2. 名称为JobA的定时任务每10秒执行一次@ScheduledJob(name = “JobA”, cronExp = “/10 * * * ?”) 3. @DisallowConcurrentEx...
SpringBoot+Quartz实现多个定时任务
Rolandcoder的博客
09-14 8867
通过Timer和Spring的scheduler实现定时任务可能会出现一旦定时任务中断后续的定时任务无法正常执行的问题，Quartz能够很好的解决这一问题。 项目使用Maven管理，因此在使用之前需要在pom文件中添加依赖，如下：     &lt;dependency&gt;       &lt;groupId&gt;org.quartz-scheduler&lt;/groupId&gt;  ...
Quartz在分布式集群环境下的应用（Spring、SpringBoot）
谦虚使人发胖的博客
04-08 3317
如果仅仅只是使用定时任务，可以使用Spring的schedule实现，方便,代码量少，只需引入必要依赖及一个简单的注解即可，类似 @Scheduled(cron = "0 0 1 * * ?") public void schedule1 () { logger.info("=== 定时任务1 ===") } ...
springboot+vue+quartz 实现动态定时任务调度
05-22
动态定时任务调度可以使用Spring Boot、Vue和Quartz来实现。下面是一个基本的实现步骤： 1. 在Spring Boot中配置Quartz 在pom.xml文件中添加Quartz依赖： ```xml <groupId>org.quartz-scheduler <artifactId>...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值