java 动态新增定时任务

最新推荐文章于 2024-05-04 17:17:52 发布
最新推荐文章于 2024-05-04 17:17:52 发布
阅读量1.5k 收藏 7
点赞数 3
分类专栏： java spring-quartz 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_19201215/article/details/120368214
版权

工具类

import com.cnsuning.bdes.common.WeekEnum;
import org.apache.commons.lang.StringUtils;
import org.quartz.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.util.Calendar;
import java.util.Date;
import java.util.Map;

@Component
public class JobUtil {
    private static final Logger logger = LoggerFactory.getLogger(JobUtil.class);

    /**
     * 
     * 功能描述: <br>
     * 新增Cron调度任务（不立即执行）
     *
     * @param scheduler
     * @param triggerGroupName 触发器组名
     * @param triggerName 触发器名
     * @param jobGroupName 任务组名
     * @param jobName 任务名
     * @param jobClass 任务的类类型
     * @param cronTime 时间设置 表达式
     * @param triggerStartTime 触发器开始时间
     * @param paramsMap 参数
     * @throws SchedulerException
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static void addCronScheduleJob(Scheduler scheduler, String triggerGroupName, String triggerName,String jobGroupName, String jobName, Class<? extends Job> jobClass, String cronTime, Date triggerStartTime,Map<String, Object> paramsMap, int hours) throws SchedulerException {
        logger.info("addCronScheduleJob: triggerGroupName{},triggerName{}", triggerGroupName, triggerName);
        Trigger trigger = scheduler.getTrigger(TriggerKey.triggerKey(triggerName, triggerGroupName));
        if (null == trigger) {
            // 创建任务
            JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
            // 参数设置
            jobDetail.getJobDataMap().putAll(paramsMap);
            if (hours > 0) {
                // simple
                SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.repeatHourlyForever(hours).withMisfireHandlingInstructionNextWithExistingCount();
                // 创建触发器
                trigger = TriggerBuilder.newTrigger().withIdentity(triggerName, triggerGroupName).startAt(triggerStartTime).withSchedule(scheduleBuilder).build();
            } else {
                // corn
                CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronTime).withMisfireHandlingInstructionDoNothing();
                // 创建触发器
                trigger = TriggerBuilder.newTrigger().withIdentity(triggerName, triggerGroupName).startAt(triggerStartTime).withSchedule(scheduleBuilder).build();
            }
            // 将触发器和任务绑定到调度器内
            scheduler.scheduleJob(jobDetail, trigger);
            // 启动任务
            /*
             * if (!scheduler.isShutdown()) { scheduler.start(); }
             */
            logger.info("Quartz created CronJob: {} ", jobDetail.getKey());
        } else {
            logger.info("job: {} already exist, don't need add new !!!", trigger.getKey());
        }
    }

    /**
     * 
     * 功能描述: <br>
     * 新增Simple调度任务（不立即执行）
     *
     * @param scheduler
     * @param triggerGroupName 触发器组名
     * @param triggerName 触发器名
     * @param jobGroupName 任务组名
     * @param jobName 任务名
     * @param jobClass 任务的类类型
     * @param triggerStartTime 触发器开始时间
     * @param paramsMap 参数
     * @throws SchedulerException
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static void addSimpleScheduleJob(Scheduler scheduler, String triggerGroupName, String triggerName,
            String jobGroupName, String jobName, Class<? extends Job> jobClass, Date triggerStartTime,
            Map<String, Object> paramsMap, int hours, int repeatCount) throws SchedulerException {
        logger.info("addCronScheduleJob: triggerGroupName:{},triggerName:{}", triggerGroupName, triggerName);
        Trigger trigger = scheduler.getTrigger(TriggerKey.triggerKey(triggerName, triggerGroupName));
        if (null == trigger) {
            // 创建任务
            // requestRecovery 执行中应用发生故障，需要重新执行
            // storeDurably 即使没有Trigger关联时，也不需要删除该JobDetail
            JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).requestRecovery()
                    .storeDurably().build();
            // 参数设置
            jobDetail.getJobDataMap().putAll(paramsMap);
            // simple
            SimpleScheduleBuilder scheduleBuilder = null;
            if (repeatCount > 0) {
                scheduleBuilder = SimpleScheduleBuilder.repeatHourlyForTotalCount(repeatCount, hours)
                        .withMisfireHandlingInstructionNextWithExistingCount();
            } else {
                scheduleBuilder = SimpleScheduleBuilder.repeatHourlyForever(hours)
                        .withMisfireHandlingInstructionNextWithExistingCount();
            }
            // 创建触发器
            trigger = TriggerBuilder.newTrigger().withIdentity(triggerName, triggerGroupName).startAt(triggerStartTime)
                    .withSchedule(scheduleBuilder).build();
            // 将触发器和任务绑定到调度器内
            scheduler.scheduleJob(jobDetail, trigger);
            // 启动任务
            /*
             * if (!scheduler.isShutdown()) { scheduler.start(); }
             */
            logger.info("Quartz created SimpleJob: {} ", jobDetail.getKey());
        } else {
            logger.info("job: {} already exist, don't need add new !!!", trigger.getKey());
        }
    }

    /**
     *
     * 功能描述: <br>
     * 删除任务
     *
     * @param
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static void deleteSchedulerJob(Scheduler scheduler, String triggerGroupName, String triggerName,String jobGroupName, String jobName) throws SchedulerException {
        JobKey jobKey = new JobKey(jobName, jobGroupName);
        // 判断对应的job是否存在
        if (scheduler.checkExists(jobKey)) {
            // 存在，删除
            if (scheduler.deleteJob(jobKey)) {
                logger.info("job:[{}-{}] delete success !!!", jobGroupName, jobName);
            } else {
                logger.error("job:[{}-{}] delete failed, please check it !!!", jobGroupName, jobName);
                throw new SchedulerException("deleteSchedulerJob failed, please check it !!!");
            }
        } else {
            logger.warn("job:[{}-{}] not exist, please check it !!!", jobName, jobGroupName);
            return;
        }
    }

    /**
     *
     * 功能描述: <br>
     * 更新触发器时间
     *
     * @param
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static void updateCronTriggerTime(Scheduler scheduler, String triggerGroupName, String triggerName,
            String newCronTime, Date triggerStartTime, int hours) throws SchedulerException {
        logger.info("updateCronTriggerTime: triggerGroupName{},triggerName{}", triggerGroupName, triggerName);
        Trigger trigger = scheduler.getTrigger(TriggerKey.triggerKey(triggerName, triggerGroupName));
        if (trigger == null) {
            logger.warn("cronTrigger:[{}-null] not exist !!!", triggerGroupName);
            return;
        }
        if (hours > 0) {
            TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
            triggerBuilder.withIdentity(triggerName, triggerGroupName);
            triggerBuilder.startAt(triggerStartTime);
            // simple
            SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.repeatHourlyForever(hours)
                    .withMisfireHandlingInstructionNextWithExistingCount();
            // 创建触发器
            triggerBuilder.withSchedule(scheduleBuilder);
            trigger = (SimpleTrigger) triggerBuilder.build();
            scheduler.rescheduleJob(TriggerKey.triggerKey(triggerName, triggerGroupName), trigger);
            logger.info("Simple updateCronTriggerTime: triggerStartTime{}", triggerStartTime);
        } else {
            CronTrigger cornTrigger = (CronTrigger) trigger;
            String oldTime = cornTrigger.getCronExpression();
            if (!oldTime.equalsIgnoreCase(newCronTime)) {
                TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
                triggerBuilder.withIdentity(triggerName, triggerGroupName);
                triggerBuilder.startAt(triggerStartTime);
                // corn
                CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(newCronTime)
                        .withMisfireHandlingInstructionDoNothing();
                triggerBuilder.withSchedule(scheduleBuilder);
                cornTrigger = (CronTrigger) triggerBuilder.build();
                scheduler.rescheduleJob(TriggerKey.triggerKey(triggerName, triggerGroupName), cornTrigger);
                logger.info("updateCronTriggerTime: old(){} -> new(){}", oldTime, newCronTime);
            } else {
                logger.warn("cronTrigger:[{}-{}] time samle, don't need update !!! ", triggerGroupName, cornTrigger);
            }
        }
    }

    /**
     * 
     * 功能描述: <br>
     * Cron表达式的格式：秒 分 时 日 月 周 年(可选)
     *
     * @param startTime 任务起始时间
     * @param cycle 执行周期
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String getCronExpression(Date startTime, String cycle) {
        String cronExpression = "";
        if (null != startTime) {
            // 当前时间所属周几
            Calendar c = Calendar.getInstance();
            c.setTime(startTime);
            int day = c.get(Calendar.DAY_OF_MONTH);
            int week = c.get(Calendar.DAY_OF_WEEK);
            int hour = c.get(Calendar.HOUR_OF_DAY);
            int minute = c.get(Calendar.MINUTE);
            int second = c.get(Calendar.SECOND);

            if ("天".equals(cycle)) {
                cronExpression = second + " " + minute + " " + hour + " ? * *";
            }
            if ("周".equals(cycle)) {
                cronExpression = second + " " + minute + " " + hour + " ? * " + week;
            }
            if ("15天".equals(cycle)) {
                cronExpression = second + " " + minute + " " + hour + " */15 * ?";
            }
            if ("月".equals(cycle)) {
                cronExpression = second + " " + minute + " " + hour + " " + day + " * ?";
            }
            if (!CronExpression.isValidExpression(cronExpression)) {
                cronExpression = "";
            }
        }

        return cronExpression;
    }

    /**
     * 
     * 功能描述: <br>
     * 〈功能详细描述〉
     *
     * @param startTime 23:11
     * @param cycle 每日、周一、周二。。。。。。
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String getCronExpressionByCycle(String startTime, String cycle) {
        String cronExpression = "";
        if (StringUtils.isNotBlank(startTime) && StringUtils.isNotBlank(cycle)) {
            // startTime转换 成时分秒
            int hour = 0;
            int minute = 0;
            int second = 0;
            if (startTime.length() > 5) {
                second = Integer.parseInt(startTime.substring(5, 6));
            }
            if (startTime.length() > 3) {
                minute = Integer.parseInt(startTime.substring(3, 5));
            }
            if (startTime.length() > 2) {
                hour = Integer.parseInt(startTime.substring(0, 2));
            }
            String week = WeekEnum.getCode(cycle);
            if (StringUtils.isNotBlank(week)) {
                cronExpression = second + " " + minute + " " + hour + " ? * " + week;
            } else {
                cronExpression = second + " " + minute + " " + hour + " ? * *";
            }
            if (!CronExpression.isValidExpression(cronExpression)) {
                cronExpression = "";
            }
        }

        return cronExpression;
    }

    /**
     * 
     * 功能描述: <br>
     * 判断Job是否存在
     *
     * @param scheduler
     * @param jobGroupName
     * @param jobName
     * @throws SchedulerException
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static boolean judgeJobExist(Scheduler scheduler, String jobGroupName, String jobName)
            throws SchedulerException {
        JobKey jobKey = new JobKey(jobName, jobGroupName);
        // 判断对应的job是否存在
        if (scheduler.checkExists(jobKey)) {
            logger.info("JobUtil.judgeJobExist:true jobName：{}，jobGroupName：{}", jobName, jobGroupName);
            return true;
        } else {
            logger.info("JobUtil.judgeJobExist:false jobName：{}，jobGroupName：{}", jobName, jobGroupName);
            return false;
        }
    }

    public static boolean judgeTriggerExist(Scheduler scheduler, String triggerName, String triggerGroupName)
            throws SchedulerException {
        TriggerKey triggerKey = new TriggerKey(triggerName, triggerGroupName);
        // 判断对应的job是否存在
        if (scheduler.checkExists(triggerKey)) {
            logger.info("JobUtil.judgeTriggerExist:true triggerName：{}，triggerGroupName：{}", triggerName,
                    triggerGroupName);
            return true;
        } else {
            logger.info("JobUtil.judgeTriggerExist:false triggerName：{}，triggerGroupName：{}", triggerName,
                    triggerGroupName);
            return false;
        }
    }

    public static boolean resumeJob(Scheduler scheduler, String jobGroupName, String jobName)
            throws SchedulerException {
        JobKey jobKey = new JobKey(jobName, jobGroupName);
        // 判断对应的job是否存在
        if (scheduler.checkExists(jobKey)) {
            /*
             * if (!scheduler.isShutdown()) { scheduler.start(); }
             */
            scheduler.resumeJob(jobKey);
            logger.info("JobUtil.judgeJobExist:true jobName：{}，jobGroupName：{}", jobName, jobGroupName);
            return true;
        } else {
            logger.info("JobUtil.judgeJobExist:false jobName：{}，jobGroupName：{}", jobName, jobGroupName);
            return false;
        }
    }

}

