quartz任务调度

最新推荐文章于 2024-07-30 07:15:00 发布
最新推荐文章于 2024-07-30 07:15:00 发布
阅读量993 收藏 1
点赞数
分类专栏： quartz 文章标签： quartz
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010024991/article/details/53261240
版权

1、定义一个工厂：

public class QuartzJobFactory implements Job {
    public final Logger log = Logger.getLogger(this.getClass());

    public void execute(JobExecutionContext context) throws JobExecutionException {
        ScheduleJobModel scheduleJob = (ScheduleJobModel) context.getMergedJobDataMap().get(QuartzUtil.SCHEDULE_JOB_CONTEXT);
        TaskUtils.invokMethod(scheduleJob);
    }
}

2、有状态任务执行

@DisallowConcurrentExecution
public class QuartzJobFactoryDisallowConcurrentExecution implements Job {
    public final Logger log = Logger.getLogger(this.getClass());

    public void execute(JobExecutionContext context) throws JobExecutionException {
        ScheduleJobModel scheduleJob = (ScheduleJobModel) context.getMergedJobDataMap().get(QuartzUtil.SCHEDULE_JOB_CONTEXT);
        TaskUtils.invokMethod(scheduleJob);
    }
}

3、任务处理

public class QuartzManager {
    /**
     * 添加任务
     * 
     * @param scheduleJob
     * @throws SchedulerException
     */
    private  Scheduler scheduler;

    public Scheduler getScheduler() {
        return scheduler;
    }
    public void setScheduler(Scheduler scheduler) {
        this.scheduler = scheduler;
    }

    public  String SCHEDULE_JOB_CONTEXT="scheduleJob";
    public  void addJob(ScheduleJobModel job) throws SchedulerException {
        if (job == null || !BaseContext.STATUS_RUNNING.equals(job.getJobStatus())) {
            return;
        }

        TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName(), job.getJobGroup());

        CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

        // 不存在，创建一个
        if (null == trigger) {
            Class clazz = BaseContext.CONCURRENT_IS.equals(job.getIsConcurrent()) ? QuartzJobFactory.class : QuartzJobFactoryDisallowConcurrentExecution.class;

            JobDetail jobDetail = JobBuilder.newJob(clazz).withIdentity(job.getJobName(), job.getJobGroup()).build();

            jobDetail.getJobDataMap().put(SCHEDULE_JOB_CONTEXT, job);

            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());

            trigger = TriggerBuilder.newTrigger().withIdentity(job.getJobName(), job.getJobGroup()).withSchedule(scheduleBuilder).build();

