quartz 动态添加任务、暂停、删除

最新推荐文章于 2024-07-24 14:21:39 发布
最新推荐文章于 2024-07-24 14:21:39 发布
阅读量5.1k 收藏 4
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/slipknotm_/article/details/40895277
版权

web.xml,所有配置文件以application开头，项目启动就能一起加载了

 <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>
			classpath*:/applicationContext*.xml
		</param-value>
  </context-param>


配置文件application-quartz.xml

<?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="schedulerFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
        <property name="dataSource">  
            <ref bean="dataSource" />  
        </property>  
        <property name="applicationContextSchedulerContextKey" value="applicationContextKey" />  
        <property name="configLocation" value="classpath:quartz-cluster.properties" />
		<!-- 启动时延期2秒开始任务 -->
		<property name="startupDelay" value="2" />
    </bean>
</beans>

quartz-cluster.properties

#demo settings
server.node_name=server1


#============================================================================
# Configure Datasources
#============================================================================
#quartz.jdbc.driver=com.mysql.jdbc.Driver
#quartz.jdbc.url=jdbc:mysql://192.168.1.99:3306/quartz?useUnicode=true&characterEncoding=utf-8
#quartz.jdbc.username=root
#quartz.jdbc.password=2cydb


#============================================================================
# Configure Main Scheduler Properties  
#============================================================================
org.quartz.scheduler.instanceName = ClusteredScheduler
org.quartz.scheduler.instanceId = AUTO
org.quartz.scheduler.skipUpdateCheck = true


#============================================================================
# Configure ThreadPool  
#============================================================================
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount = 5
org.quartz.threadPool.threadPriority = 5


#============================================================================
# Configure JobStore  
#============================================================================
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.misfireThreshold = 60000
org.quartz.jobStore.useProperties = false
org.quartz.jobStore.tablePrefix = QRTZ_


#Cluster setting
org.quartz.jobStore.isClustered = true
org.quartz.jobStore.clusterCheckinInterval = 15000


#============================================================================
# Configure Plugins 
#============================================================================


#org.quartz.plugin.triggHistory.class = org.quartz.plugins.history.LoggingJobHistoryPlugin


#org.quartz.plugin.jobInitializer.class = org.quartz.plugins.xml.XMLSchedulingDataProcessorPlugin
#org.quartz.plugin.jobInitializer.fileNames = quartz_data.xml
#org.quartz.plugin.jobInitializer.failOnFileNotFound = true
#org.quartz.plugin.jobInitializer.scanInterval = 120
#org.quartz.plugin.jobInitializer.wrapInUserTransaction = false


还有quartz的表

#
# In your Quartz properties file, you'll need to set 
# org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#
#
# By: Ron Cordell - roncordell
#  I didn't see this anywhere, so I thought I'd post it here. This is the script from Quartz to create the tables in a MySQL database, modified to use INNODB instead of MYISAM.


DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;
DROP TABLE IF EXISTS QRTZ_LOCKS;
DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;
DROP TABLE IF EXISTS QRTZ_CALENDARS;


CREATE TABLE QRTZ_JOB_DETAILS(
SCHED_NAME VARCHAR(120) NOT NULL,
JOB_NAME VARCHAR(200) NOT NULL,
JOB_GROUP VARCHAR(200) NOT NULL,
DESCRIPTION VARCHAR(250) NULL,
JOB_CLASS_NAME VARCHAR(250) NOT NULL,
IS_DURABLE VARCHAR(1) NOT NULL,
IS_NONCONCURRENT VARCHAR(1) NOT NULL,
IS_UPDATE_DATA VARCHAR(1) NOT NULL,
REQUESTS_RECOVERY VARCHAR(1) NOT NULL,
JOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP))
ENGINE=InnoDB;


CREATE TABLE QRTZ_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
JOB_NAME VARCHAR(200) NOT NULL,
JOB_GROUP VARCHAR(200) NOT NULL,
DESCRIPTION VARCHAR(250) NULL,
NEXT_FIRE_TIME BIGINT(13) NULL,
PREV_FIRE_TIME BIGINT(13) NULL,
PRIORITY INTEGER NULL,
TRIGGER_STATE VARCHAR(16) NOT NULL,
TRIGGER_TYPE VARCHAR(8) NOT NULL,
START_TIME BIGINT(13) NOT NULL,
END_TIME BIGINT(13) NULL,
CALENDAR_NAME VARCHAR(200) NULL,
MISFIRE_INSTR SMALLINT(2) NULL,
JOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP))
ENGINE=InnoDB;