定时器自动触发方法

import com.alibaba.fastjson.JSON;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.ArrayList;
import java.util.List;

public class InspectionJob implements Job {
    private static final Logger logger = LoggerFactory.getLogger(InspectionJob.class);

    @Autowired
    private InspectionResultService inspectionResultService;

    public InspectionJob() {
        inspectionResultService = SpringContextUtils.getBeanByClass(InspectionResultService.class);
    }

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        logger.info("InspectionJob.execute context:{}");
        try {
            JobDataMap dataMap = context.getJobDetail().getJobDataMap();
            logger.info("start InspectionJob.execute dataMap:{}", JSON.toJSONString(dataMap));
            ClusterPatrolDto clusterPatrolDto = new ClusterPatrolDto();
            //clusterPatrolDto.setClusterId(clusterId);
            //clusterPatrolDto.setClusterName(clusterName);
            inspectionResultService.clusterPatrol(clusterPatrolDto);
            logger.info("end InspectionJob.execute clusterName:{}", clusterName);
        } catch (Exception e) {
            logger.info("InspectionJob.execute immediateInspection failed:{}", e);
        }

    }

}

配置文件 spring-quartz.xml

<bean id="inspectionJob"
		  class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
		<property name="jobClass"
				  value="com.cnsuning.bdes.job.InspectionJob" />
		<property name="durability" value="true" />
