spring集成动态Quartz帮助类

最新推荐文章于 2021-02-23 23:43:07 发布
置顶 最新推荐文章于 2021-02-23 23:43:07 发布
阅读量714 收藏
点赞数 2
分类专栏： java quartz 定时 文章标签： quartz spring job 定时任务 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/givemefive888/article/details/52881058
版权
java 同时被 3 个专栏收录
2 篇文章 0 订阅
订阅专栏
quartz
1 篇文章 0 订阅
订阅专栏
定时
1 篇文章 0 订阅
订阅专栏 
1、接口
 
package com.biz.oth.quartz.service;

import java.util.Map;

public interface QuartzManagerService {
	    
		/**
		 * 获得触发器对象
		 * @param paramMap
		 * @return
		 */
	 	public Map<String,Object> queryTriggersForMap(Map<String,Object> paramMap);
	 
	    /**
	     * 添加一个定时任务
	     * @param paramMap 
	     */
	    public void addJob(Map<String, Object> paramMap);
	    
	    /**
	     * 添加一个定时任务
	     * @param jobName 任务名 
	     * @param triggerName 触发器名 
	     * @param cronExpression 时间设置，参考quartz说明文档 
	     * @param description TODO
	     */
	    public void addJob(String jobName, String triggerName, String cronExpression, String description);
	    
	    /**
	     * 生成Cron表达式
	     * @param paramMap
	     * @return
	     */
	    public String getCroExpression(Map<String, Object> paramMap);
		
		/**
		 * 暂停触发器
		 * @param triggerName
		 * @param triggerGroup
		 */
		public void pauseTrigger(String triggerName, String triggerGroup);
		
		/**
		 * 重启触发器
		 * @param triggerName
		 * @param triggerGroup
		 */
		public void resumeTrigger(String triggerName, String triggerGroup);
		
		/**
		 * 删除触发器
		 * @param triggerName
		 * @param triggerGroup
		 * @return
		 */
		public boolean removeTrigger(String triggerName, String triggerGroup);
	  
		/**
		 * 修改一个任务的触发时间 
		 * @param paramMap
		 */
		public void modifyJobTime(Map<String, Object> paramMap);
		
		/**
		 * 修改一个任务的触发时间 
		 * @param jobName
		 * @param cronExpression
		 */
		public void modifyJobTime(String jobName, String cronExpression);
		
	    /** 
	     * 修改一个任务的触发时间 
	     * @param triggerName 
	     * @param triggerGroup 
	     * @param cronExpression 
	     */  
	    public void modifyJobTime(String triggerName, String triggerGroup, String cronExpression);
	  
	    /**
	     * 移除一个定时任务
	     * @param jobName
	     */
	    public void removeJob(String jobName);
	    
	    /**
	     *暂停一个job任务 
	     * @param jobName
	     */
	    public void pauseJob(String jobName);
	    
	    /**
	     * 恢复一个job任务
	     * @param jobName
	     */
	    public void resumeJob(String jobName);
	  
	    /**
	     * 暂停调度中所有的job任务
	     */
	    public void pauseAll();
	    
	    /**
	     * 
	     * 恢复调度中所有的job的任务
	     * 此方法重新恢复会多次调用暂停前的job
	     */
	    public void resumeAll();
	    
	    /** 
	     * 启动所有定时任务 
	     */  
	    public void startJobs();
	  
	    /** 
	     * 关闭所有定时任务 
	     * 关闭后需要重新启动TOMCAT
	     */  
	    public void shutdownJobs();
	    
	   
}

 

 

 

 
 
 
2、实现类
package com.biz.oth.quartz.service.impl;

import java.util.HashMap;
import java.util.Map;

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.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.ext.spring.jdbc.Condition;
import com.ext.spring.jdbc.ConditionDef;
import com.smart.biz.base.BaseDao;
import com.smart.biz.oth.quartz.MyQuartzJobBean;
import com.smart.biz.oth.quartz.service.QuartzManagerService;
import com.smart.common.Constant;
import com.smart.util.Utils;

@Service
public class QuartzManagerServiceImpl implements QuartzManagerService {
	    
	    @Autowired
		private BaseDao baseDao;
	    @Autowired
	    private Scheduler scheduler;
	  