            scheduler.scheduleJob(jobDetail, trigger);
        } else {
            // Trigger已存在，那么更新相应的定时设置
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());

            // 按新的cronExpression表达式重新构建trigger
            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();

            // 按新的trigger重新设置job执行
            scheduler.rescheduleJob(triggerKey, trigger);
        }
    }
      /**
       * 
       * @return
       * @throws SchedulerException
       */
        public  List<ScheduleJobModel> getAllJob() throws SchedulerException {
            GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
            Set<JobKey> jobKeys = scheduler.getJobKeys(matcher);
            List<ScheduleJobModel> jobList = new ArrayList<ScheduleJobModel>();
            for (JobKey jobKey : jobKeys) {
                List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
                for (Trigger trigger : triggers) {
                    ScheduleJobModel job = new ScheduleJobModel();
                    job.setJobName(jobKey.getName());
                    job.setJobGroup(jobKey.getGroup());
                    job.setDescription("触发器:" + trigger.getKey());
                    Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                    job.setJobStatus(triggerState.name());
                    if (trigger instanceof CronTrigger) {
                        CronTrigger cronTrigger = (CronTrigger) trigger;
                        String cronExpression = cronTrigger.getCronExpression();
                        job.setCronExpression(cronExpression);
                    }
                    jobList.add(job);
                }
            }
            return jobList;
        }

        /**
         * 所有正在运行的job
         * 
         * @return
         * @throws SchedulerException
         */
        public  List<ScheduleJobModel> getRunningJob() throws SchedulerException {
            List<JobExecutionContext> executingJobs = scheduler.getCurrentlyExecutingJobs();
            List<ScheduleJobModel> jobList = new ArrayList<ScheduleJobModel>(executingJobs.size());
            for (JobExecutionContext executingJob : executingJobs) {
                ScheduleJobModel job = new ScheduleJobModel();
                JobDetail jobDetail = executingJob.getJobDetail();
                JobKey jobKey = jobDetail.getKey();
                Trigger trigger = executingJob.getTrigger();
                job.setJobName(jobKey.getName());
                job.setJobGroup(jobKey.getGroup());
                job.setDescription("触发器:" + trigger.getKey());
                Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                job.setJobStatus(triggerState.name());
                if (trigger instanceof CronTrigger) {
                    CronTrigger cronTrigger = (CronTrigger) trigger;
                    String cronExpression = cronTrigger.getCronExpression();
                    job.setCronExpression(cronExpression);
                }
                jobList.add(job);
            }
            return jobList;
        }

        /**
         * 暂停一个job
         * 
         * @param scheduleJob
         * @throws SchedulerException
         */
        public  void pauseJob(ScheduleJobModel scheduleJob) throws SchedulerException {
            JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
            scheduler.pauseJob(jobKey);
        }

        /**
         * 恢复一个job
         * 
         * @param scheduleJob
         * @throws SchedulerException
         */
        public  void resumeJob(ScheduleJobModel scheduleJob) throws SchedulerException {
            JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
            scheduler.resumeJob(jobKey);
        }

        /**
         * 删除一个job
         * 
         * @param scheduleJob
         * @throws SchedulerException
         */
        public  void deleteJob(ScheduleJobModel scheduleJob) throws SchedulerException {
            JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
            scheduler.deleteJob(jobKey);
        }

        /**
         * 立即执行job
         * 
         * @param scheduleJob
         * @throws SchedulerException
         */
        public  void runAJobNow(ScheduleJobModel scheduleJob) throws SchedulerException {
            JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
            scheduler.triggerJob(jobKey);
        }

        /**
         * 更新job时间表达式
         * 
         * @param scheduleJob
         * @throws SchedulerException
         */
        public  void updateJobCron(ScheduleJobModel scheduleJob) throws SchedulerException {
            TriggerKey triggerKey = TriggerKey.triggerKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression());
            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
            scheduler.rescheduleJob(triggerKey, trigger);
        }
}

4、工具

public class QuartzUtil {
    /**
     * 添加任务
     * 
     * @param scheduleJob
     * @throws SchedulerException
     */
    public static Scheduler scheduler;
    public static String SCHEDULE_JOB_CONTEXT="scheduleJob";
    public static void addJob(ScheduleJobModel job) throws SchedulerException {
        if (job == null || !BaseContext.STATUS_RUNNING.equals(job.getJobStatus())) {
            return;
        }

        TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName(), job.getJobGroup());

        CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

        // 不存在，创建一个
        if (null == trigger) {
            Class clazz = BaseContext.CONCURRENT_IS.equals(job.getIsConcurrent()) ? QuartzJobFactory.class : QuartzJobFactoryDisallowConcurrentExecution.class;

            JobDetail jobDetail = JobBuilder.newJob(clazz).withIdentity(job.getJobName(), job.getJobGroup()).build();

            jobDetail.getJobDataMap().put(SCHEDULE_JOB_CONTEXT, job);

            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());

            trigger = TriggerBuilder.newTrigger().withIdentity(job.getJobName(), job.getJobGroup()).withSchedule(scheduleBuilder).build();

