SpringBoot多任务Quartz动态管理Scheduler（只要一张表，动态启停任务）

最新推荐文章于 2024-06-26 17:22:19 发布

贤和兄

最新推荐文章于 2024-06-26 17:22:19 发布

阅读量1.3w

点赞数 2

分类专栏：我的经验总结文章标签： springboot quartz 定时

本文链接：https://blog.csdn.net/u010598111/article/details/85336634

版权

我的经验总结专栏收录该内容

107 篇文章 0 订阅

订阅专栏

前言：由于公司最近在开发新架构，需要对任务调度进行统一管理，旧的架构中采用的是spring内置的定时，存在一定的问题，而且每次修改定时之后需要重新启动应用，不是很好使，也不够强大，于是引入了quartz进行管理。具体处理如下

一、quartz简单介绍

1. 介绍
Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，是完全由java开发的一个开源的任务日程管理系统，“任务进度管理器”就是一个在预先确定（被纳入日程）的时间到达时，负责执行（或者通知）其他软件组件的系统。
Quartz用一个小Java库发布文件（.jar文件），这个库文件包含了所有Quartz核心功能。这些功能的主要接口(API)是Scheduler接口。它提供了简单的操作，例如：将任务纳入日程或者从日程中取消，开始/停止/暂停日程进度。
2. 定时器种类
Quartz 中五种类型的 Trigger：SimpleTrigger，CronTirgger，DateIntervalTrigger，NthIncludedDayTrigger和Calendar 类（ org.quartz.Calendar）。
最常用的：
SimpleTrigger：用来触发只需执行一次或者在给定时间触发并且重复N次且每次执行延迟一定时间的任务。
CronTrigger：按照日历触发，例如“每个周五”，每个月10日中午或者10：15分。
3. 存储方式
RAMJobStore和JDBCJobStore
对比：

类型   优点   缺点
RAMJobStore   不要外部数据库，配置容易，运行速度快   因为调度程序信息是存储在被分配给JVM的内存里面，所以，当应用程序停止运行时，所有调度信息将被丢失。另外因为存储到JVM内存里面，所以可以存储多少个Job和Trigger将会受到限制
JDBCJobStore   支持集群，因为所有的任务信息都会保存到数据库中，可以控制事物，还有就是如果应用服务器关闭或者重启，任务信息都不会丢失，并且可以恢复因服务器关闭或者重启而导致执行失败的任务   运行速度的快慢取决与连接数据库的快慢
4. 表关系和解释

表关系

解释

表名称   说明
qrtz_blob_triggers   Trigger作为Blob类型存储(用于Quartz用户用JDBC创建他们自己定制的Trigger类型，JobStore 并不知道如何存储实例的时候)
qrtz_calendars   以Blob类型存储Quartz的Calendar日历信息， quartz可配置一个日历来指定一个时间范围
qrtz_cron_triggers   存储Cron Trigger，包括Cron表达式和时区信息。
qrtz_fired_triggers   存储与已触发的Trigger相关的状态信息，以及相联Job的执行信息
qrtz_job_details   存储每一个已配置的Job的详细信息
qrtz_locks   存储程序的非观锁的信息(假如使用了悲观锁)
qrtz_paused_trigger_graps   存储已暂停的Trigger组的信息
qrtz_scheduler_state   存储少量的有关 Scheduler的状态信息，和别的 Scheduler 实例(假如是用于一个集群中)
qrtz_simple_triggers   存储简单的 Trigger，包括重复次数，间隔，以及已触的次数
qrtz_triggers   存储已配置的 Trigger的信息
qrzt_simprop_triggers
5. 核心类和关系

核心类
（1）核心类
QuartzSchedulerThread ：负责执行向QuartzScheduler注册的触发Trigger的工作的线程。
ThreadPool：Scheduler使用一个线程池作为任务运行的基础设施，任务通过共享线程池中的线程提供运行效率。
QuartzSchedulerResources：包含创建QuartzScheduler实例所需的所有资源（JobStore，ThreadPool等）。
SchedulerFactory ：提供用于获取调度程序实例的客户端可用句柄的机制。
JobStore：通过类实现的接口，这些类要为org.quartz.core.QuartzScheduler的使用提供一个org.quartz.Job和org.quartz.Trigger存储机制。作业和触发器的存储应该以其名称和组的组合为唯一性。
QuartzScheduler ：这是Quartz的核心，它是org.quartz.Scheduler接口的间接实现，包含调度org.quartz.Jobs，注册org.quartz.JobListener实例等的方法。
Scheduler ：这是Quartz Scheduler的主要接口，代表一个独立运行容器。调度程序维护JobDetails和触发器的注册表。一旦注册，调度程序负责执行作业，当他们的相关联的触发器触发（当他们的预定时间到达时）。
Trigger ：具有所有触发器通用属性的基本接口，描述了job执行的时间出发规则。 - 使用TriggerBuilder实例化实际触发器。
JobDetail ：传递给定作业实例的详细信息属性。 JobDetails将使用JobBuilder创建/定义。
Job：要由表示要执行的“作业”的类实现的接口。只有一个方法 void execute(jobExecutionContext context)
(jobExecutionContext 提供调度上下文各种信息，运行时数据保存在jobDataMap中)
Job有个子接口StatefulJob ,代表有状态任务。
有状态任务不可并发，前次任务没有执行完，后面任务处于阻塞等到。
注：在网上查看了各种贴子、文章，结合本身的业务，发现如此多的表对我们确实用处不大，然后产生一个想法，是否不需要这么多表的情况下也能满足我现有的功能需求呢？于是，做了如下的配置开发.......