CREATE TABLE QRTZ_SIMPLE_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
REPEAT_COUNT BIGINT(7) NOT NULL,
REPEAT_INTERVAL BIGINT(12) NOT NULL,
TIMES_TRIGGERED BIGINT(10) NOT NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;


CREATE TABLE QRTZ_CRON_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
CRON_EXPRESSION VARCHAR(120) NOT NULL,
TIME_ZONE_ID VARCHAR(80),
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;


CREATE TABLE QRTZ_SIMPROP_TRIGGERS
  (          
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    STR_PROP_1 VARCHAR(512) NULL,
    STR_PROP_2 VARCHAR(512) NULL,
    STR_PROP_3 VARCHAR(512) NULL,
    INT_PROP_1 INT NULL,
    INT_PROP_2 INT NULL,
    LONG_PROP_1 BIGINT NULL,
    LONG_PROP_2 BIGINT NULL,
    DEC_PROP_1 NUMERIC(13,4) NULL,
    DEC_PROP_2 NUMERIC(13,4) NULL,
    BOOL_PROP_1 VARCHAR(1) NULL,
    BOOL_PROP_2 VARCHAR(1) NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP) 
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;


CREATE TABLE QRTZ_BLOB_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
BLOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
INDEX (SCHED_NAME,TRIGGER_NAME, TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;


CREATE TABLE QRTZ_CALENDARS (
SCHED_NAME VARCHAR(120) NOT NULL,
CALENDAR_NAME VARCHAR(200) NOT NULL,
CALENDAR BLOB NOT NULL,
PRIMARY KEY (SCHED_NAME,CALENDAR_NAME))
ENGINE=InnoDB;


CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;


CREATE TABLE QRTZ_FIRED_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
ENTRY_ID VARCHAR(95) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
INSTANCE_NAME VARCHAR(200) NOT NULL,
FIRED_TIME BIGINT(13) NOT NULL,
SCHED_TIME BIGINT(13) NOT NULL,
PRIORITY INTEGER NOT NULL,
STATE VARCHAR(16) NOT NULL,
JOB_NAME VARCHAR(200) NULL,
JOB_GROUP VARCHAR(200) NULL,
IS_NONCONCURRENT VARCHAR(1) NULL,
REQUESTS_RECOVERY VARCHAR(1) NULL,
PRIMARY KEY (SCHED_NAME,ENTRY_ID))
TYENGINEPE=InnoDB;


CREATE TABLE QRTZ_SCHEDULER_STATE (
SCHED_NAME VARCHAR(120) NOT NULL,
INSTANCE_NAME VARCHAR(200) NOT NULL,
LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
CHECKIN_INTERVAL BIGINT(13) NOT NULL,
PRIMARY KEY (SCHED_NAME,INSTANCE_NAME))
ENGINE=InnoDB;


CREATE TABLE QRTZ_LOCKS (
SCHED_NAME VARCHAR(120) NOT NULL,
LOCK_NAME VARCHAR(40) NOT NULL,
PRIMARY KEY (SCHED_NAME,LOCK_NAME))
ENGINE=InnoDB;


CREATE INDEX IDX_QRTZ_J_REQ_RECOVERY ON QRTZ_JOB_DETAILS(SCHED_NAME,REQUESTS_RECOVERY);
CREATE INDEX IDX_QRTZ_J_GRP ON QRTZ_JOB_DETAILS(SCHED_NAME,JOB_GROUP);


CREATE INDEX IDX_QRTZ_T_J ON QRTZ_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_JG ON QRTZ_TRIGGERS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_C ON QRTZ_TRIGGERS(SCHED_NAME,CALENDAR_NAME);
CREATE INDEX IDX_QRTZ_T_G ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);
CREATE INDEX IDX_QRTZ_T_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_N_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_N_G_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_NEXT_FIRE_TIME ON QRTZ_TRIGGERS(SCHED_NAME,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_ST ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE_GRP ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_GROUP,TRIGGER_STATE);


CREATE INDEX IDX_QRTZ_FT_TRIG_INST_NAME ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME);
CREATE INDEX IDX_QRTZ_FT_INST_JOB_REQ_RCVRY ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME,REQUESTS_RECOVERY);
CREATE INDEX IDX_QRTZ_FT_J_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_FT_JG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_FT_T_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP);
CREATE INDEX IDX_QRTZ_FT_TG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);


commit; 



@PersistJobDataAfterExecution
public class QuartzFactory extends QuartzJobBean{
	
	private static final Logger logger = LoggerFactory.getLogger(QuartzFactory.class);  
	