            scheduler.scheduleJob(jobDetail, trigger);
        } else {
            // Trigger已存在，那么更新相应的定时设置
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());

            // 按新的cronExpression表达式重新构建trigger
            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();

            // 按新的trigger重新设置job执行
            scheduler.rescheduleJob(triggerKey, trigger);
        }
    }
      /**
       * 
       * @return
       * @throws SchedulerException
       */
        public static List<ScheduleJobModel> getAllJob() throws SchedulerException {
            GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
            Set<JobKey> jobKeys = scheduler.getJobKeys(matcher);
            List<ScheduleJobModel> jobList = new ArrayList<ScheduleJobModel>();
            for (JobKey jobKey : jobKeys) {
                List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
                for (Trigger trigger : triggers) {
                    ScheduleJobModel job = new ScheduleJobModel();
                    job.setJobName(jobKey.getName());
                    job.setJobGroup(jobKey.getGroup());
                    job.setDescription("触发器:" + trigger.getKey());
                    Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                    job.setJobStatus(triggerState.name());
                    if (trigger instanceof CronTrigger) {
                        CronTrigger cronTrigger = (CronTrigger) trigger;
                        String cronExpression = cronTrigger.getCronExpression();
                        job.setCronExpression(cronExpression);
                    }
                    jobList.add(job);
                }
            }
            return jobList;
        }

        /**
         * 所有正在运行的job
         * 
         * @return
         * @throws SchedulerException
         */
        public static List<ScheduleJobModel> getRunningJob() throws SchedulerException {
            List<JobExecutionContext> executingJobs = scheduler.getCurrentlyExecutingJobs();
            List<ScheduleJobModel> jobList = new ArrayList<ScheduleJobModel>(executingJobs.size());
            for (JobExecutionContext executingJob : executingJobs) {
                ScheduleJobModel job = new ScheduleJobModel();
                JobDetail jobDetail = executingJob.getJobDetail();
                JobKey jobKey = jobDetail.getKey();
                Trigger trigger = executingJob.getTrigger();
                job.setJobName(jobKey.getName());
                job.setJobGroup(jobKey.getGroup());
                job.setDescription("触发器:" + trigger.getKey());
                Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                job.setJobStatus(triggerState.name());
                if (trigger instanceof CronTrigger) {
                    CronTrigger cronTrigger = (CronTrigger) trigger;
                    String cronExpression = cronTrigger.getCronExpression();
                    job.setCronExpression(cronExpression);
                }
                jobList.add(job);
            }
            return jobList;
        }

        /**
         * 暂停一个job
         * 
         * @param scheduleJob
         * @throws SchedulerException
         */
        public static void pauseJob(ScheduleJobModel scheduleJob) throws SchedulerException {
            JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
            scheduler.pauseJob(jobKey);
        }

        /**
         * 恢复一个job
         * 
         * @param scheduleJob
         * @throws SchedulerException
         */
        public static void resumeJob(ScheduleJobModel scheduleJob) throws SchedulerException {
            JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
            scheduler.resumeJob(jobKey);
        }

        /**
         * 删除一个job
         * 
         * @param scheduleJob
         * @throws SchedulerException
         */
        public static void deleteJob(ScheduleJobModel scheduleJob) throws SchedulerException {
            JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
            scheduler.deleteJob(jobKey);
        }

        /**
         * 立即执行job
         * 
         * @param scheduleJob
         * @throws SchedulerException
         */
        public static void runAJobNow(ScheduleJobModel scheduleJob) throws SchedulerException {
            JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
            scheduler.triggerJob(jobKey);
        }

        /**
         * 更新job时间表达式
         * 
         * @param scheduleJob
         * @throws SchedulerException
         */
        public static void updateJobCron(ScheduleJobModel scheduleJob) throws SchedulerException {
            TriggerKey triggerKey = TriggerKey.triggerKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression());
            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
            scheduler.rescheduleJob(triggerKey, trigger);
        }
}

5、计划任务信息

public class ScheduleJobModel  {

    private Integer jobId;

    private Date createTime;

    private Date updateTime;
    /**
     * 任务名称
     */
    private String jobName;
    /**
     * 任务分组
     */
    private String jobGroup;
    /**
     * 任务状态 是否启动任务
     */
    private String jobStatus;
    /**
     * cron表达式
     */
    private String cronExpression;
    /**
     * 描述
     */
    private String description;
    /**
     * 任务执行时调用哪个类的方法 包名+类名
     */
    private String beanClass;
    /**
     * 任务是否有状态
     */
    private String isConcurrent;
    /**
     * spring bean
     */
    private String springId;
    /**
     * 任务调用的方法名
     */
    private String methodName;

    /**
     * 最后一次执行状态
     */
    private String lastStatus;

    /**
     * 最后一次执行状态
     */
    private Date lastTime;


    public Integer getJobId() {
        return jobId;
    }
    public void setJobId(Integer jobId) {
        this.jobId = jobId;
    }
    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 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 getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
    public String getBeanClass() {
        return beanClass;
    }
    public void setBeanClass(String beanClass) {
        this.beanClass = beanClass;
    }
    public String getIsConcurrent() {
        return isConcurrent;
    }
    public void setIsConcurrent(String isConcurrent) {
        this.isConcurrent = isConcurrent;
    }
    public String getSpringId() {
        return springId;
    }
    public void setSpringId(String springId) {
        this.springId = springId;
    }
    public String getMethodName() {
        return methodName;
    }
    public void setMethodName(String methodName) {
        this.methodName = methodName;
    }
    public String getLastStatus() {
        return lastStatus;
    }
    public void setLastStatus(String lastStatus) {
        this.lastStatus = lastStatus;
    }
    public Date getLastTime() {
        return lastTime;
    }
    public void setLastTime(Date lastTime) {
        this.lastTime = lastTime;
    }
    public Date getCreateTime() {
        return createTime;
    }
    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }
    public Date getUpdateTime() {
        return updateTime;
    }
    public void setUpdateTime(Date updateTime) {
        this.updateTime = updateTime;
    }
}