二、引入quartz开发

1、建表

CREATE TABLE `base_quartz_config` (
  `configid` varchar(64) COLLATE utf8_bin NOT NULL,
  `quarta_name` varchar(100) COLLATE utf8_bin DEFAULT NULL COMMENT '任务名称',
  `quarta_group` varchar(100) COLLATE utf8_bin DEFAULT NULL COMMENT '任务组',
  `status` int(11) DEFAULT NULL COMMENT '状态',
  `quartz_class` varchar(200) COLLATE utf8_bin DEFAULT NULL COMMENT '类全名',
  `remark` varchar(200) COLLATE utf8_bin DEFAULT NULL COMMENT '备注',
  `createuserid` varchar(64) COLLATE utf8_bin DEFAULT NULL COMMENT '创建人',
  `expression` varchar(64) COLLATE utf8_bin DEFAULT NULL COMMENT '表达式',
  `createtime` datetime DEFAULT NULL,
  PRIMARY KEY (`configid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;

2、引入jar包

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-quartz</artifactId>
		</dependency>

整体目录结构如下

3、具体代码

创建调度工厂

package com.app.base.modules.common.quartzutil;

import java.util.List;

import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.TriggerBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

import com.app.base.modules.common.entity.BaseQuartzConfigEntity;
import com.app.base.modules.common.service.BaseQuartzConfigService;
import com.app.tool.core.util.StringUtil;

/**
 * 调度工厂类
 */
@Service("MySchedulerFactory")
@Component
public class MySchedulerFactory {
	private static Logger logger = LoggerFactory.getLogger(MySchedulerFactory.class);
	@Autowired
	SchedulerFactoryBean schedulerFactoryBean;

	/**
	 * 任务配置读取服务
	 */
	@Autowired
	private BaseQuartzConfigService baseQuartzConfigService;

	public void scheduleJobs() throws SchedulerException {
		Scheduler scheduler = getScheduler();
		// 为了避免org.quartz.ObjectAlreadyExistsException，在执行前将scheduler进行清理
		scheduler.clear();
		startJob(scheduler);
	}

	/**
	 * 获取scheduler
	 * @return
	 * @author pangxianhe
	 * @date 2018年12月27日
	 */
	private Scheduler getScheduler() {
		return schedulerFactoryBean.getScheduler();
	}

	/**
	 * 项目启动 开启任务
	 * @param scheduler
	 * @author pangxianhe
	 * @date 2018年12月27日
	 */
	private void startJob(Scheduler scheduler) {
		try {
			List<BaseQuartzConfigEntity> jobList = baseQuartzConfigService.findAll();
			for (BaseQuartzConfigEntity config : jobList) {
				try {
					// 1-暂停的任务 0-正常运行任务
					if (1l == config.getStatus()) {
						continue;
					}
					String classz = config.getQuartzClass();
					if (StringUtil.isNotBlank(classz)) {
						@SuppressWarnings("unchecked")
						Class<? extends Job> clazz = (Class<? extends Job>) Class.forName(classz);
						JobDetail jobDetail = JobBuilder.newJob(clazz).withIdentity(config.getConfigid(), config.getQuartaGroup())
								.build();
						CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(config.getExpression());
						CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity(config.getConfigid(), config.getQuartaGroup())
								.withSchedule(scheduleBuilder).build();
						scheduler.scheduleJob(jobDetail, cronTrigger);
					}
				} catch (Exception e) {
					logger.info("定时启动异常：" + config.getQuartaName() + " 异常信息：" + e.getMessage());
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 任务暂停
	 * @param id
	 * @throws Exception
	 * @author pangxianhe
	 * @date 2018年12月27日
	 */
	public void pauseJob(String id) throws Exception {
		Scheduler scheduler = getScheduler();
		BaseQuartzConfigEntity QuartzConfig = baseQuartzConfigService.get(String.valueOf(id));
		JobKey jobKey = JobKey.jobKey(QuartzConfig.getConfigid(), QuartzConfig.getQuartaGroup());
		scheduler.deleteJob(jobKey);
	}

	/**
	 * 任务恢复
	 * @param id
	 * @throws Exception
	 * @author pangxianhe
	 * @date 2018年12月27日
	 */
	public void resumeJob(String id) throws Exception {
		Scheduler scheduler = getScheduler();
		BaseQuartzConfigEntity QuartzConfig = baseQuartzConfigService.get(String.valueOf(id));
		JobKey jobKey = JobKey.jobKey(QuartzConfig.getConfigid(), QuartzConfig.getQuartaGroup());
		Class<? extends Job> clazz = (Class<? extends Job>) Class.forName(QuartzConfig.getQuartzClass());
		JobDetail jobDetail1 = scheduler.getJobDetail(jobKey);
		if (jobDetail1 == null) {
			JobDetail jobDetail = JobBuilder.newJob(clazz).withIdentity(QuartzConfig.getConfigid(), QuartzConfig.getQuartaGroup())
					.build();
			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(QuartzConfig.getExpression());
			CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity(QuartzConfig.getConfigid(), QuartzConfig.getQuartaGroup())
					.withSchedule(scheduleBuilder).build();
			scheduler.scheduleJob(jobDetail, cronTrigger);
		} else {
			scheduler.resumeJob(jobKey);
		}
	}
}

创建任务工厂

package com.app.base.modules.common.quartzutil;

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.AdaptableJobFactory;
import org.springframework.stereotype.Component;

@Component
public class MyJobFactory extends AdaptableJobFactory {

    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;

    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        // 调用父类的方法
        Object jobInstance = super.createJobInstance(bundle);
        // 进行注入
        capableBeanFactory.autowireBean(jobInstance);
        return jobInstance;
    }
}

向spring容器注入调度任务配置信息

package com.app.base.modules.common.quartzutil;

import org.quartz.SchedulerException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

/**
 * 定时任务运行工厂类
 */
@Configuration
public class StartSchedulerListener implements ApplicationListener<ContextRefreshedEvent> {
    @Autowired
    public MySchedulerFactory mySchedulerFactory;
    @Autowired
    private MyJobFactory myJobFactory;
    // springboot 启动监听
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        try {
            mySchedulerFactory.scheduleJobs();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    //注入SchedulerFactoryBean
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() {
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        schedulerFactoryBean.setJobFactory(myJobFactory);
        return schedulerFactoryBean;
    }

}

监听

package com.app.base.modules.common.quartzutil;

import org.quartz.SchedulerException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

/**
 * 定时任务运行工厂类
 */
@Configuration
public class StartSchedulerListener implements ApplicationListener<ContextRefreshedEvent> {
    @Autowired
    public MySchedulerFactory mySchedulerFactory;
    @Autowired
    private MyJobFactory myJobFactory;
   /**
    * springboot 启动监听
    */
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        try {
            mySchedulerFactory.scheduleJobs();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    //注入SchedulerFactoryBean
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() {
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        schedulerFactoryBean.setJobFactory(myJobFactory);
        return schedulerFactoryBean;
    }

}

测试类

package com.app.base.modules.common.quartzutil;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.stereotype.Component;

@Configuration
@Component
@EnableScheduling
public class ScheduleTask1 implements Job {
 
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        try {
            System.out.print("任务执行1 :");
            System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
 
        } catch (Exception e) {
        	System.out.println(e.getMessage());
        }
        }
}

在线修改定时运行与停止管理

/**
     * 修改定时任务
     * @param data
     * @return
     * @throws Exception 
     * @author pangxianhe
     * @date 2018年12月28日
     */
    @PostMapping("/changestatus")
    @Log(title = "修改定时任务", action = BusinessType.INSERT)
    @ApiOperation(value = "修改定时任务", notes = "修改定时任务")
    public Result changestatus(@RequestBody Map<String, Object> data){
    	
    	try {
			String status = (String) data.get("status");
			String configid = (String) data.get("configid");
			if (StringUtil.isNotBlank(configid)) {
				BaseQuartzConfigEntity quartzConfigEntity = baseQuartzConfigService.get(configid);
				if ("0".equals(status)) {
					//修改为0，并且恢复运行
					quartzConfigEntity.setStatus(0);
					mySchedulerFactory.resumeJob(configid);
				}else {
					//修改为1，并且暂停
					quartzConfigEntity.setStatus(1);
					mySchedulerFactory.pauseJob(configid);
				}
				baseQuartzConfigService.update(quartzConfigEntity);
			}
			  return Result.success().put("data","success");
		} catch (Exception e) {
			  return Result.error().put("data","fail");
		}
    }

文件目录如：

效果如下：

完毕，以上如有疑问请评论沟通，互相学习，谢谢。

贤和兄

关注

2
点赞
踩
52

收藏

觉得还不错? 一键收藏
12
评论
SpringBoot多任务Quartz动态管理Scheduler（只要一张表，动态启停任务）

前言：由于公司最近在开发新架构，需要对任务调度进行统一管理，旧的架构中采用的是spring内置的定时，存在一定的问题，而且每次修改定时之后需要重新启动应用，不是很好使，也不够强大，于是引入了quartz进行管理。具体处理如下一、quartz简单介绍1. 介绍 Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，是完全由java开发的一个...
复制链接

扫一扫

专栏目录