	    private ConditionDef trggerCondition = new ConditionDef(new Object[][] {
			{ "JOB_NAME=:jobName" },
			{ "JOB_GROUP=:jobGroup" },
			{ "TRIGGER_NAME=:triggerName" },
			{ "TRIGGER_GROUP=:triggerGroup" }
	   });
	    
	    @Override
	    public Map<String,Object> queryTriggersForMap(Map<String,Object> paramMap) {
	    	Condition condition = new Condition(trggerCondition, paramMap);
	    	StringBuilder sql = new StringBuilder("select JOB_NAME jobName, JOB_GROUP jobGroup, TRIGGER_NAME triggerName, \n");
					      sql.append(" TRIGGER_GROUP triggerGroup \n ");
	    				  sql.append(" from QRTZ_TRIGGERS ");
	    				  sql.append(condition.getConditionClauseWithWhere());
	    	return baseDao.queryForMap(sql.toString(), paramMap);
	    }
	    
	    @Override
	    public void addJob(String jobName, String triggerName, String cronExpression, String description){  
	        try {  
	            // 任务执行类  ，任务名，任务组
	            JobBuilder jobBuilder = JobBuilder.newJob(MyQuartzJobBean.class).withIdentity(jobName, Constant.DEFAULT_JOB_GROUP);
	    		jobBuilder.withDescription(description);//描述
	    		jobBuilder.requestRecovery(true);//指示调度程序是否应该在遇到“恢复”或“失败”的情况下重新执行作业，默认false
	    		jobBuilder.storeDurably(true);//quartz会把job持久化到数据库中  默认false
	    		JobDetail jobDetail = jobBuilder.build();
	    		
	            // 触发器名,触发器组  
	    	 	TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger().withIdentity(triggerName, Constant.DEFAULT_TRIGGER_GROUP);
	    		triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cronExpression));
	            CronTrigger trigger = (CronTrigger) triggerBuilder.build();
	            
