quartz动态设置cron

莫翊痕

已于 2022-04-19 09:58:18 修改

阅读量1.7k

点赞数 1

CC 4.0 BY-SA版权

分类专栏： java 文章标签： spring java 后端

于 2022-04-08 15:31:09 首次发布

本文链接：https://blog.csdn.net/qq_35193677/article/details/124041912

java 专栏收录该内容

8 篇文章

订阅专栏

这篇博客介绍了如何使用Quartz框架在Java中创建和修改cron表达式来实现定时任务。示例代码展示了一个名为SignInJob的测试任务类，该类会根据计数器动态调整执行频率，从每5秒变为每10秒执行一次。同时，还提供了QuartzManager类用于管理任务的启动、停止以及修改定时配置。测试结果显示了任务按预期更改cron表达式并按新频率执行。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

学习quartz cron表达式定时任务笔记,主要是想实现特定日期时间点执行定时任务.

1.测试任务类

package com.example.demo330.signin;

import com.example.demo330.utils.QuartzManager;
import org.quartz.*;
import org.quartz.impl.JobDetailImpl;

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

public class SignInJob implements Job {
    static int count = 0;
    static String cron = "0/5 * * * * ? *";

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        JobDetailImpl jdi = (JobDetailImpl) jobExecutionContext.getJobDetail();

        JobKey jk = jdi.getKey();

        String jobName = jk.getName();
        String jobGroup = jk.getGroup();
        Trigger trigger = jobExecutionContext.getTrigger();
        TriggerKey key = trigger.getKey();
        String name = key.getName();
        String group = key.getGroup();
 		JobDataMap jobDataMap = jdi.getJobDataMap();
 		
        count = count + 1;
        //测试更改下cron表达式 
        if (count > 5) {
            cron = "0/10 * * * * ? *";
            if (count > 10)
                count = 0;
        } else {
            cron = "0/5 * * * * ? *";
        }

        String printTime = new SimpleDateFormat("yy-MM-dd HH-mm-ss").format(new Date());
        System.out.println("SignInJob start at:" + printTime + "--jobName:" + jobName + "--jobGroup:" + jobGroup +
                "--triggerName:" + name + "--triggerGroup:" + group + "--count:" + count +"--cron:"+cron);

        QuartzManager.modifyJobTime(key, cron, jk, jobDataMap);
    }
}

2.Quartz管理类添加启动修改停止

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

import java.util.Date;

public class QuartzManager {

    public static StdSchedulerFactory sf = new StdSchedulerFactory();

    /**
     * 添加cronTrigger的定时器
     *
     * @param jobKey     .
     * @param triggerKey .
     * @param jobClass   .
     * @param cro        .
     * @param jobDataMap .
     */
    public static void addJob(JobKey jobKey,
                              TriggerKey triggerKey,
                              Class<? extends Job> jobClass,
                              String cro,
                              JobDataMap jobDataMap) {

        try {
            // 任务名，任务组，任务执行类;可以将自己需要的额外信息添加到jobdatamap中。
            JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobKey).setJobData(jobDataMap).build();
            //触发器
            TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
            //触发器名 触发器组
            triggerBuilder.withIdentity(triggerKey);
            //现在执行
            //triggerBuilder.startNow();
            //触发器规则
            triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cro).withMisfireHandlingInstructionDoNothing());
            //创建CronTrigger对象
            CronTrigger trigger = (CronTrigger) triggerBuilder.build();
            //创建调度器
            Scheduler scheduler = sf.getScheduler();
            //调度器设置jobDetail,trigger
            scheduler.scheduleJob(jobDetail, trigger);
            if (!scheduler.isShutdown())
                scheduler.start();

        } catch (Exception e) {
            //e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 修改cronTrigger定时器
     *
     * @param triggerKey .
     * @param cron       .
     * @param jonKey     .
     * @param jobDataMap
     * withMisfireHandlingInstructionDoNothing
     * ——不触发立即执行
     * ——等待下次Cron触发频率到达时刻开始按照Cron频率依次执行
     *
     * withMisfireHandlingInstructionIgnoreMisfires
     * ——以错过的第一个频率时间立刻开始执行
     * ——重做错过的所有频率周期后
     * ——当下一次触发频率发生时间大于当前时间后，再按照正常的Cron频率依次执行
     *
     * withMisfireHandlingInstructionFireAndProceed
     * ——以当前时间为触发频率立刻触发一次执行
     * ——然后按照Cron频率依次执行
     */
    public static void modifyJobTime(TriggerKey triggerKey, String cron, JobKey jonKey, JobDataMap jobDataMap) {
        try {
            Scheduler scheduler = sf.getScheduler();
            //TriggerKey triggerKey1 = TriggerKey.triggerKey(triggerKey.getName(), triggerKey.getGroup());
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            if (trigger == null)
                return;
            String oldTime = trigger.getCronExpression();
            if (!oldTime.equalsIgnoreCase(cron)) {

                /**调用 rescheduleJob 开始 */
                TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();// 触发器
                triggerBuilder.withIdentity(triggerKey);// 触发器名,触发器组

                //triggerBuilder.startNow();// 立即执行
                triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron).withMisfireHandlingInstructionDoNothing());// 触发器时间设定
                trigger = (CronTrigger) triggerBuilder
                        .startAt(new Date())
                        .build();// 创建Trigger对象
                scheduler.rescheduleJob(triggerKey, trigger);// 修改一个任务的触发时间
            } else {
                System.out.println("--------------------------------------------------------------------cron相同 不处理");
            }
        } catch (SchedulerException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 启动所有任务
     */
    public static void startJobs() {
        try {
            sf.getScheduler().start();
        } catch (SchedulerException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 关闭所有定时任务
     */
    public static void shutdownJobs() {
        try {
            if (!sf.getScheduler().isShutdown())
                sf.getScheduler().shutdown();
        } catch (SchedulerException e) {
            //e.printStackTrace();
            throw new RuntimeException(e);
        }
    }


    public static void removeJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName) {

        try {

            Scheduler sched = sf.getScheduler();


            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);


            sched.pauseTrigger(triggerKey);

            sched.unscheduleJob(triggerKey);

            boolean b = sched.deleteJob(JobKey.jobKey(jobName, jobGroupName));
            System.out.println("删除结果:"+b+"--jobName:"+jobName+"--triggerName:"+triggerName);
        } catch (Exception e) {

            throw new RuntimeException(e);

        }

    }


}

