AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

任务调度开源框架Quartz动态添加、删除、修改任务

2022-12-05 544
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 任务调度开源框架Quartz动态添加、删除、修改任务

任务调度开源框架Quartz动态添加、删除、修改任务

如题所示，本篇的主要内容是介绍如何对quratz的任务动态添加、删除及修改

  • 首先我写了一个任务管理的接口，里面有对job的一些操作方法
package com.hrt.quartz;
import java.text.ParseException;
import java.util.List;
import java.util.Date;
import org.quartz.SchedulerFactory;
import org.quartz.impl.StdSchedulerFactory;
/**
 * 定时任务管理
 * @author JP
 *
 */
public interface QuartzManager {
    /**
     *   添加简单任务，只运行一次的任务
     * @param jobname
     * @param jobGroup
     * @param jobClass
     * @param runTime  格式 ：yyyyMMddHHmmss
     * @param arrayParam
     */
 public void addSimpleJob(String jobname, String jobGroup, Class jobClass, Date runTime, List arrayParam); 
   /**
    * 添加循环任务,特定时间循环运行,例如每个星期3,12点运行等
    * @param jobname
    * @param jobGroup
    * @param jobClass
    * @param crontime
    * @param arrayParam
    */
  public void addCronJob(String jobname,String jobGroup,Class jobClass,String crontime,List arrayParam);
  /**
   * 修改简单任务，一般指修改运行的时间
   * @param jobName
   * @param jobGroup
   * @param runDateTime
   */
  void updateSimpleJob(String jobName, String jobGroup, Date runDateTime);
  /**
   * 修改cron任务,一般指修改循环运行时间
   * @param jobName
   * @param jobGroup
   * @param cronTime
   */
  public void updateCronJob(String jobName, String jobGroup, String cronTime);
  /**
   * 移除所有任务
   */
  public void deleteAll();
  /**
   * 移除任务
   * @param jobName
   * @param jobGroup
   */
  public void deleteJob(String jobName, String jobGroup);
  /**
   * 暂停任务
   * @param jobName
   * @param jobGroup
   */
  public void pauseJob(String jobName, String jobGroup);
  /**
   * 暂停所有任务
   */
  public void pauseAll();
  /**
     * 恢复某个任务
     *
     * @param jobName
     * @param jobGroup
     */
    public void resumeJob(String jobName, String jobGroup) ;
    /**
     * 恢复所有
     */
    public void resumeAll() ;
    /**
     * 关闭任务调度器
     */
    public void shutDown();
    /**
     * 开启任务调度器
     */
    public void startScheduler() ;
}

然后就是去实现这个接口里的方法，方便后面使用