	            scheduler.scheduleJob(jobDetail, trigger);  
	        } catch (Exception e) {  
	            e.printStackTrace();  
	            throw new RuntimeException(e);  
	        }  
	    }  
	    
	    @Override
	    public void addJob(Map<String, Object> paramMap){
	    	String jobName = (String) paramMap.get("jobName");
	    	String triggerName = Utils.getUuid32();
			String cronExpression = getCroExpression(paramMap);
			addJob(jobName, triggerName, cronExpression, "");
		}
		
	    @Override
	    public String getCroExpression(Map<String, Object> paramMap){
	    	 String year = (String)paramMap.get("year"),
	    			week = (String)paramMap.get("week"),
	    	 		month = (String)paramMap.get("month"),
	    	 		day = (String) paramMap.get("day"),
	    	 		hour = (String)paramMap.get("hour"),
	    	 		minute = (String)paramMap.get("minute"),
	    	 		second = (String)paramMap.get("second");
	    	 
			 String defaultSecond = "0", defaultMinute = "0", defaultHour = "0", 
					defaultDay= "*",defaultMonth = "*", defaultWeek = "*", defaultYear = "*";
			 StringBuilder cronExpression = new StringBuilder();
			 if (second != null) defaultSecond = second;
			 if (minute != null) defaultMinute = minute;
			 if (hour != null) defaultHour = hour;
			 if (day != null) {
				 defaultDay = day;
				 //"?" 与{日期}互斥，即意味着若明确指定{日期}触发，则表示{星期}无意义，以免引起冲突和混乱
				 defaultWeek = "?";
			 }
			 if (month != null) defaultMonth = month;
			 if (week != null) {
				 defaultWeek = week;
				 //"?" 与{星期}互斥，即意味着若明确指定{星期}触发，则表示{日期}无意义，以免引起 冲突和混乱
				 defaultDay = "?";
			 }
			 if (year != null) defaultYear = year;
			 //如果都没空的时候，设置 defaultDay = "*"， defaultDay = "?"
			 if (day == null && week == null) {
				 defaultDay = "*";
				 defaultWeek = "?";
			 }
			 cronExpression.append(defaultSecond).append(" ")
			 			   .append(defaultMinute).append(" ")
			 			   .append(defaultHour).append(" ")
			 			   .append(defaultDay).append(" ")
			 			   .append(defaultMonth).append(" ")
			 			   .append(defaultWeek).append(" ")
			 			   .append(defaultYear);
			 return cronExpression.toString();
		}
	  
	    @Override
		public void pauseTrigger(String triggerName, String triggerGroup) {
			try {
				scheduler.pauseTrigger(new TriggerKey(triggerName, triggerGroup));// 停止触发器
			} catch (SchedulerException e) {
				throw new RuntimeException(e);
			}
		}
		
	    @Override
		public void resumeTrigger(String triggerName, String triggerGroup) {
			try {
				scheduler.resumeTrigger(new TriggerKey(triggerName, triggerGroup));// 重启触发器
			} catch (SchedulerException e) {
				throw new RuntimeException(e);
			}
		}
		
	    @Override
		public boolean removeTrigger(String triggerName, String triggerGroup) {
			TriggerKey triggerKey = new TriggerKey(triggerName, triggerGroup);
			try {
				scheduler.pauseTrigger(triggerKey);// 停止触发器
				return scheduler.unscheduleJob(triggerKey);// 移除触发器
			} catch (SchedulerException e) {
				throw new RuntimeException(e);
			}
		}
	    
		@Override
		public void modifyJobTime(Map<String, Object> paramMap) {
			String jobName = (String) paramMap.get("jobName");
			String cronExpression = getCroExpression(paramMap);
			modifyJobTime(jobName, cronExpression);
		}
		
		@Override
		public void modifyJobTime(String jobName, String cronExpression) {
			Map<String, Object> paramMap = new HashMap<String, Object>();
			paramMap.put("jobName", jobName);
			paramMap.put("jobGroup", Constant.DEFAULT_JOB_GROUP);
			Map<String, Object> returnMap = queryTriggersForMap(paramMap);
			if (returnMap != null) {
				String triggerName = (String) returnMap.get("triggerName");
				String triggerGroup = (String) returnMap.get("triggerGroup");
				modifyJobTime(triggerName, triggerGroup, cronExpression);
			}
			
		}
	  
	    @Override
	    public void modifyJobTime(String triggerName, String triggerGroup, String cronExpression) {  
	        try {  
	            TriggerKey triggerKey = new TriggerKey(triggerName, triggerGroup);
	            TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger().withIdentity(triggerName, triggerGroup);
	    		triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cronExpression));
	            CronTrigger trigger = (CronTrigger) triggerBuilder.build();
				
	            scheduler.rescheduleJob(triggerKey, trigger);
	        } catch (Exception e) {  
	            e.printStackTrace();  
	            throw new RuntimeException(e);  
	        }  
	    }  
	    
	    @Override
		public void removeJob(String jobName) {
	    	 Map<String, Object> paramMap = new HashMap<String, Object>();
	    	 paramMap.put("jobName", jobName);
	    	 String jobGroup = Constant.DEFAULT_JOB_GROUP;
	    	 paramMap.put("jobGroup", jobGroup);
			 Map<String, Object> returnMap = queryTriggersForMap(paramMap);
			 if (returnMap != null) {
		         try {
		        	String triggerName = (String) returnMap.get("triggerName");
		        	String triggerGroup = (String) returnMap.get("triggerGroup");
		        	removeTrigger(triggerName, triggerGroup); //移除触发器  
					scheduler.deleteJob(new JobKey(jobName, jobGroup));
				 } catch (SchedulerException e) {
					e.printStackTrace();
				 } 
			 }
			
		}
	  
	    @Override
	    public void startJobs() {  
	        try {  
	        	scheduler.start();  
	        } catch (Exception e) {  
	            e.printStackTrace();  
	            throw new RuntimeException(e);  
	        }  
	    }  
	  
	    @Override
	    public void shutdownJobs() {  
	        try {  
	            if(!scheduler.isShutdown()) {  
	            	scheduler.shutdown();  
	            }  
	        } catch (Exception e) {  
	            e.printStackTrace();  
	            throw new RuntimeException(e);  
	        }  
	    }

		@Override
		public void pauseAll() {
			try {  
				scheduler.pauseAll();
	        } catch (Exception e) {  
	            e.printStackTrace();  
	            throw new RuntimeException(e);  
	        }  
		}

		@Override
		public void resumeAll() {
			try {  
				scheduler.resumeAll();
	        } catch (Exception e) {  
	            e.printStackTrace();  
	            throw new RuntimeException(e);  
	        }  
			
		}

		@Override
		public void pauseJob(String jobName) {
			 try {  
				 JobKey jobKey = new JobKey(jobName, Constant.DEFAULT_JOB_GROUP);
				 scheduler.pauseJob(jobKey);
		     } catch (Exception e) {  
		            e.printStackTrace();  
		            throw new RuntimeException(e);  
		     }  
		}

		@Override
		public void resumeJob(String jobName) {
			try {  
				  JobKey jobKey = new JobKey(jobName, Constant.DEFAULT_JOB_GROUP);
				  scheduler.resumeJob(jobKey);
		      } catch (Exception e) {  
		            e.printStackTrace();  
		            throw new RuntimeException(e);  
		      }  
		}

}

 

 

 