3.开启定时任务

		/*Cron表达式有7段构成，分为秒，分钟，小时时，日，月份，星期，年
              *（星号）是通配符，表示每秒，每分钟，每小时，每日等
              ,（逗号）可以列举执行的时间，比如 1,2,3 * * * * ? * 表示每分钟的1秒，2秒和3秒时执行一次
              -（横杆）表示范围，0 1-3 * * * ? * 表示每小时的1分钟到3分钟，每分钟执行一次
              /（斜杆）表示增量，0 0/5 10 * * ? * 表示每天的10点到10点55分，每5分钟执行一次*/
              
		JobDataMap dataMap1 = new JobDataMap();
        dataMap1.put("类型1", "one");
        dataMap1.put("类型2", "two");

        JobKey jobKey = new JobKey("cron任务1", "任务组名1");
        TriggerKey triggerKey = new TriggerKey("cron触发器1", "cron触发器组名1");
        QuartzManager.addJob(jobKey,triggerKey,SignInJob.class,"0/5 * * * * ? *",dataMap1);
		//开启定时任务
        QuartzManager.startJobs();

测试job执行中修改cron 定时配置. 5秒改为10秒执行一次.

SignInJob start at:22-04-08 14-46-20--jobName:cron任务1--jobGroup:任务组名1--triggerName:cron触发器1--triggerGroup:cron触发器组名1--count:1--cron:0/5 * * * * ? *
SignInJob start at:22-04-08 14-46-25--jobName:cron任务1--jobGroup:任务组名1--triggerName:cron触发器1--triggerGroup:cron触发器组名1--count:2--cron:0/5 * * * * ? *
SignInJob start at:22-04-08 14-46-30--jobName:cron任务1--jobGroup:任务组名1--triggerName:cron触发器1--triggerGroup:cron触发器组名1--count:3--cron:0/5 * * * * ? *
SignInJob start at:22-04-08 14-46-35--jobName:cron任务1--jobGroup:任务组名1--triggerName:cron触发器1--triggerGroup:cron触发器组名1--count:4--cron:0/5 * * * * ? *
SignInJob start at:22-04-08 14-46-40--jobName:cron任务1--jobGroup:任务组名1--triggerName:cron触发器1--triggerGroup:cron触发器组名1--count:5--cron:0/5 * * * * ? *
SignInJob start at:22-04-08 14-46-45--jobName:cron任务1--jobGroup:任务组名1--triggerName:cron触发器1--triggerGroup:cron触发器组名1--count:6--cron:0/10 * * * * ? *
SignInJob start at:22-04-08 14-46-50--jobName:cron任务1--jobGroup:任务组名1--triggerName:cron触发器1--triggerGroup:cron触发器组名1--count:7--cron:0/10 * * * * ? *
SignInJob start at:22-04-08 14-47-00--jobName:cron任务1--jobGroup:任务组名1--triggerName:cron触发器1--triggerGroup:cron触发器组名1--count:8--cron:0/10 * * * * ? *
SignInJob start at:22-04-08 14-47-10--jobName:cron任务1--jobGroup:任务组名1--triggerName:cron触发器1--triggerGroup:cron触发器组名1--count:9--cron:0/10 * * * * ? *
SignInJob start at:22-04-08 14-47-20--jobName:cron任务1--jobGroup:任务组名1--triggerName:cron触发器1--triggerGroup:cron触发器组名1--count:10--cron:0/10 * * * * ? *