package com.hrt.quartz;
import java.util.List;
import java.util.Set;
import java.util.ArrayList;
import java.util.Date;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleTrigger;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.matchers.GroupMatcher;
import org.quartz.impl.triggers.CronTriggerImpl;
public class QuartzManagerImpl implements QuartzManager{
   private static SchedulerFactory gSchedulerFactory = new StdSchedulerFactory(); 
   /**
       *   添加简单任务，只运行一次的任务
       * @param jobname
       * @param jobGroup
       * @param jobClass
       * @param runTime  格式 ：Date
       * @param arrayParam
       */
  @Override
  public  void addSimpleJob(String jobname, String jobGroup, Class jobClass, Date runTime, List arrayParam) {
    // TODO Auto-generated method stub
     try {
      Scheduler sched = gSchedulerFactory.getScheduler();
      //判断是否已存在相同jobName,jobGroup,若存在则删除
      if(sched.getJobDetail(JobKey.jobKey(jobname,jobGroup))!=null) {
          deleteJob(jobname, jobGroup);
      }
      JobDetail jobDetail=JobBuilder.newJob(jobClass)
          .withIdentity(jobname, jobGroup)
          .build();
      jobDetail.getJobDataMap().put("scheduleJob",arrayParam);
       //创建SimpleTrigger,在特定时间仅运行一次
          SimpleTrigger trigger = (SimpleTrigger) TriggerBuilder.newTrigger().withIdentity(jobname, jobGroup).
                  startAt(runTime).build();
          sched.scheduleJob(jobDetail, trigger);
       // 启动  
          if(!sched.isShutdown()) {
            sched.start();
          }
    } catch (SchedulerException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }  
  }
  @Override
  public void addCronJob(String jobname, String jobGroup, Class jobClass, String crontime, List arrayParam) {
    // TODO Auto-generated method stub
     try {
        Scheduler sched = gSchedulerFactory.getScheduler();
        //判断是否已存在相同jobName,jobGroup,若存在则删除
        if(sched.getJobDetail(JobKey.jobKey(jobname,jobGroup))!=null) {
            deleteJob(jobname, jobGroup);
        }
        JobDetail jobDetail=JobBuilder.newJob(jobClass)
            .withIdentity(jobname, jobGroup)
            .build();
        jobDetail.getJobDataMap().put("scheduleJob",arrayParam);
         //创建CronTrigger,在特定时间循环运行
         CronTrigger trigger =  (CronTrigger) TriggerBuilder.newTrigger().withIdentity(jobname, jobGroup)
             .withSchedule(CronScheduleBuilder.cronSchedule(crontime))// 日历
              .build();
            sched.scheduleJob(jobDetail, trigger);
         // 启动  
            if(!sched.isShutdown()) {
              sched.start();
            }
      } catch (SchedulerException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }  
  }
  /**
   * 修改SimpleJob任务时间
   */
  @Override
  public void updateSimpleJob(String jobName, String jobGroup, Date runDateTime) {
    // TODO Auto-generated method stub
    try {  
            Scheduler sched = gSchedulerFactory.getScheduler();  
            TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
           SimpleTrigger trigger = (SimpleTrigger) sched.getTrigger(triggerKey);  
            if (trigger == null) {  
                return;  
            }  
            // 触发器  
            TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
            // 触发器名,触发器组  
            triggerBuilder.withIdentity(jobName, jobGroup);
            // 触发器时间设定  
            triggerBuilder.startAt(runDateTime);
            // 创建Trigger对象
            trigger = (SimpleTrigger) triggerBuilder.build();
            // 按新的触发器重新设置Job执行
            sched.rescheduleJob(triggerKey, trigger);
        } catch (Exception e) {  
            throw new RuntimeException(e);  
        }  
  }
  /**
   * 修改CronJob  任务周期
   */
  @Override
  public void updateCronJob(String jobName, String jobGroup, String cronTime) {
    // TODO Auto-generated method stub
       try {  
              Scheduler sched = gSchedulerFactory.getScheduler();  
              TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
              CronTrigger trigger = (CronTrigger)sched.getTrigger(triggerKey); 
              if (trigger == null) {  
                  return;  
              }  
              String oldTime = trigger.getCronExpression();  
              if (!oldTime.equalsIgnoreCase(cronTime)) { 
                  // 触发器  
                  TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
                  // 触发器名,触发器组  
                  triggerBuilder.withIdentity(jobName, jobGroup);
                  triggerBuilder.startNow();
                  // 触发器时间设定  
                  triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cronTime));
                  // 创建Trigger对象
                  trigger = (CronTrigger) triggerBuilder.build();
                  // 按新的触发器重新设置Job执行
                  sched.rescheduleJob(triggerKey, trigger);
              }  
          } catch (Exception e) {  
              throw new RuntimeException(e);  
          }  
  }
   /**
    * 删除任务组名为group_1的所有任务
    */
  @Override
  public void deleteAll() {
    // TODO Auto-generated method stub
    try {  
         Scheduler sched = gSchedulerFactory.getScheduler();  
       GroupMatcher<JobKey> matcher = GroupMatcher.groupEquals("group_1");  //得修改
             Set<JobKey> jobkeySet = sched.getJobKeys(matcher);
             List<JobKey> jobkeyList = new ArrayList<JobKey>();
             jobkeyList.addAll(jobkeySet);
             sched.deleteJobs(jobkeyList);
             System.out.println("删除所有组别为group_1的任务");
        } catch (Exception e) {  
            throw new RuntimeException(e);  
        }  
  }
  /**
   * 删除单个任务
   */
  @Override
  public void deleteJob(String jobName, String jobGroup) {
    // TODO Auto-generated method stub
    try {  
            Scheduler sched = gSchedulerFactory.getScheduler();  
          sched.pauseTrigger(TriggerKey.triggerKey(jobName, jobGroup));// 停止触发器 
          sched.unscheduleJob(TriggerKey.triggerKey(jobName, jobGroup));// 移除触发器  
          sched.deleteJob(JobKey.jobKey(jobName, jobGroup));// 删除任务  
        } catch (Exception e) {  
            throw new RuntimeException(e);  
        }  
  }
  /**
   * 关闭所有定时器
   */
  @Override
  public void shutDown() {
    // TODO Auto-generated method stub
      try {  
              Scheduler sched = gSchedulerFactory.getScheduler();  
              if (!sched.isShutdown()) {  
                  sched.shutdown();  
              }  
          } catch (Exception e) {  
              throw new RuntimeException(e);  
          }  
  }
  /**
   * 启动所有的定时器
   */
  @Override
  public void startScheduler() {
    // TODO Auto-generated method stub
     try {  
              Scheduler sched = gSchedulerFactory.getScheduler();  
              sched.start();  
          } catch (Exception e) {  
              throw new RuntimeException(e);  
          }  
  }
   /**
    * 暂停单个任务
    */
  @Override
  public void pauseJob(String jobName, String jobGroup) {
    // TODO Auto-generated method stub
     try {  
              Scheduler sched = gSchedulerFactory.getScheduler();  
              sched.pauseJob(JobKey.jobKey(jobName, jobGroup));
              sched.pauseTrigger(TriggerKey.triggerKey(jobName, jobGroup));
          } catch (Exception e) {  
              throw new RuntimeException(e);  
          }  
  }
 /**
  * 暂停所有任务
  */
  @Override
  public void pauseAll() {
    // TODO Auto-generated method stub
    try {  
            Scheduler sched = gSchedulerFactory.getScheduler();  
           sched.pauseAll();
        } catch (Exception e) {  
            throw new RuntimeException(e);  
        }  
  }
  /**
   * 恢复单个任务
   */
  @Override
  public void resumeJob(String jobName, String jobGroup) {
    // TODO Auto-generated method stub
    try {  
            Scheduler sched = gSchedulerFactory.getScheduler();  
          sched.resumeJob(JobKey.jobKey(jobName, jobGroup));
          sched.resumeTrigger(TriggerKey.triggerKey(jobName, jobGroup));
        } catch (Exception e) {  
            throw new RuntimeException(e);  
        }  
  }
 /**
  * 恢复所有任务
  */
  @Override
  public void resumeAll() {
    // TODO Auto-generated method stub
    try {  
            Scheduler sched = gSchedulerFactory.getScheduler();  
            sched.resumeAll();
        } catch (Exception e) {  
            throw new RuntimeException(e);  
        }  
  }
}

