精华内容
下载资源
问答
  • SpringBoot实现动态定时任务,是Springboot做的动态定时任务,可以暂停,恢复,添加,删除,等操作
  • java spring quartz 实现的动态定时任务,可以动态添加高度任务
  • springboot jpa quartz 动态定时任务,任务增加,任务删除,任务修改demo,非常简单
  • SpringBoot整合Quartz实现动态定时任务,在页面动态展示,添加,暂停,删除定时任务. 并整合了MyBatis-plus, 感兴趣的小伙伴 可以试试
  • 主要介绍了SpringBoot并发定时任务动态定时任务实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 主要介绍了SpringBoot集成Quartz动态定时任务,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • spring设置动态定时任务.doc
  • 本篇文章主要介绍了详解Spring整合Quartz实现动态定时任务,具有一定的参考价值,感兴趣的小伙伴们可以参考一下。
  • 无配置文件实现动态定时任务,超级简单 详细介绍了如何利用spring框架实现了动态定时任务的功能,包括动态取消、动态修改任务执行时间等。本文给出了详细的代码示例,可即拿即用。可扩展性强,可根据自己的具体业务...

    无配置文件实现动态定时任务,超级简单

    定时任务抽象类ScheduleTask ,为具体的任务类提供了模板方法

    /**
     * 定时任务抽象类(父类)
     * 具体执行方法请继承该类,然后重写run方法
     */
    public abstract class ScheduleTask implements Runnable {
        private String id;
    
        public void setId(String id) {
            this.id = id;
        }
    
        public String getId() {
            return id;
        }
    
        public ScheduleTask(String id) {
            this.id = id;
        }
    
        @Override
        public abstract void run();
    }
    
    

    工具类ScheduleUtil 。用于实现任务的开启、关闭、时间设置等操作

    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.ScheduledFuture;
    
    /**
     * 定时任务工具类
     *
     */
    public class ScheduleUtil {
        private static final Log logger = LogFactory.getLog(ScheduleUtil.class);
    
        private static ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
        private static Map<String, ScheduledFuture<?>> scheduledFutureMap = new HashMap<>();
        static{
            threadPoolTaskScheduler.initialize();
            logger.info("初始化线程池...");
        }
        /**
         * 启动某定时任务,到时间点就运行一次
         * @param scheduleTask
         * @param startTime
         */
        public static void start(ScheduleTask scheduleTask, Date startTime){
            if (isExist(scheduleTask.getId())){
                logger.info("启动定时任务"+ scheduleTask.getId()+"失败,任务已存在");
                return;
            }
            ScheduledFuture<?>scheduledFuture = threadPoolTaskScheduler.schedule(scheduleTask,startTime);
            scheduledFutureMap.put(scheduleTask.getId(),scheduledFuture);
            logger.info("启动定时任务"+ scheduleTask.getId()+",执行时间为"+ startTime);
        }
    
        /**
         * 启动某定时任务,以固定周期运行
         * @param scheduleTask
         * @param period
         */
        public static void start(ScheduleTask scheduleTask, long period){
            if (isExist(scheduleTask.getId())){
                logger.info("启动定时任务"+ scheduleTask.getId()+"失败,任务已存在");
                return;
            }
            ScheduledFuture<?>scheduledFuture = threadPoolTaskScheduler.scheduleAtFixedRate(scheduleTask,period);
            scheduledFutureMap.put(scheduleTask.getId(),scheduledFuture);
            logger.info("启动定时任务" + scheduleTask.getId() + ",执行周期为" + period + "毫秒");
        }
    
        /**
         * 取消某定时任务
         * @param scheduleTask*/
        public static void cancel(ScheduleTask scheduleTask){
            ScheduledFuture<?> scheduledFuture = scheduledFutureMap.get(scheduleTask.getId());
            if(scheduledFuture != null && !scheduledFuture.isCancelled()){
                scheduledFuture.cancel(false);
            }
            scheduledFutureMap.remove(scheduleTask.getId());
            logger.info("取消定时任务"+ scheduleTask.getId());
        }
        /**
         * 修改定时任务执行时间
         * @param scheduleTask
         * @param startTime
         */
        public static void reset(ScheduleTask scheduleTask,Date startTime){
            //先取消定时任务
            String id = scheduleTask.getId();
            ScheduledFuture<?> scheduledFuture = scheduledFutureMap.get(id);
            if(scheduledFuture != null && !scheduledFuture.isCancelled()){
                scheduledFuture.cancel(false);
            }
            scheduledFutureMap.remove(id);
            //然后启动新的定时任务
            scheduledFuture = threadPoolTaskScheduler.schedule(scheduleTask,startTime);
            scheduledFutureMap.put(id,scheduledFuture);
            logger.info("重置定时任务"+ id+",执行时间为"+ startTime);
        }
    
        /**
         * 判断某个定时任务是否存在或已经取消
         * @param id
         */
        public static Boolean isExist(String id) {
            ScheduledFuture<?> scheduledFuture = scheduledFutureMap.get(id);
            if (scheduledFuture != null && !scheduledFuture.isCancelled()) {
                return true;
            }
            return false;
        }
    }
    
    

    具体的任务类MyTask

    import java.util.Date;
    
    public class MyTask extends ScheduleTask {
        public MyTask(String id) {
            super(id);
        }
    
        @Override
        public void run() {
        	//todo Your operation
            System.out.println(new Date() + "任务" + this.getId() + "开始执行...hello world!");
        }
    }
    
    

    用法示例

    import java.util.Date;
    
    public class Main {
        public static void main(String[] args) throws Exception {
            //任务1
            ScheduleTask helloTask1 = new MyTask("task1");//new一个具体的执行任务
            ScheduleUtil.start(helloTask1, new Date(System.currentTimeMillis() + 5000));//5秒后执行一次
            ScheduleUtil.reset(helloTask1, new Date(System.currentTimeMillis() + 10000));//修改时间,10秒后执行
    
            //任务2
            ScheduleTask helloTask2 = new MyTask("task2");//new一个具体的执行任务
            ScheduleUtil.start(helloTask2, 2000);//每2秒执行一次
            Thread.sleep(5000);
            ScheduleUtil.cancel(helloTask2);//取消定时任务
        }
    }
    
    
    

    测试结果,如下图
    在这里插入图片描述

    本例无需其他任何配置,简单易用
    需用到的包为:
    commons-logging.jar
    spring-beans
    spring-context
    spring-core

    展开全文
  • 动态定时任务demo.rar

    2020-05-28 14:43:37
    基于springboot框架搭建的定时任务管理demo,可以动态修改定时任务的执行时间,及动态增加和启用或禁用定时任务
  • 基于Spring的Quartz动态定时任务增删改查,代码简洁。后端采用SpringMvc+Spring+Mybatis+Quartz,前端采用Bootstrap框架,数据库采用MySQL;完成定时任务动态任务初始化,增删改查
  • 文档讲述了SpringTask动态定时任务的使用以及配置方法。可拔插的使用在相关的项目中去
  • 动态定时任务调度

    2020-05-16 12:09:51
    一、 为什么要使用动态定时任务 现在的系统早已不是仅仅由增删改查组成,任务的定时调度和执行也是程序的标配。定时任务相当于闹钟,在什么时候做什么事情。定时任务实现方式,很多人都有不同的方式,基础无外乎以下...

    一、 为什么要使用动态定时任务
    现在的系统早已不是仅仅由增删改查组成,任务的定时调度和执行也是程序的标配。定时任务相当于闹钟,在什么时候做什么事情。定时任务实现方式,很多人都有不同的方式,基础无外乎以下四种:
    1、 JDK的Timer类
    2、 JDK的ScheduledExecutorService
    3、 Spring Task
    4、 Quartz
    在使用过程中,用的最多的是SpringTask的XML配置,配置简单,也较好理解。但是有个缺点,在运行过程中想改变某个任务的执行时间频率或者是再增加/删除一个任务,怎么做?关闭应用,更改配置文件,重新启动!如果这种任务经常性变动,我们不可能频繁更改配置和重启应用的,这时动态定时任务有了用武之地。
    二、 技术选型
    近期在做项目的预警中心,运营人员在web页面进行增删改需要预警的内容和频率,服务端在接收到web请求后,添加、删除、修改定时任务。
    在我的考虑中有三种方案实现,如下:
    1、 启动一个定时任务,每隔一秒查询一次数据库,匹配到需要执行的任务,放入线程池执行;
    2、 Spring ThreadPoolTaskScheduler,将任务ID和ScheduledFuture存入ConcurrentHashMap,通过任务ID获取ScheduledFuture,操作任务;
    3、 Quartz-功能完善的任务调度框架;
    方案一对数据库压力较大,频繁访问数据库,可能导致数据库性能低下,影响整个系统的性能。方案二中ThreadPoolTaskScheduler能够开启线程池进行任务调度,schedule方法返回ScheduledFuture,可以关闭其线程,符合我的预期,作为备选方案。方案三Quartz 是一个功能完善的任务调度框架,支持集群环境下的任务调度,使用也比较麻烦,做持久化的时候需要用到quartz的11张表,引入第三方框架会增加系统的复杂度,同时也增加了开发成本。
    综上,我选择了方案二。
    三、 实现原理
    这里先介绍下ThreadPoolTaskScheduler是怎么实现对重复的任务进行调度。
    在这里插入图片描述
    ThreadPoolTaskScheduler其实底层使用也是java自带的线程池。
    在这里插入图片描述
    在这里插入图片描述
    从下面的代码中可以看出最终执行的java.util.concurrent.ScheduledExecutorService定义的方法。executor正是上图createExecutor方法创建的ScheduledThreadPoolExecutor。
    在这里插入图片描述
    ThreadPoolTaskScheduler提供了以下6种方法进行定时任务发布:

    1public ScheduledFuture<?> schedule(Runnable task, Trigger trigger);//动态创建指定表达式cron的定时任务。
    2public ScheduledFuture<?> schedule(Runnable task, Date startTime);//在指定时间执行一次定时任务。
    3public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period);//在指定时间(startTime)以指定间隔(period毫秒)执行一次任务,间隔为前一次执行开始到下一次任务执行。
    4public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period);//从现在开始以指定间隔(period毫秒)执行一次任务,间隔为前一次执行开始到下一次任务执行。
    5public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay);//在指定时间(startTime) 以指定间隔(delay毫秒)执行一次任务,间隔为前一次执行完成到下一次任务执行。
    6public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay);//从现在开始以指定间隔(delay毫秒)执行一次任务,间隔为前一次执行完成到下一次任务执行。
    
    
    根据业务场景,我采用的是第5种方式,代码如下:
    
    1.	@Service  
    2.	@Slf4j  
    3.	public class AlertTaskInitServiceImpl implements IAlertTaskInitService {  
    4.	  
    5.	    /** 
    6.	     * 线程池 
    7.	     */  
    8.	    @Autowired  
    9.	    private ThreadPoolTaskScheduler threadPoolTaskScheduler;  
    10.	  
    11.	    /** 
    12.	     * futureConcurrentMap 
    13.	     */  
    14.	    private ConcurrentMap<Long, ScheduledFuture> futureConcurrentMap = new ConcurrentHashMap<>();  
    15.	  
    16.	    /** 
    17.	     * 开启定时任务 
    18.	     * 
    19.	     * @param alertRule 预警规则 
    20.	     * @return 成功标记 
    21.	     */  
    22.	    @Override  
    23.	    public boolean startTask(AlertRule alertRule) {  
    24.	        boolean flag = false;  
    25.	        long period = alertRule.getPeriod();  
    26.	        Date startDate = new Date();  
    27.	        BaseTask baseTask = new BaseTask();  
    28.	        baseTask.setAlertRule(alertRule);  
    29.	        future = threadPoolTaskScheduler.scheduleAtFixedRate(baseTask, startDate, period);  
    30.	        futureConcurrentMap.put(id, future);  
    31.	        log.info("预警规则 id:{} 添加任务成功", id);  
    32.	        flag = true;  
    33.	        return flag;  
    34.	    }  
    35.	  
    36.	    /** 
    37.	     * 关闭定时任务 
    38.	     * 
    39.	     * @param ruleId 规则ID 
    40.	     * @return 成功标记 
    41.	     */  
    42.	    @Override  
    43.	    public boolean stopTask(Long ruleId) {  
    44.	        boolean flag = false;  
    45.	        if (ruleId == null) {  
    46.	            log.warn("预警规则ID为空");  
    47.	            return flag;  
    48.	        }  
    49.	        ScheduledFuture future = futureConcurrentMap.get(ruleId);  
    50.	        if (future == null){  
    51.	            log.warn("预警future不存在");  
    52.	            return true;  
    53.	        }  
    54.	        future.cancel(true);  
    55.	        if (future.isCancelled()) {  
    56.	            futureConcurrentMap.remove(ruleId);  
    57.	            flag = true;  
    58.	        }  
    59.	        return flag;  
    60.	    }  
    61.	  
    62.	    /** 
    63.	     * 修改定时任务 
    64.	     * 
    65.	     * @param alertRule 预警规则 
    66.	     * @return 成功标记 
    67.	     */  
    68.	    @Override  
    69.	    public boolean updateTask(AlertRule alertRule) {  
    70.	        if (alertRule == null) {  
    71.	            log.warn("预警规则为空");  
    72.	            return false;  
    73.	        }  
    74.	        boolean flag = stopTask(alertRule.getId());  
    75.	        if (!flag) {  
    76.	            return flag;  
    77.	        }  
    78.	        return startTask(alertRule);  
    79.	    }  
    80.	}
    
    

    threadPoolTaskScheduler初始化如下:

    <!--定时任务调度器-->  
    <bean id="threadPoolTaskScheduler" class="org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler">  
    	 <property name="rejectedExecutionHandler">  
    	        <bean class="java.util.concurrent.ThreadPoolExecutor$AbortPolicy"/>  
    	 </property>  
        <property name="threadNamePrefix" value="MesTaskThreadPool-"/>  
    	<property name="waitForTasksToCompleteOnShutdown" value="true"/>  
    	<property name="awaitTerminationSeconds" value="120"/>  
        <property name="poolSize" value="10"/>  
    	<property name="removeOnCancelPolicy" value="true"/>  
    </bean>
    

    以上是我对本次使用动态定时任务调度的一点分析。技术没有优劣之分,每种技术都有适合的应用场景,在能解决问题的前提下,我认为越简单的技术越稳妥。

    展开全文
  • SpringBoot集成Quartz实现动态定时任务

    千次阅读 2019-11-24 19:50:17
    SpringBoot集成Quartz实现动态定时任务,不停服务更新任务间隔

    一、背景

    在平常的开发过程中,大家对定时任务肯定都不陌生,比如每天0点自动导出下用户数据,每天早上8点自动发送一封系统的邮件等等。简单的定时任务使用spring自带的 @Scheduled实现即可。但是对于一些特殊的场景下,比如我们想在不重启项目的情况下,动态的修改定时器的运行间隔,将原来每30分钟执行一次的定时任务,动态改为5分钟执行一次,这时候Spring自带的定时器就不太方便了。

    二、引入Quartz

    “工欲善其事,必先利其器”——Quartz就是我们解决这个问题的利器, Quartz是Apache下开源的一款功能强大的定时任务框架。Quartz官网 对它的描述:
    QuartzQuartz是一个功能丰富的开源作业调度库,可以集成到几乎任何Java应用程序中——从最小的独立应用程序到最大的电子商务系统。Quartz可用于创建简单或复杂的调度,以执行数万、数百甚至数万个作业;任务被定义为标准Java组件的作业,这些组件可以执行几乎任何您可以编程让它们执行的任务。Quartz调度器包含许多企业级特性,比如对JTA事务和集群的支持。

    在使用Quartz之前,我们要先了解下Quartz的中核心组成:

    • Job 任务,要执行的具体内容,我们自定义的任务类都要实现此Job接口,Job接口中只有一个方法,我们的业务逻辑就在此方法编写,Job的源码如下:
      Job

    • JobDetail 表示一个具体的可执行的调度程序,Job 是这个可执行程调度程序所要执行的内容,另外 JobDetail 还包含了这个任务调度的方案和策略

    • Trigger 触发器,用于定义Job任务何时被触发,以何种方式触发。Trigger接口的关系图如下,最常用的是CronTrigger
      Trigger

    • Scheduler 调度容器,Scheduler负责将Job和Trigger关联起来,统一进行任务调度,一个Scheduler中可以注册多个 Job 和 Trigger。

    在这里插入图片描述

    三、SpringBoot集成Quartz

    接下来我们使用SpringBoot 2.2.0.RELEASE,集成Quartz 2.3.0版本,来创建一个简单的demo。

    1.添加maven依赖

     <!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz -->
     <dependency>
         <groupId>org.quartz-scheduler</groupId>
         <artifactId>quartz</artifactId>
         <version>2.3.0</version>
    </dependency>
    

    2.创建Job任务

    此处创建了PrintTimeJob 类并实现Job接口,任务很简单——打印开始时间,然后休眠5s,打印结束时间。

    package com.example.demo.quartz;
    
    import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    
    public class PrintTimeJob implements Job {
    
        private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-DD HH:mm:ss");
     
        @Override
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
            String format = sdf.format(new Date());
            System.out.println(Thread.currentThread().getName()+"  任务开始>>>>>>>>>>>>>>现在时间是:"+format);
             //模拟任务执行耗时5s
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"  任务结束!现在时间是:"+sdf.format(new Date()));
        }
    }
    
    

    3.创建CronTrigger与scheduler

    在定义过Job类之后,我们就可以通过创建CronTrigger与scheduler来执行定时任务了,为了简单,代码都写在了main方法里

    package com.example.demo.quartz;
    
    import org.quartz.*;
    import org.quartz.impl.StdSchedulerFactory;
    import org.quartz.spi.MutableTrigger;
    
    import java.util.Date;
    
    public class QuartzTest {
    
        public static void main(String[] args) throws SchedulerException {
            //1.创建一个jobDetail,并与PrintTimeJob绑定,Job任务的name为printJob
            JobDetail jobDetail = JobBuilder.newJob(PrintTimeJob.class).withIdentity("printJob").build();
    
            //2.使用cron表达式,构建CronScheduleBuilder
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0/5 * * * * ?");
            //使用TriggerBuilder构建cronTrigger,并指定了Trigger的name和group
            CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("job1", "group1")
                    .withSchedule(cronScheduleBuilder).build();
            //3.创建scheduler
            StdSchedulerFactory factory = new StdSchedulerFactory();
            Scheduler scheduler = factory.getScheduler();
            //4.将job和cronTrigger加入scheduler进行管理
            scheduler.scheduleJob(jobDetail,cronTrigger);
            //5.开启调度
            scheduler.start();
        }
    }
    

    执行main方法,可以看到控制台输出,如下图:
    在这里插入图片描述

    四、如何动态修改定时任务间隔

    通过上面的代码我们知道了如何通过Quartz实现定时任务,那么关键的问题来了——如何动态的修改任务间隔?这个问题其实可以分解为三小个问题:
    在这里插入图片描述

    • 如何将scheduler变为spring容器管理?
      在SpringBoot中很容易实现,使用 @Bean或者 @Autowired注入Scheduler 即可。

    • 如何重新设置Job任务的Trigger?
      既然scheduler是任务的调度器,那么我们自然想到scheduler中是否有相关API,果然发现了scheduler中的rescheduleJob(TriggerKey key, Trigger trigger)方法,从方法名很明显看出,这是在重新设置任务的触发器,我们修改任务的时间间隔,就是在重新设置的触发器。而TriggerKey 是目标任务的标识。包含任务名字和分组名,这个在上面demo中我们设置过。

    • 如何在项目启动后,就开始任务调度?
      这个问题等同于 “如何监听springboot应用启动成功事件?”,翻阅资料发现,自Spring框架3.0版本后,自带了ApplicationListener接口,允许我们通过实现此接口监听spring框架中的的ApplicationEvent,ApplicationListener接口的源码如下:
      AppListener

    ApplicationListener使用了观察者模式,实现该接口的类,会作为观察者,当特定的ApplicationEvent被触发时,spring框架反射动调用onApplicationEvent方法,更多的说明详见官网说明ApplicationListener

    ApplicationEvent就是要监听的事件,查看源码发现其有很多实现类,而其中的SpringApplicationEvent下的ApplicationReadyEvent就是我们想要的监听的事件。
    关于ApplicationEvent 更多说明见官网链接ApplicationEvent
    在这里插入图片描述
    到了这里,三个问题都解决了,思路清晰了,编起代码来,就很快了。

    五、动态修改定时任务间隔

    1.创建QuartzUtil工具类

    package com.example.demo.util;
    
    import lombok.extern.slf4j.Slf4j;
    import org.quartz.*;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    import org.springframework.util.ObjectUtils;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    @Slf4j
    @Component
    public class QuartzUtil {
    
        /**
         * 注入Scheduler
         */
        @Autowired
        private Scheduler scheduler;
    
        /**
         * 创建CronTrigger
         * @param triggerName  触发器名
         * @param triggerGroupName 触发器组名
         * @param cronExpression  定时任务表达式
         */
        public CronTrigger createCronTrigger(String triggerName,String triggerGroupName ,String cronExpression){
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);
            CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity(triggerName, triggerGroupName)
                    .withSchedule(cronScheduleBuilder).build();
            return cronTrigger;
        }
    
        /**
         * 创建JobDetail
         * @param jobDetailName 任务名称
         * @param jobClass  任务类,实现Job类接口
         */
        public JobDetail createCronScheduleJob(String jobDetailName,Class<? extends Job> jobClass){
            JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobDetailName).build();
            return jobDetail;
        }
    
    
        /**
         * 修改cron任务的执行间隔
         * @param triggerName   旧触发器名
         * @param triggerGroupName 旧触发器组名
         * @param newCronTime
         * @throws SchedulerException
         */
        public boolean updateCronScheduleJob(String triggerName,String triggerGroupName,String newCronTime) throws SchedulerException {
            Date date;
            log.info("updateCronScheduleJob 入参name={},triggerGroupName={},newCronTime={}",triggerName,triggerGroupName,newCronTime);
            TriggerKey triggerKey = new TriggerKey(triggerName, triggerGroupName);
            CronTrigger cronTrigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            if(ObjectUtils.isEmpty(cronTrigger)){
                log.error("获取到的cronTrigger为null!");
                return false;
            }
            String oldTime = cronTrigger.getCronExpression();
            log.info("oldTimeCron={},newCronTime={}",oldTime,newCronTime);
            if (!oldTime.equalsIgnoreCase(newCronTime)) {
                CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(newCronTime);
                CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(triggerName, triggerGroupName)
                        .withSchedule(cronScheduleBuilder).build();
                date = scheduler.rescheduleJob(triggerKey, trigger);
                log.info("修改执行成功,下次任务开始time={}",new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(date));
                return true;
            }else{
                log.error("oldTimeCron与newCronTime相等,修改结束");
                return false;
            }
        }
    
    }
    
    

    2.使用ApplicationListener监听

    package com.example.demo.config;
    
    
    import cn.hutool.core.date.DateUtil;
    import com.example.demo.job.PrintTimeJob;
    import com.example.demo.util.QuartzUtil;
    import lombok.extern.slf4j.Slf4j;
    import org.quartz.JobDetail;
    import org.quartz.SchedulerException;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.context.event.ApplicationReadyEvent;
    import org.springframework.context.ApplicationListener;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Primary;
    import org.springframework.scheduling.quartz.SchedulerFactoryBean;
    import org.springframework.stereotype.Component;
    
    import java.util.Date;
    import java.util.Properties;
    
    
    /**
     * 监听器,启动定时任务
     *
     */
    @Slf4j
    @Component
    public class QuartzConfig implements  ApplicationListener<ApplicationReadyEvent> {
    
        /**
         * 注入QuartzUtil
         */
        @Autowired
        private QuartzUtil quartzUtil;
    
        @Override
        public void onApplicationEvent(ApplicationReadyEvent applicationReadyEvent) {
            try {
                log.info("监听程序启动完成");
                String jobName = "printTimeJob";
                String cronTriggerName = "printTimeCronTrigger";
                String cronTriggerGroupName = "printTimeCronTriggerGroup";
                 //创建定时任务PrintTimeJob,每10秒描述执行一次
                Date cronScheduleJob = quartzUtil.createCronScheduleJob(jobName, PrintTimeJob.class, cronTriggerName, cronTriggerGroupName, "0/10 * * * * ?");
                log.info("定时任务jobName={},cronTriggerName={},cronTriggerGroupName={},date={}",jobName, cronTriggerName,cronTriggerGroupName,DateUtil.format(cronScheduleJob,"yyyy-MM-dd HH:mm:ss"));
                quartzUtil.scheduleJob();
            } catch (SchedulerException e) {
                e.printStackTrace();
                log.error("监听程序启动失败");
            }
        }
    }
    
    

    3.创建Controller,模拟动态修改定时任务间隔

    package com.example.demo.controller;
    
    
    import com.example.demo.config.CompanyWeChatConfig;
    import com.example.demo.util.ApiRes;
    import com.example.demo.util.QuartzUtil;
    import com.example.demo.util.ResultEnum;
    import io.swagger.annotations.ApiOperation;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.http.MediaType;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.Map;
    
    
    /**
    * @Author:         wgq
    * @CreateDate:     2019-11-8 13:43:21
    * @Description:    quartz测试
    * @Version:        1.0
    */
    @Slf4j
    @RestController
    @RequestMapping(value = "/qz")
    public class QuartzController {
    
        
        /*
        *注入QuartzUtil 
        **/
        @Autowired
        QuartzUtil quartzUtil;
    
         /**
         * 修改定时任务间隔
         * @param triggerName 触发器名称
         * @param groupName  触发器组名
         * @param newCronTime
         * @return
         */
        @PostMapping(value = "updateCronScheduleJob",produces = MediaType.APPLICATION_JSON_VALUE)
        @ApiOperation(value = "修改cron任务执行间隔")
        public boolean sendMsg(@RequestParam String triggerName, @RequestParam String groupName,@RequestParam String newCronTime){
            try {
                return  quartzUtil.updateCronScheduleJob(triggerName, groupName, newCronTime);
            }catch (Exception e){
                e.printStackTrace();
            }
            return false;
        }
    
    
    }
    
    

    4.模拟动态修改定时任务间隔

    1.现在我们启动项目,会发现在项目启动完成后,我们的自定义监听类QuartzConfig里面的onApplicationEvent方法被触发,我们的PrintTimeJob开始按照每10秒一次的频率执行。
    在这里插入图片描述2.现在我们使用postman调用QuartzControllerupdateCronScheduleJob方法,将定时任务修改为每30秒一次
    在这里插入图片描述发送请求后,查看控制台打印信息,修改成功,定时任务变为每30秒执行一次!
    在这里插入图片描述
    OK,到了这里大功告成了!
    当然Quartz功能不止如此,我们还可以动态的创建、停止定时任务等等,留给大家去探索。

    展开全文
  • 1. 入口类加@EnabledScheduling注解 2.随便创建一个类,实现SchedulingConfigurer 接口 注释的地方是重点,你直接复制过去... // 这个是定时任务的执行规则,比如每2分钟执行一次什么的 @Override public vo...

    1. 入口类加@EnabledScheduling注解

     

    2.随便创建一个类,实现SchedulingConfigurer 接口

          注释的地方是重点,你直接复制过去用就行了。

    @Component 
    public class TaskCronChange implements  SchedulingConfigurer{
    
        public String cron; // 这个是定时任务的执行规则,比如每2分钟执行一次什么的
    
        @Override
        public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
            //项目部署时,会在这里执行一次,从数据库拿到cron表达式
            // 这句代码就是获取定时任务的执行规则,你从哪里获取都可以,从数据库,从配置中心apollo都可以,根据你的业务需求来。
            cron = xxxMapper.getCronTime(); // 这句是个伪代码,你明白意思就好
    
           Runnable task = new Runnable() {
               @Override
               public void run() {
                  //任务逻辑代码部分.这里调用你要执行的任务就行了
                  System.out.println("I am going:" + LocalDateTime.now());
               }
           };
           Trigger trigger = new Trigger() {
               @Override
               public Date nextExecutionTime(TriggerContext triggerContext) {
                  //任务触发,可修改任务的执行周期.
                  //每一次任务触发,都会执行这里的方法一次,重新获取下一次的执行时间        
                  cron = timerQueryMapper.getCronTime();
                  CronTrigger trigger = new CronTrigger(cron);
                  Date nextExec = trigger.nextExecutionTime(triggerContext);
                  return nextExec;
               }
           };
           taskRegistrar.addTriggerTask(task, trigger);
        }
    
    }

    3. 好了,去运行吧,没有第3了

     

     

     

     

    展开全文
  • 主要介绍了Springboot整个Quartz实现动态定时任务的示例代码,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • spring设置动态定时任务,spring 定时器
  • 1.需求:每天网站开始营业时(一般是7:30)开始执行更新数据库,但是这个7:30是可以修改的. 就是说这个定时任务... * 动态定时任务-->动态修改cron参数 */ @Service @EnableScheduling public class ScheduledFor...
  • 定时任务有三种实现 1 jdk自带的定时任务 2 Quartz插件实现的定时任务,需要引入额外的包 3 SpringTask定时调度,是对jdk的再一次封装,不用引入其他包了,用spring的包就自带 SpringTask有3种实现定时任务的方式 1 ...
  • spring 动态定时任务

    千次阅读 2019-06-28 10:29:06
    使用的是spring的ThreadPoolTaskScheduler定时线程池,其有以下四种方法进行定时任务发布: ...2. schedule(Runnable task, Trigger trigger),动态创建指定表达式cron的定时任务 3. scheduleAtFixedR...
  • SpringBoot定时器:基于注解(@Scheduled)的简单定时器,基于接口SchedulingConfigurer的动态定时任务) 一、代码目录结构 二、配置文件application.yml内容 #设置定时任务 task: taskName1: #任务名称 switch: ...
  • 文章目录一、功能说明二、快速使用三、实现原理1、动态管理实现(1) 配置管理介绍(2) 使用后处理器拦截SpringBoot原本的定时任务(3) 使用ApplicationRunner初始化自定义的定时任务运行器(4) 进行动态管理2、增强接口...
  • springboot动态定时任务

    2018-04-18 15:19:58
    前提概述:springboot定时器开发特别简单,本篇文章不做介绍(通过配置@EnableScheduling和@Scheduled(cron=""实现),动态定时器相对复杂,... 动态定时任务实现步骤如下 1、定时器类继承SchedulingConf...
  • springboot的动态定时任务,crm中用户登录使用的job。
  • springboot整合quarzt实现动态定时任务

    千次阅读 2019-05-12 16:26:21
    springboot整合quarzt实现动态定时任务实现定时任务的几种方式:1.使用linux的crontab2.使用spring自带的ScheduledExecutor3. 使用JDK自带的Timer4.使用quarzt整合步骤:遇到的坑:源码地址:[github源码地址]...
  • 动态定时任务.zip

    2020-04-24 09:01:58
    包含Dao层,service controller 都包含,拿出来改一下就可以用了,源码。我自己在使用的中的。
  • 上一次传错了资源了,这个是正确的,包含quartz动态定时任务
  • 基于quartz集群分布式动态定时任务管理 真正动态,定时任务“0”开发,基于quartz集群超轻量级扩展实现。 不多说,先看效果 添加定时任务 编辑定时任务-修改定时规则 特点: 基于quartz集群,轻量扩展。可快速改造...
  • 1.1创建任务表 CREATE TABLE `scheduled_task` ( `id` int(11) NOT NULL AUTO_INCREMENT, `task_key` varchar(128) NOT NULL COMMENT '任务key值(使用bean名称)', `task_desc` varchar(128) DEFAULT NULL ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 73,569
精华内容 29,427
关键字:

动态定时任务