</bean>

<bean id="quartzScheduler" lazy-init="false"
		  class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
		<property name="dataSource">
			<ref bean="dataSource" />
		</property>
		<property name="applicationContextSchedulerContextKey" value="applicationContextKey"></property>
		<property name="configLocation"
				  value="classpath:conf/spring/spring-quartz.properties"></property>
		<property name="autoStartup" value="true" />
		<property name="overwriteExistingJobs" value="true" />
</bean>

实时新增定时任务

Map<String, Object> paramsMap = new HashMap<>();
String cronExpression = JobUtil.getCronExpressionByCycle(inspectionSubSetInfo.getSendTime(),inspectionSubSetInfo.getSendFrequency());
if (StringUtils.isBlank(cronExpression)) {
    return new ResponseSimpleObject(ResponseSimpleObject.ERROR_CODE, "定时任务新增失败，执行周期为空");
}
paramsMap.put("clusterName", inspectionSubSetInfo.getClusterName());
paramsMap.put("clusterId", inspectionSubSetInfo.getClusterId());
JobUtil.addCronScheduleJob(scheduler, triggerGroupName, triggerName, jobGroupName, jobName,InspectionJob.class, cronExpression, new Date(), paramsMap, 0);

新建表：

 

执行addCronScheduleJob方法，表qrtz_cron_triggers新增一条定时任务

 