再去弄一个具体的job类，去执行具体的工作

import java.text.SimpleDateFormat;
import java.util.Date;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
public class QuartzJob implements Job{
  @Override
  public void execute(JobExecutionContext context) throws JobExecutionException {
    // TODO Auto-generated method stub
     System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+ ".........");    
  }
}

接下来就是去调用方法，动态的管理任务。这里我就写了两种触发器添加任务的方法，其他方法可自己调用测试。

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import com.hrt.quartz.QuartzJob;
import com.hrt.quartz.QuartzManager;
import com.hrt.quartz.QuartzManagerImpl;
import com.hrt.util.DateCron;
public class TestQuartz {
  public static void main(String[] args) {
    executeSimpleJob();//以Simple触发器添加的定时任务
    executeCronJob(); //以Cron触发器添加的定时任务
    //QuartzManager q=new QuartzManagerImpl();
      //q.deleteAll(); 删除所有
  }
  //测试SImpleJob方法
  public static void executeSimpleJob() {
    QuartzManagerImpl q=new QuartzManagerImpl();
        String job_name="一个simpleJob任务";
        String jobGroup="Group12";
         //指定执行时间
        String time="2019-01-23 16:07:31";
      DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = null;
        try {
            //字符时间转时间类型
            date = format.parse(time);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println("Simple【系统启动】开始在2019-01-23 16:07:31执行");    
        //传参
       List list=new ArrayList<>();
        q.addSimpleJob(job_name, jobGroup, QuartzJob.class, date, list);
        //q.deleteJob(job_name, jobGroup);
  }
  //测试CronJob方法
  public static void executeCronJob() {
    QuartzManagerImpl q=new QuartzManagerImpl();
        String job_name="Cron触发器在指定时间循环执行";
        String jobGroup="Group12";
/*        //转换出Cron时间
      String Crontime=DateCron.cronTime(date, "1");
      System.out.println("Cron时间表达试：" +Crontime);*/
       String str="0/5 * * * * ? ";
       System.out.println("CronJOb【系统启动】(每5秒输出一次)...");    
       List list=new ArrayList<>();
      q.addCronJob(job_name, jobGroup, QuartzJob.class, str, list);
        //q.deleteJob(job_name, jobGroup);
  }
}

测试结果如下：

20200401134307494.png

有兴趣的老爷，可以关注我的公众号【一起收破烂】，回复【006】获取2021最新java面试资料以及简历模型120套哦~

文章标签：
Java
调度
收破烂的小熊猫
目录
相关文章
weixin_836869520
|
6月前
|
存储 Java API
Quartz表达式：定时任务调度的高级配置与应用
Quartz表达式：定时任务调度的高级配置与应用
weixin_836869520
167 1
好奇的菜鸟
|
7月前
|
SQL API 调度
Springboot2.4.5集成Quartz实现动态任务数据持久化-不怕重启服务
Springboot2.4.5集成Quartz实现动态任务数据持久化-不怕重启服务
好奇的菜鸟
295 0
风水道人
|
8月前
|
Java 数据库 Spring
Spring Boot 实现定时任务的动态增删启停
Spring Boot 实现定时任务的动态增删启停
风水道人
77 1
yangnk42
|
存储 开发框架 Java
分布式定时任务框架Quartz总结和实践（1）
Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。
yangnk42
204 0
java菌
quartz（二）动态增删改查停止启用job
quartz（二）动态增删改查停止启用job
java菌
70 0
wljslmz
|
存储 Oracle Java
如何使用Quartz框架来实现任务调度？
如何使用Quartz框架来实现任务调度？
wljslmz
117 0
猫头虎
|
Java 数据库 Spring
SpringBoot实现动态增删启停定时任务
SpringBoot实现动态增删启停定时任务
猫头虎
472 0
SpringBoot实现动态增删启停定时任务
开发工程师
|
Java 数据库 Spring
Spring Boot 定时任务，怎么实现任务动态增删启停？
在spring boot项目中，可以通过@EnableScheduling注解和@Scheduled注解实现定时任务，也可以通过SchedulingConfigurer接口来实现定时任务。但是这两种方式不能动态添加、删除、启动、停止任务。要实现动态增删启停定时任务功能，比较广泛的做法是集成Quartz框架。
开发工程师
503 0
Spring Boot 定时任务，怎么实现任务动态增删启停？
ta7lhdiw3omdo
|
SQL 监控 JavaScript
基于Quartz编写一个可复用的分布式调度任务管理WebUI组件
创业小团队，无论选择任何方案，都优先考虑节省成本。关于分布式定时调度框架，成熟的候选方案有XXL-JOB、Easy Scheduler、Light Task Scheduler和Elastic Job等等，其实这些之前都在生产环境使用过。但是想要搭建高可用的分布式调度平台，这些框架（无论是否去中心化）都需要额外的服务器资源去部署中心调度管理服务实例，甚至有时候还会依赖一些中间件如Zookeeper。
ta7lhdiw3omdo
243 0
基于Quartz编写一个可复用的分布式调度任务管理WebUI组件
程序猿DD
|
Java 数据库 Spring
Spring Boot实现定时任务的动态增删启停
Spring Boot实现定时任务的动态增删启添加执行定时任务的线程池配置类:
程序猿DD
295 0
Spring Boot实现定时任务的动态增删启停

热门文章

最新文章