3、quartz.xml
<pre name="code" class="html"><?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
	
	<bean name="quartzScheduler"
		class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
		<property name="dataSource">
			<ref bean="dataSource" />
		</property>
		<property name="schedulerContextAsMap">      
            <map>      
                <!-- spring 管理的service需要放到这里，才能够注入成功 -->      
                <description>schedulerContextAsMap</description>      
                <entry key="hyService" value-ref="hyService"/>      
            </map>      
        </property>    
		<property name="applicationContextSchedulerContextKey" value="applicationContextKey" />
		<property name="configLocation" value="classpath:quartz.properties" />
	</bean>
	
	<bean id="jobDetail" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
		<property name="jobClass">
			<value>com.smart.biz.oth.quartz.MyQuartzJobBean</value>
		</property>	
		  
		<property name="durability" value="true" />	
	</bean>

</beans>

 

 

 

4、quartz.properties
org.quartz.scheduler.instanceName = DefaultQuartzScheduler
org.quartz.scheduler.instanceId = AUTO
org.quartz.scheduler.rmi.export = false
org.quartz.scheduler.rmi.proxy = false
org.quartz.scheduler.wrapJobExecutionInUserTransaction = false

org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount = 10
org.quartz.threadPool.threadPriority = 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true

org.quartz.jobStore.misfireThreshold = 60000

#org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore

org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
#org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.HSQLDBDelegate
org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#org.quartz.jobStore.useProperties = true
org.quartz.jobStore.tablePrefix = QRTZ_  
org.quartz.jobStore.isClustered = true  
org.quartz.jobStore.clusterCheckinInterval = 20000
org.quartz.jobStore.maxMisfiresToHandleAtATime=1

 

 

 

 

 

