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

最新推荐文章于 2024-06-29 10:43:48 发布
最新推荐文章于 2024-06-29 10:43:48 发布
阅读量665 收藏 2
点赞数 1
分类专栏： Quartz 文章标签： Quartz定时器动态管理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36654629/article/details/86612404
版权

任务调度开源框架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);
	}
}

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

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

收破烂的小熊猫~
关注
专栏目录
任务调度开源框架Quartz动态添加、修改和删除定时任务
Joyce Luo的专栏
07-07 5万+
Quartz 是个开源的作业调度框架，为在 Java 应用程序中进行作业调度提供了简单却强大的机制。Quartz框架包含了调度器监听、作业和触发器监听。你可以配置作业和触发器监听为全局监听或者是特定于作业和触发器的监听。Quartz 允许开发人员根据时间间隔（或天）来调度作业。它实现了作业和触发器的多对多关系，还能把多个作业与不同的触发器关联。整合了 Quartz 的应用程序可以重用来自不同事件的
通过源码分析Java开源任务调度框架Quartz的主要流程
m0_73257876的博客
08-27 324
继续分析JobStoreSupport类的两个线程 ClusterManager 和 MisfireHandler 的分析， 它们维护触发器的MISFIRE_INSTR状态，和调度器状态QRTZ_SCHEDULER_STATE。联合主键，QRTZ_JOB_DETAILS表SCHED_NAME外键。联合主键，QRTZ_JOB_DETAILS表JOB_GROUP外键。联合主键，QRTZ_JOB_DETAILS表JOB_NAME外键。联合主键，QRTZ_TRIGGERS表JOB_NAME外键。...
quartz动态添加、修改和删除定时任务
01-06
附件中实现了对quartz的动态添加、修改和删除定时任务，方便通过页面动态控制执行定时任务。
SpringBoot整合Quartz实现动态定时任务
最新发布
这河里吗l的博客
06-29 2365
Quartz是一个开源的任务调度服务，它可以独立使用，也可与其它的Java EE，Java SE应用整合使用。无论是执行十个，一百个工作的简单任务，还是执行成百上千个工作的复杂调度任务都可以使用Quartz来实现，此外，Quartz还提供了很多企业级应用的特色，如JTA事务支持及集群。如果你的应用中有任务需要在特定的时间执行，亦或周期循环执行，则Quartz也许是你理想的选择。
java quartz动态的添加任务_Quartz1.8.6 任务调度之动态添加、修改和删除任务
weixin_39556853的博客
03-02 359
Quartz框架可以动态的添加、删除作业任务，也可以修改作业的时间。下边我们就通过例子更清楚的知道该如何使用。实例：package com.what21.quartz1.cron.demo2;public class QuartzDemo {/*** @param args* @throws Exception*/public static void main(String[] args) thr...
定时任务quartz实现分组串行并行动态配置
05-06
Quartz是一款广泛使用的开源作业调度框架，它允许开发者在Java应用程序中定义和执行定时任务。在实际应用中，我们可能需要根据业务需求动态地配置定时任务的执行方式，例如，某些任务可能需要串行执行，而其他任务则...
java Quartz动态添加、删除job
qq_27106141的博客
02-07 1594
java Quartz动态添加、删除job
浅析动态添加、删除、修改TreeView节点
03-22
浅析动态添加、删除、修改TreeView节点 不需要重新加载treeview就可以完成对treeview的添加、删除、修改操作
Quartz 2.2 动态添加、修改和删除定时任务
u013680097的博客
04-28 587
转自：https://blog.csdn.net/xlxxcc/article/details/52115995 Quartz 2.2 的实现原理和运行过程, 请阅读我的另一篇文章：http://blog.csdn.net/xlxxcc/article/details/52104463 下面直接上代码： QuartzManager.java 动态添加、修改和删除定时任务管理类 impor...
Quartz带参数任务的创建与修改
weixin_30929195的博客
08-18 1399
需求背景：创建的quartz任务需要用到三个参数，根据参数去执行并将结果入库，并且参数可修改更新。 这里，有三个参数需要传入，分别是planId、target、officeId 定义Job类： public class StatisticsTaskService implements Job { private Logger logger = LoggerFactor...
Quartz 动态添加、修改和删除定时任务
_江屿_
09-01 702
Quartz动态添加、修改和删除定时任务
spring quartz动态实现对任务的增删改查（可传参数）
csdn_sunlighting的博客
05-27 4045
        上一篇文章写到了关于定时任务的动态实现，在一些情况下，我们可能需要传参数来实现定时任务，直接贴代码了QuartzParamUtils，核心类package com.thinkgem.jeesite.modules.task.quartz.param; import java.util.HashMap; import java.util.List; import java.util...
quartz 动态添加job_Quartz任务调度框架
weixin_39988197的博客
12-02 705
什么是Quartz？ Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。Quartz的最新版本为Quartz 2.3.1。Quartz是一个完全由java编写...
SpringBoot整合Quartz任务，java对任务创建、删除、修改、查询
张刚的博客
01-28 947
SpringBoot整合Quartz任务，java对任务创建、删除、修改、查询， java对Quartz任务创建，删除，修改，查询
Quartz学习笔记（一）—— Job和SimpleTrigger
亦轩丶Javer的博客
03-05 568
Quartz 主要模块Scheduler 与调度器的主要API进行交互Job 实现想要的调度器的组件Trigger 将执行一个给定的工作时间表的组件JobBuilder 用于定义/构建JobDetail实例TriggerBuilder 用于定义/构建触发实例JobDataMap 可以用来保存任何数量的数据对象(序列化),JobDataMap JavaMap接口的一个实现,并且有一些添加便利的方法来存
使用Quartz实现动态任务调度
动态任务调度意味着可以在运行时添加、修改或删除任务，无需重启应用。 首先，需要下载Quartz的jar包，并确保与项目的其他依赖兼容。在这个案例中，由于项目使用了Spring、Hibernate和Webwork，所以也升级了数据库...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

收破烂的小熊猫~

你的鼓励将是我创造最大的东西~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值