东耳佳茗
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
c# 任务调度篇QuartZ（第四部分：配置添加任务文件使用）
一点一滴
12-28 2万+
主要改写的代码 //IJobDetail sayHijobDetail = JobBuilder.Create<SayHIJob>() // .WithDescription("this is sayHijobDetail") //.WithIdentity("SayhiJob", "Vip高级班") //.WithDescription("This is SayhiJob") ...
java 定时任务 实现
没伞的孩子努力奔跑
07-20 102
java 定时任务
TriggerBuilder详解
weixin_40482816的博客
05-11 3617
TriggerBuilder是⽤来创建触发器Trigger的。它与JobBuilder在整体结构或者说设计风格上可以说是⼀模⼀样的，同样采⽤Builder模式。 以下为TriggerBuilder类中的api说明： 1、TriggerBuilder.newTrigger() 调用自己的无参构造方法，创建⼀个新的TriggerBuilder，⽤它来定义触发器的规范。 源码： /** * Create a new TriggerBuilder with which to define a
Java中定时任务的6种实现方式，你知道几种？
最新发布
2301_82242670的博客
05-04 2921
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
Java 之定时器
yin__ren的博客
08-31 773
一、Java 定时器 二、Spring 定时器 三、quartz 定时器
Quartz 是什么？一文带你入坑
heishuiloveyou的博客
02-21 3961
*以上方式便是：**只要我们在Job实现类中添加对应key的setter方法，那么Quartz框架默认的JobFactory实现类在初始化 Job 实例对象时回自动地调用这些 setter 方法。按照上面的想法我们写出了这部分代码，但貌似打脸了，结果并没有按照我们预计的发展，是逻辑不对吗，貌似写的也没什么问题。个任务，每个任务都有指定的时间进行执行，而这种多任务的执行策略就是任务调度。接口，可以用来存取基本数据类型，也可以用来转载任何可序列化的数据对象，当。是工作任务调度的接口，任务类需要实现该接口。
Springboot：整合Quartz
拒绝熬夜啊的博客
11-25 3579
Springboot：整合Quartz一
Java实现定时任务
m0_54853420的博客
06-05 264
这种方式的定时任务主要用到两个类，Timer 和 TimerTask，使用起来比较简单。其中 Timer 负责设定 TimerTask 的起始与间隔执行时间。 TimerTask是一个抽象类，new的时候实现自己的 run 方法，然后将其丢给 Timer 去执行即可。 代码示例： 缺点：ScheduledExecutorService 即是 Timer 的替代者，JDK 1.5 并发包引入，是基于线程池设计的定时任务类。每个调度任务都会分配到线程池中的某一个线程去执行，任务就是并发调度执行的，任务之间互不
java 动态增加定时任务示例
08-31
_java动态增加定时任务示例 Java动态增加定时任务示例是指在Java中使用Quartz框架实现动态增加定时任务的示例代码。Quartz是一个功能强大且灵活的开源作业调度框架，能够轻松地实现复杂的作业调度任务。 Java动态...
springboot动态添加修改删除定时任务.md
09-09
（b）ThreadPoolTaskScheduler.schedule()方法会创建一个定时计划ScheduledFuture，在这个方法需要添加两个参数，Runnable（线程接口类） 和CronTrigger（定时任务触发器）（c）在ScheduledFuture中有一个cancel可以...
SpringBoot实现动态控制定时任务支持多参数功能
08-25
通过该方法，可以动态地新增定时任务。同时，也提供了 removeCronTask 方法，用于删除定时任务。 在实现多参数功能时，可以通过使用 Java 反射机制来实现参数的传递。例如，在定时任务中，可以使用反射机制来传递...
动态获取定时任务
12-18
动态获取定时任务,，将定时任务配置在数据库，启动项目的时候，用mybatis读取数据库，实例化对象，并设定定时任务。如果需要新增，减少，修改定时任务，仅需要修改数据库资料，并重启项目即可，无需改代码
java 定时任务管理框架
09-06
Java定时任务管理框架是开发中常见的一种工具，用于在特定时间执行特定任务，极大地提高了工作效率。Citic Scheduler作为这样一个框架，旨在简化Java项目中的定时任务管理。它提供了一个直观的用户界面，允许开发者...
Spring Boot 集成 Quartz（任务调度框架）
欲变世界，先变其身
09-28 5488
Quartz 是完全由Java开发的作业调度框架，当定时任务愈加复杂时，使用Spring注解@Schedule已经不能满足业务需要。} }return JobBuilder . newJob(SampleJob . class) . withIdentity("job" , "group") . withDescription("任务描述：内存方式运行") . storeDurably() . build();} }
Quartz架构篇 - 分布式任务调度Quartz
The Secret
01-15 2496
本文介绍分布式任务调度 Quartz
java定时任务quartz框架介绍
迷路的小羊博客
10-28 2033
什么是Quartz? Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，完全由Java开发，可以用来执行定时任务，类似于java.util.Timer。Quartz具有以下特点： （1）强大的调度功能，例如支持丰富多样的调度方法，可以满足各种常规及特殊需求； （2）灵活的应用方式，例如支持任务和调度的多种组合方式，支持调度数据的多种存储方式； （3）分布式和集群能力，Terracotta收购后在原来功能基础上作了进一步提升。 Quartz 的基本结构 Quart
Quartz.基本使用
qq_59025975的博客
02-11 1316
一、定时任务 在很多情况下任务并非需要立即执行,而是需要往后或定期执行,这不可能人工去操作,所以定时任务就出现了 Scheduled参数 @Scheduled(fixedRate=5000):上⼀次开始执⾏时间点之后5秒再执⾏ @Scheduled(fixedDelay=5000):上⼀次执⾏完毕时间点之后5秒再执⾏ @Scheduled(initialDelay=1000, fixedRate=5000):第⼀次延迟1秒后执⾏,之后按fixedRate的规则 每5秒执⾏⼀次 @Sc
定时任务框架Quartz-(一)Quartz入门与Demo搭建
热门推荐
noaman_wgs的博客
07-10 36万+
一、什么是Quartz 什么是Quartz? Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，完全由Java开发，可以用来执行定时任务，类似于java.util.Timer。但是相较于Timer， Quartz增加了很多功能： 持久性作业 - 就是保持调度定时的状态; 作业管理 - 对调度作业进行有效的管理; ...
java开发培训任务调度框架Quartz的用法
weixin_45695430的博客
05-24 1190
前言 项目中遇到一个，需要 客户自定任务启动时间 的需求。原来一直都是在项目里硬编码一些定时器，所以没有学习过。 很多开源的项目管理框架都已经做了 Quartz 的集成。我们居然连这么常用得东西居然没有做成模块化，实在是不应该。 Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，完全由Java开发，可以用来执行定时任务，类似于java.util.Timer。但是相较于Timer， Quartz增加了很多功能： 持久性作业 - 就是保持调度定时的状态;
java 动态新增修改删除任务
09-21
通过使用这些类，我们可以动态地新增、修改和删除定时任务。我们可以创建定时器或者定时任务执行器，然后配置需要执行的任务和执行的时间间隔。通过修改或者取消已经创建的定时任务，我们可以达到动态修改任务的目的...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值