DreamNiceDay
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Quartz 2.2.1 工具类
08-18
通过Quartz的API，自己实现了 添加JOB、删除、修改、暂停/恢复，停复机等的多种功能，已经可以满足基本项目的使用.
springboot quartz任务信息持久化storeDurably详解
OceanSky的专栏
09-05 4174
在将JobDetails信息持久化到数据库的时候有一个属性storeDurably，如果设置为true则无论与其关联的Trigger是否存在其都会一直存在，否则只要相关联的trigger删除掉了其会自动删除掉； 1.看下源码注解 /** * Whether or not the <code>Job</code> should remain stored after it is * orphaned (no <code>{@link Trigger
Quartz定时任务帮助类
weixin_34241036的博客
12-13 224
1 using Quartz; 2 using Quartz.Impl; 3 using System; 4 using System.Collections.Generic; 5 using System.Collections.Specialized; 6 using System.Linq; 7 using System.Text; 8 us...
Quartz定时服务帮助类
weixin_30886233的博客
05-11 85
using Quartz; using Quartz.Impl; using System; using System.Collections.Generic; namespace Fenla.Common { /// <summary> /// 定时任务调度帮助基类 /// 注意：job和trigger使用相同的jobName和jobG...
Quartz 基本概念
别抢我蓝buff
03-19 321
核心概念1.Job：Job是任务执行的流程，是一个类2.JobDetail：JobDetail是Job是实例，是一个对象，包含了该实例的执行计划和所需要的数据3.Trigger：Trigger是定时器，决定任务何时执行4.Scheduler：调度器，...
Spring Boot集成Quartz注入Spring管理的类的方法
08-27
本篇文章主要介绍了Spring Boot集成Quartz注入Spring管理的类的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring 集成 Quartz
05-30
Spring 集成 Quartz.zip
Spring集成Quartz的简单配置的方法
08-31
本篇文章主要介绍了Spring集成Quartz的简单配置的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
spring集成quartz集群配置
08-12
NULL 博文链接：https://vista-move.iteye.com/blog/2274246
spring-boot集成quartz实现动态任务管理，支持集群
01-15
spring-boot集成quartz实现动态任务管理，采用数据库存储方式，建表语句已经打包在一起，支持分布式集群。 代码开箱即用，没有集成业务模块，大家可以根据自己的业务场景自己去实现Job类即可。
quartz.net帮助文档
08-05
quartz.net帮助文档 从官网下载的
java quartz JobBuilder
Claroja
02-23 689
JobBuilder主要主要用来创建JobDetail,常用两个属性: .withIdentity("job1", "group1") //设置job的名称和分组,以便后期的查找 .usingJobData("key","value") // 使用JobData向job中传递参数 完整代码演示: package com; import org.quartz.*; import org.quartz.impl.StdSchedulerFactory; import java.io.IOException;
Quartz操作工具类
u011494081的专栏
05-25 3920
Quartz操作工具类，quartz 版本2.0.* 以上
Quartz2.x学习笔记（二）：存储与持久化
Howard的博客
02-23 1415
Quartz的存储与持久化 在默认情况下Quartz将任务调度的运行信息保存在内存中，这种方法提供了最佳的性能，因为内存中数据访问最快。不足之处是缺乏数据的持久性，当程序路途停止或系统崩溃时，所有运行的信息都会丢失。 而如果采用数据库存储的方式，那么如果调度执行到一半退出，再次运行可以通过方法恢复调度，从原来的地方开始执行。（如果调度10次，到第4次退出，那么卡可以从第5次继续执行） 下面是
基于Quartz2.3.3的帮助类 QuartzHelper
oopts的博客
11-02 580
using System;using System.Collections.Generic;using Quartz;using Quartz.Core;using Quartz.Impl;using Quartz.Impl.Triggers;using Kmmp.Core.Models; namespace Kmmp.Core.Helper{ /// <summary&g...
网站后台管理系统——登录部分
west13的专栏
11-17 1380
一、思路介绍 1.这块内容包含三个部分： 第一、数据库中存放用户登录信息。 第二、登录页面（js验证）。 第三、用户信息验证。 2.各部分功能实现方式介绍 第一、在数据库中写入默认的用户名和密码。 第二、登录页面中有两表单：用户名和密码，这部分要进行js验证，验证用户名和密码长度。 第三、编写另外一个jsp页面用于验证用户名和密码是否和数据库中的一致。 ...
QuartzUtils工具类
huangyueranbbc的博客
11-08 2993
Quartz工具类。包含一些常用的操作。 Job、Trigger、JobDetail、Listener、JobExecutionException、misfire、Priority、Durably、Recovery、DisallowConcurrentExecution、PersistJobDataAfterExecution、ThreadPool、usingJobData、Quartz Plu...
quartz的简单使用-基于2.X（一）【基本使用】
熊诗言的博客
05-27 2384
我自己测试过的代码 SchedulerFactory schedFact = new org.quartz.impl.StdSchedulerFactory(); Scheduler sched = schedFact.getScheduler(); // scheduler.getContext().put("java.sql.Con
spring整合quartz实现动态定时任务
luo_yu_1106的博客
09-26 546
目前的思路是先参考springboot整合quartz 本文代码参考： https://www.cnblogs.com/hhhshct/p/9707710.html https://www.cnblogs.com/hhhshct/p/9708688.html 第一步，加入quartz的依赖 <!--quartz start--> <dependency...
spring cloud集成quartz数据库配置定时任务
最新发布
04-23
在Spring Cloud集成Quartz时，需要进行以下数据库配置： 1. 首先，在您的Spring Boot项目中添加Quartz的依赖项。您可以在pom.xml文件中添加以下依赖项： ``` <groupId>org.springframework.boot <artifactId>...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值