	@Override
	public void executeInternal(JobExecutionContext context) throws JobExecutionException {
		TaskLogService taskLogService = ApplicationContextHolder.getBean(TaskLogService.class);
		Task task = (Task)context.getMergedJobDataMap().get("task");
		
		TaskLog log = taskLogService.save(task.getId());
		
        logger.info("任务名称 = [" + task.getClassName() + "---------任务分组 "+task.getMethodName() + "]");
        taskLogService.finshLog(log.getId());
	} 
}


下面的两个类实际应用中都以放到util包里便捷管理
QuartzUtil 类 

public class QuartzUtil {

	/**
	 * 转换为Task
	 * @param trigger
	 * @param job
	 * @return
	 */
	public static Task convert(Trigger trigger,Task job){
		
		job.setTaskName(trigger.getKey().getName());
		job.setTaskGroup(trigger.getKey().getGroup());
		job.setDescription("触发器:" + trigger.getKey()+"_"+trigger.getDescription());
		job.setEndTime(trigger.getEndTime());
		job.setStartTime(trigger.getStartTime());
		job.setNextFireTime(trigger.getNextFireTime());
		job.setPrevFireTime(trigger.getPreviousFireTime());
		job.setPriority(trigger.getPriority());
		Trigger.TriggerState triggerState = null;
		
		try {
			triggerState = getScheduler().getTriggerState(trigger.getKey());
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
		job.setStatus(triggerState.name());
		if (trigger instanceof CronTrigger) {
			CronTrigger cronTrigger = (CronTrigger) trigger;
			String cronExpression = cronTrigger.getCronExpression();
			job.setCronExpression(cronExpression);
		}
		return job;
	}
	
	/**
	 * 获取正在运行的计划任务
	 * @return
	 */
	public static Map<String,Trigger> getTriggers(){
		
		Map<String,Trigger> triggerMap = new HashMap<String,Trigger>();
		
		Scheduler scheduler = getScheduler();
		GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
		Set<JobKey> jobKeys = null;
		try {
			jobKeys = scheduler.getJobKeys(matcher);
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
		for (JobKey jobKey : jobKeys) {
			List<? extends Trigger> triggers = null;
			try {
				triggers = scheduler.getTriggersOfJob(jobKey);
			} catch (SchedulerException e1) {
				e1.printStackTrace();
			}
			for (Trigger trigger : triggers) {
				triggerMap.put(jobKey.getGroup()+"."+jobKey.getName(), trigger);
			}
		}
		return triggerMap;
	}
	
	/**
	 * 启动一个计划任务
	 * @return
	 * @throws SchedulerException 
	 */
	public static Date startTask(Task task) throws SchedulerException{
		String taskName = task.getTaskName();
		String taskGroup = task.getTaskGroup();

		Scheduler scheduler = getScheduler();
		TriggerKey triggerKey = TriggerKey.triggerKey(taskName, taskGroup);
		CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
		
		//不存在，创建一个
		if (null == trigger) {
			JobDetail jobDetail = JobBuilder.newJob(QuartzFactory.class).withIdentity(taskName, taskGroup).build();
			jobDetail.getJobDataMap().put("scheduleJob", task);
			//表达式调度构建器
			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(task.getCronExpression());
			//按新的cronExpression表达式构建一个新的trigger
			trigger = TriggerBuilder.newTrigger().withIdentity(taskName, taskGroup).withSchedule(scheduleBuilder).build();
			return scheduler.scheduleJob(jobDetail, trigger);
		} else {
			// Trigger已存在，那么更新相应的定时设置
			//表达式调度构建器
			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(task.getCronExpression());
			//按新的cronExpression表达式重新构建trigger
			trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
			//按新的trigger重新设置job执行
			return scheduler.rescheduleJob(triggerKey, trigger);
		}
	}
	/**
	 * 暂停任务执行
	 * @param taskName
	 * @param groupName
	 * @throws SchedulerException
	 */
	public static void pauseTask(String taskName,String groupName) throws SchedulerException{
		Scheduler scheduler = getScheduler();
		JobKey jobKey = JobKey.jobKey(taskName, groupName);
		
		scheduler.pauseTrigger(new TriggerKey(taskName, groupName));
//		scheduler.pauseJob(jobKey);
		
	}
	
	/**
	 * 重启计划任务
	 * @param taskName
	 * @param groupName
	 * @throws SchedulerException
	 */
	public static void resumeTask(String taskName,String groupName) throws SchedulerException{

		Scheduler scheduler = getScheduler();
		
		scheduler.resumeTrigger(new TriggerKey(taskName, groupName));
	}
	
	/**
	 * 删除计划任务
	 * @param taskName
	 * @param taskGroup
	 * @return
	 * @throws SchedulerException
	 */
	public static boolean deleteTask(String taskName, String taskGroup) throws SchedulerException {
		TriggerKey triggerKey = new TriggerKey(taskName, taskGroup);  
		
		Scheduler scheduler = getScheduler();
		scheduler.pauseTrigger(triggerKey);// 停止触发器
		return scheduler.unscheduleJob(triggerKey);// 移除触发器

	}

	public static Scheduler getScheduler(){
		 return ApplicationContextHolder.getBean(SchedulerFactoryBean.class).getScheduler();
	}


}

ApplicationContextHolder类 

public class ApplicationContextHolder implements ApplicationContextAware {
	private static ApplicationContext applicationContext;

	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		ApplicationContextHolder.applicationContext = applicationContext;
	}

	public static ApplicationContext getApplicationContext() {
		return applicationContext;
	}

	@SuppressWarnings("unchecked")
	public static <T> T getBean(String name) {
		return (T) getApplicationContext().getBean(name);
	}
	
	public static <T> T getBean(Class<T> clazz) {
		return (T) getApplicationContext().getBean(clazz);
	}

	public static void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck) {
		getApplicationContext().getAutowireCapableBeanFactory().autowireBeanProperties(existingBean, autowireMode, dependencyCheck);
	}


参考了这两篇文章
http://www.meiriyouke.net/?p=140

http://my.oschina.net/u/1177710/blog/284608

slipknotM_
关注
【SpringBoot】82、SpringBoot集成Quartz实现动态管理定时任务
Asurplus
06-29 3万+
Quartz 是一个开源的作业调度框架，它完全由 Java 写成，并设计用于 J2SE 和 J2EE 应用中。它提供了巨大的灵 活性而不牺牲简单性。你能够用它来为执行一个作业而创建简单的或复杂的调度。它有很多特征，如：数据库支持，集群，插件，EJB 作业预构 建，JavaMail 及其它，支持 cron-like 表达式等等
Quartz调度、终止执行的任务
08-07
使用Quartz调度任务，根据需要人为的终止某个任务，适用于很多常见的场景
C#--使用Quartz实现定时任务的暂停定时、恢复定时、关闭定时等操作
qq_46104221的博客
07-22 1901
基于Quartz3.0版本总结一些quartz定时任务的暂停、恢复、删除等操作。定时任务的暂停、删除等操作主要是基于JobKey或TriggerKey。
Quartz 定时任务
最新发布
qq_59308271的博客
07-24 1808
Quartz是一个定时任务调度框架；有三大核心部分组成，分别是Job，Trigger、Scheduler。。Job：任务，可以理解成你要做什么事，具体要执行的业务逻辑，比如：发送短信、同步数据、发送邮件等。JobDetail：基于Job，进一步包装，其中关联一个Job，并为Job指定更详细的属性，比如标识等，用于描述Job任务，(任务的名称、任务的分组) - ID。
quartz使用（二）任务的删除，停止，暂停，启动
毅香雪海的博客
02-27 9225
在上一篇文章中，介绍了quartz简单的使用方法，没有看过的可以查看https://editor.csdn.net/md/?articleId=102677404 这一篇介绍关于任务的启动停止这些操作，废话不多说。 任务启动停止 启动任务 void start() throws SchedulerException; // 启动任务 停止任务 void shutdown() t...
Quartz执行逻辑（七）任务的暂停和恢复
卷福。的博客
04-21 7090
Quartz执行逻辑（七）任务的暂停和恢复1.简介2.暂停与恢复任务2.1暂停任务2.2恢复任务 1.简介 前面在Quartz执行逻辑（一）中说到trigger的状态是WAITING的，会在目标时间被触发，所以暂停与恢复任务自然是修改了trigger的状态。 2.暂停与恢复任务 2.1暂停任务 暂停任务时通过调用Scheduler的pauseJob方法来实现这个操作。这个方法一直向下调用到了JobStoreSupport中的pauseJob方法。该方法中是对任务的trigger进行操作的，也证实了前面的猜想
Spring Quartz 动态暂停、恢复、修改定时任务
01-06
Spring Quartz 动态暂停、恢复、修改定时任务的一个demo，使用maven构建，框架采用spring springmvc jpa，数据库mysql，含数据库脚本，运行可用，页面访问地址http://localhost:8080/quartz_demo/quartz/list
定时任务quartz实现分组串行并行动态配置
05-06
Quartz提供了API接口和JMX支持，可以获取Job和Trigger的状态，以及进行暂停、恢复、删除等操作。 7. **持久化存储**：Quartz支持多种持久化策略，如内存、数据库等。选择合适的存储方式可以确保在服务器重启后仍能...
Springboot2.0.1整合Quartz动态定时任务
09-15
例如，添加任务的接口可以这样实现： ```java @PostMapping("/addJob") public Result addJob(@RequestBody JobInfo jobInfo) { // 保存任务信息到数据库 jobService.save(jobInfo); // 创建并添加Job和Trigger ...
Springboot整合Quartz实现定时任务数据库动态配置
03-17
用户可以通过API接口动态地添加、修改、暂停、恢复和删除定时任务，极大地提高了系统的灵活性和可维护性。这样的设计使得业务需求变化时，无需修改代码，只需调整数据库中的任务配置即可。同时，结合Spring Cloud ...
springboot整合quartz实现定时任务的动态修改，启动，暂停等操作
yyyy11119的博客
10-24 3485
什么是Quartz？一个定时任务调度框架，简单易用，功能强大可以使实现定时任务的。 在项目开发过程当中，某些定时任务，可能在运行一段时间之后，就不需要了，或者需要修改下定时任务的执行时间等等。 需要在代码当中进行修改然后重新打包发布，很麻烦。使用Quartz来实现的话不需要重新修改代码而达到要求。 springboot整合Quartz定时调度框架开发环境JDK版本1.8springboot版本：2...
任务调度开源框架Quartz动态添加、修改和删除定时任务
07-07
Quartz 是个开源的作业调度框架，为在 Java 应用程序中进行作业调度提供了简单却强大的机制。Quartz框架包含了调度器监听、作业和触发器监听。你可以配置作业和触发器监听为全局监听或者是特定于作业和触发器的监听。Quartz 允许开发人员根据时间间隔（或天）来调度作业。它实现了作业和触发器的多对多关系，还能把多个作业与不同的触发器关联。整合了 Quartz 的应用程序可以重用来自不同事件的作业，还可以为一个事件组合多个作业。并且还能和Spring配置整合使用。Quartz在功能上远远超越了JDK自带的Timer，很好很强大！
quartz动态添加、修改和删除定时任务
01-06
附件中实现了对quartz的动态添加、修改和删除定时任务，方便通过页面动态控制执行定时任务。
Spring 3整合Quartz 1.8实现定时任务三：动态暂停 恢复 修改和删除任务
07-22
Spring 3整合Quartz 1.8实现定时任务三：动态暂停 恢复 修改和删除任务 任务保存到数据库，系统启动时读取数据库，页面显示加载，并管理 注：spring3+quartz2动态任务调度，任务保存在内存中，页面显示动态管理版地址为http://download.csdn.net/detail/johnjobs/7646011
quartz(六)定时任务的暂停、关闭等操作说明
swimming_lu的博客
03-30 7768
定时任务的暂停、关闭等操作说明 基于quartz3.0版本总结一些quartz定时任务的暂停、恢复、删除等操作。 定时任务的删除等操作主要是基于JobKey或TriggerKey。 暂停Job: //通过JobName以及JobGroup获得JobKey JobKey jobKey = JobKey.jobKey("aaaa" + 1, JOB_GROUP_NAME); ...
Quartz的任务的临时启动和暂停和恢复
冷月宫主的专栏
03-13 997
http://topmanopensource.iteye.com/blog/1125753
防止IIS回收停止Job的处理(Quartz.net)
qq_18932003的博客
06-14 712
我们知道关闭、重启网站或者IIS程序池是会执行Application_End事件的，Application_End 事件后 就跟刚部署到IIS的站点一样，在发送第一个针对该 Web 应用程序的 Http 请求后，IIS 才会自动启动 Web 应用程序，既然IIS是因为程序闲置没有收到请求而回收进程的，那就在Application_End 事件里再提交一个请求给该 Web 应用程序，从而“激活”关闭的应用程序不就可以了？第二，GC并不是实时性的，这将会造成系统性能上的瓶颈和不确定性。
从Quartz数据库中删除cron trigger
wangcheng
09-22 2358
要删除quartz的cron类型的trigger，从qrtz_triggers表和qrtz_cron_triggers表中，删除对应的数据就可以
SpringBoot与Quartz集成：动态定时任务实战解析
Quartz是一个开源的作业调度框架，它提供了更复杂和精细的任务调度能力，如任务的暂停、恢复、删除和更新等。Quartz支持多种触发器（包括CronTrigger）以及任务之间的依赖关系，能够更好地满足多任务管理和动态配置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值