6、通过反射调用scheduleJob中定义的方法

public class TaskUtils {
    public final static Logger log = Logger.getLogger(TaskUtils.class);

    /**
     * 通过反射调用scheduleJob中定义的方法
     * 
     * @param scheduleJob
     */
    public static boolean invokMethod(ScheduleJobModel scheduleJob) {
        Object object = null;
        Class clazz = null;
        if (StringUtils.isNotBlank(scheduleJob.getSpringId())) {
            object = SpringUtil.getBean(scheduleJob.getSpringId());
        } else if (StringUtils.isNotBlank(scheduleJob.getBeanClass())) {
            try {
                clazz = Class.forName(scheduleJob.getBeanClass());
                object = clazz.newInstance();
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }

        }
        if (object == null) {
            log.error("任务名称 = [" + scheduleJob.getJobName() + "]---------------未启动成功，请检查是否配置正确！！！");
            return false;
        }
        clazz = object.getClass();
        Method method = null;
        try {
            method = clazz.getDeclaredMethod(scheduleJob.getMethodName());
        } catch (NoSuchMethodException e) {

            log.error("任务名称 = [" + scheduleJob.getJobName() + "]---------------未启动成功，方法名设置错误！！！");
            return false;
        } catch (SecurityException e) {
            e.printStackTrace();
            return false;
        }
        if (method != null) {
            try {
                method.invoke(object);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
                log.error("任务名称 = [" + scheduleJob.getJobName() + "]--------------执行失败！！！");
                return false;
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
                log.error("任务名称 = [" + scheduleJob.getJobName() + "]---------------执行失败！！！");
                return false;
            } catch (InvocationTargetException e) {
                e.printStackTrace();
                log.error("任务名称 = [" + scheduleJob.getJobName() + "]---------------执行失败！！！");
                return false;
            }
        }
        return true;
    }
}
AlexWong2526
关注
专栏目录
quartz(三)工厂类总结
swimming_lu的博客
11-12 688
本篇文章中将会对quartz常用的factory进行总结 SchedulerFactory接口为调度器工厂接口 SchedulerFactory中主要方法介绍 getScheduler()获取一个可用的调度器 getScheduler(String schedName)通过调度器名字得到调度器 JobFactory接口负责生成Job的具体实例，如果我们需要Job实例支持bean注入那么我们需要...
Quartz任务调度
zl5186888的博客
09-14 480
文章目录 Java定时任务 数据结构–堆 堆 插入元素 删除堆顶元素 Quartz任务调度 一、Quartz概念 二、Quartz运行环境 三、Quartz设计模式 四、Quartz学习的核心概念 五、Quartz的体系结构 六、Quartz的几个常用API 七、Quartz使用 1.入门案例 2.Job和JobDetail介绍 3.JobExecutionContext介绍 4.JobDataMap介绍 5.有状态的Job和无状态的Job 6.Trigger介绍 7.SimpleTrigger触发器 8.
Java中的定时任务调度：Quartz详解
最新发布
聚娃科技开发者博客
07-30 1184
本文将深入探讨Quartz的基本概念、配置方法和实际应用示例，帮助你更好地利用Quartz进行定时任务调度。Quartz是一个功能强大的定时任务调度库，通过灵活的配置和编程接口，可以满足各种定时任务的需求。通过本文的示例和配置指南，你可以快速上手使用Quartz进行定时任务调度，实现高效的任务管理和调度。Quartz支持将任务的状态持久化到数据库，以便在应用重启后恢复任务状态。Quartz是一个开源的任务调度库，它允许开发者通过配置或编程方式定义、调度和管理任务。，以便Quartz能够连接到数据库。
Quartz schedulerContextAsMap 和jobDataMap
小白鼠丶
01-19 995
1.schedulerContextAsMap 配置文件 beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:task="http://www.springframework.org
quartz 定制 jobFactory，在quartz.config中配置
Henry_Wu001的专栏
11-01 3895
refs: https://jayvilalta.com/blog/2012/07/17/configuring-quartz-net-to-use-a-custom-job-factory/ rt: 在quartz.config中配置 jobFactory,会替换掉默认的SimpleJobFactory quartz.scheduler.jobFactory.type
quartz自动作业使用
03-28
NULL 博文链接：https://howdy-world.iteye.com/blog/1235427
C#基于Quartz任务调度系统
01-15
**C#基于Quartz任务调度系统** 在软件开发中，任务调度是一项重要的功能，它允许开发者安排任务在特定时间执行，比如数据同步、定时备份、报告生成等。Quartz是一款强大的开源任务调度库，广泛应用于Java和.NET生态...
.net Quartz 任务调度平台源码
10-10
《.NET Quartz 任务调度平台源码解析与应用》 .NET Quartz 是一款强大的任务调度框架，它为.NET开发者提供了一种高效、灵活的方式来安排和执行周期性任务。Quartz.NET 是开源项目Quartz的.NET版本，它允许开发人员...
Quartz 任务调度
08-08
总的来说，Quartz 是一个强大的任务调度工具，提供灵活的时间调度和故障恢复机制。通过深入学习和实践，我们可以充分利用它来提升应用的自动化水平，提高工作效率。在案例中，你可以找到关于如何使用 Quartz 的具体...
Quartz定时任务框架(一)：概述和Job、JobDetail详解
qq_42682745的博客
04-27 4994
详解quartz定时任务框架，死磕
Quartz定时任务
记录一些小的知识点
10-07 243
config包下面的三个类 /** * JobFactory 类 */ import org.quartz.spi.TriggerFiredBundle; import org.springframework.beans.factory.config.AutowireCapableBeanFactory; import org.springframework.scheduling.quartz...
@DisallowConcurrentExecution 注解
winwinwin99的博客
05-18 4167
Quartz定时任务默认都是并发执行的，不会等待上一次任务执行完毕，只要间隔时间到就会执行, 如果定时任执行太长，会长时间占用资源，导致其它任务堵塞。 在Spring中这时需要设置concurrent的值为false, 禁止并发执行。 <property name="concurrent" value="true" /> 当不使用spring的时候就需要在Job的实现类上加@DisallowConcurrentExecution的注释 @DisallowConcurrentExecu.
quartz spring 实现动态定时任务
CHBSRZF的博客
02-15 2183
在实际项目应用中经常会用到定时任务，可以通过quartz和spring的简单配置即可完成，但如果要改变任务的执行时间、频率，废弃任务等就需要改变配置甚至代码需要重启服务器，这里介绍一下如何通过quartz与spring的组合实现动态的改变定时任务的状态的一个实现。 参考文章：http://www.meiriyouke.net/?p=82 本文章适合对quartz和spring有一定了解
SpringBoot——整合 Quartz 定时框架
时光·漫步的博客
08-01 359
Quartz 的使用思路 job - 任务 - 你要做什么事？ Trigger - 触发器 - 你什么时候去做？ Scheduler - 任务调度 - 你什么时候需要去做什么事？ 1.修改 pom 文件添加坐标 <!-- Quartz 坐标 --> <dependency> <groupId>org.quartz-scheduler</gro...
Quartz与Spring的整合-Quartz中的job如何自动注入spring容器托管的对象
hello_junz的专栏
08-13 575
原文请参考  http://www.tuicool.com/articles/Qjyamu Quartz与Spring的整合-Quartz中的job如何自动注入spring容器托管的对象 - 大新博客 时间 2014-03-18 18:01:00 博客园-所有随笔区 原文  http://www.cnblogs.com/daxin/p/3608320.html
springboot整合quartz实现定时任务
weixin_44740673的博客
04-30 304
一.引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-quartz</artifactId> </dependency> &lt...
Springboot整合Quartz定时任务框架（Spring解决方案）
Ricardo.M.Yu的博客
04-17 4020
spring提供的quartz解决发难
Springboot Quartz定时任务的动态调度使用，实战详解
2303_77877769的博客
04-17 1113
针对最近很多人都在面试，我这边也整理了相当多的面试专题资料，也有其他大厂的面经。希望可以帮助到大家。下面的面试题答案都整理成文档笔记。也还整理了一些面试资料&最新2021收集的一些大厂的面试真题（都整理成文档，小部分截图）最新整理电子书《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！定时任务，模拟多定时任务调度处理不同业务：/****/
Quartz任务调度框架详解
"Quartz任务调度" Quartz任务调度是Java开发中广泛使用的开源任务调度框架，它为应用程序提供了灵活且强大的定时任务管理能力。Quartz自2001年以来，因其易于使用和功能全面的特点，已被众多项目采纳为任务调度的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值