  • 1
    为什么说流处理即未来？
  • 2
    【实战】锐捷AC+AP配置WLAN基本服务系列
  • 3
    Mac：安装Python3并配置环境变量（本地多个Python版本选择配置）
  • 4
    丰富、连接、待集成—MaxCompute 生态再出发
  • 5
    Tomcat 7.0 64位免安装解压版 安装及配置
  • 6
    securecrt克隆会话与sshd 的 MaxSessions
  • 7
    C语言结构体的使用！简易学生成绩统计程序发布！
  • 8
    《VMware Virtual SAN权威指南》一2.2　VSAN的要求
  • 9
    webstorm9.0.3 注册码
  • 10
    数据文件offline后unusable索引造成的问题
  • 1
    LangGraph：构建多代理动态工作流的开源框架，支持人工干预、循环、持久性等复杂工作流自动化
    27
  • 2
    Eliza：TypeScript 版开源 AI Agent 开发框架，快速搭建智能、个性的 Agents 系统
    25
  • 3
    AI Dev Gallery：微软开源 Windows AI 模型本地运行工具包和示例库，助理开发者快速集成 AI 功能
    34
  • 4
    「Mac畅玩鸿蒙与硬件51」UI互动应用篇28 - 模拟记账应用
    100
  • 5
    我的博客年度之旅：感恩、成长与展望
    87
  • 6
    《构建高效K近邻算法：降低计算复杂度的策略与实践》
    24
  • 7
    《提升支持向量机泛化能力：核函数改进策略大揭秘》
    16
  • 8
    《智能算法设计与开发的全解析：从理念到实践》
    20
  • 9
    《深度学习梯度消失问题：原因与解决之道》
    21
  • 10
    《docker基础篇：8.Docker常规安装简介》包括：docker常规安装总体步骤、安装tomcat、安装mysql、安装redis
    18

    • 相关电子书

    更多
  • 《Pulsar 2.8.0 功能特性概述及规划》
  • 低代码开发师（初级）实战教程
  • 阿里巴巴DevOps 最佳实践手册

    • 相关实验场景

    更多
  • XXL-JOB零改造迁移
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月