Quartz从学习到踩坑到成功使用

最新推荐文章于 2023-08-29 16:37:04 发布

ChriszStathum

最新推荐文章于 2023-08-29 16:37:04 发布

阅读量348

点赞数

文章标签： quartz

本文链接：https://blog.csdn.net/weixin_43866922/article/details/104000495

版权

Quartz从学习到使用

Quartz的功能

Quartz的功能

Quartz是一个开源的定时作业框架,它可以用来定时去执行多个任务,只要按约定好的规则保存好Job和Trigger的相关参数,就可以非常方便直观地去控制任务的执行。

Quartz的实现

Quartz的组成主要为三部分:
1.调度器：Quartz框架的核心是调度器。调度器负责管理Quartz应用运行时环境。调度器不是靠自己做所有的工作，而是依赖框架内一些非常重要的部件。Quartz不仅仅是线程和线程池管理。为确保可伸缩性，Quartz采用了基于多线程的架构。启动时，框架初始化一套worker线程，这套线程被调度器用来执行预定的作业。这就是Quartz怎样能并发运行多个作业的原理。Quartz依赖一套松耦合的线程池管理部件来管理线程环境。
2.任务：这个很简单，就是我们自己编写的业务逻辑，交给quartz帮我们执行。
3.触发器：简单的讲就是调度作业，什么时候开始执行，什么时候结束执行。

调度任务流程

以下是实现一个定时任务生成的代码

	@Transactional
	public void addJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName, Class jobClass, String cron, Map<String, Object> params, Date startTime) {
		try {
	       // 任务名，任务组，任务执行类
			JobDetail job = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
			// 任务参数
			job.getJobDataMap().putAll(params);
			// 触发器
			TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
			// 触发器名,触发器组
			triggerBuilder.withIdentity(triggerName, triggerGroupName);
			triggerBuilder.startAt(startTime);
			// 触发器时间设定
			triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
			// 创建触发器对象
			CronTrigger trigger = (CronTrigger) triggerBuilder.build();
			// 调度容器设置任务和触发器
			scheduler.scheduleJob(job, trigger);
			// 启动
			if (!scheduler.isShutdown()) {
				scheduler.start();
				}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}

这里是调用addJob生成任务的示例,quartz是用反射类的方法去找到需要执行的任务。

像MongoTemplate这样需要new的实例,都可以通过map传给job实现类里,这样可以很好地控制连接数,如果在job实现类中new示例的话,那有一个问题是在连接信息不同的情况下不好去分辨到底想要new哪个实例,另一个问题就是MongoDB无法手动控制关闭连接(如果有大佬知道如何手动关闭,跪求指教),只能设置超时关闭,如果创建连接速度大于关闭速度的话必然会OOM

quartzManager.addJob(jobName, jobGroupName, triggerGroupName, triggerName, Class.forName("com.tianfu.system.agent.jobs.DayEnergyCalc"), cron, map, startTime);

以下是一个实现Job接口的实现类

@Component
public class ExecuteRulesJob implements Job {
	@Override
	public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
	  System.out.println("hellow world");
	}

Quartz任务管理类的使用示例,封装类代码放在最后

@Service
public class QuartzServiceImpl implements IQuartzService {
	@Autowired
	private SchedulerFactoryBean schedulerFactoryBean;
	@Override
	@SneakyThrows
	public void StartSchedulerByDayEnergy(String jobName, String jobGroupName,String triggerName, String triggerGroupName, String cron,String tenantCode, String targetApp,Date startTime,Integer SourceType) {
		long first = TimeUtil.getSimpledateParse(TimeUtil.getNextExecTime(cron,2).get(0)).getTime()/1000;
		long second =TimeUtil.getSimpledateParse(TimeUtil.getNextExecTime(cron,2).get(1)).getTime()/1000;
		Integer timerCronInterval=new Long(second-first).intValue();
		Map<String,Object> map=new HashMap<>();
		map.put("tenantCode",tenantCode);
		map.put("targetApp",targetApp);
		map.put("timerCronInterval",timerCronInterval);
		Scheduler scheduler= schedulerFactoryBean.getScheduler();
		QuartzManager quartzManager=new QuartzManager(scheduler);
		String sourceType= TDatabaseType.getDatabaseType(SourceType).toString();
		if (sourceType== TDatabaseType.MySql.getValue()) {
			quartzManager.addJob(jobName, jobGroupName, triggerGroupName, triggerName, Class.forName("com.tianfu.system.agent.jobs.ExecuteRulesJob"), cron, map, startTime);
		}
		else if (sourceType==TDatabaseType.MongoDB.getValue())
		{
			quartzManager.addJob(jobName, jobGroupName, triggerGroupName, triggerName, Class.forName("com.tianfu.system.agent.jobs.ExecuteRulesByCommWay"), cron, map, startTime);
		}
	}


## 无法在Job实现类中使用@Autowired注入Servivce的解决方案
Quartz的JobFactory是不交给springboot管理的,因此在它的实现方法里就无法注入Spring的Service了,解决方法就是重写一下JobFactory里的方法,把它交给Spring管理

```java
@Component
public class JobFactory extends AdaptableJobFactory {
	@Autowired
	private AutowireCapableBeanFactory factory;

	public JobFactory(AutowireCapableBeanFactory factory){
		this.factory=factory;
	}

	@Override
	@SneakyThrows
	protected Object createJobInstance(TriggerFiredBundle bundle){
		// 实例化对象
		Object job = super.createJobInstance(bundle);
		// 进行注入（Spring管理该Bean）
		factory.autowireBean(job);
		//返回对象
		return job;
	}
}

@Configuration
public class QuartzConfig {

	private JobFactory jobFactory;
	public QuartzConfig(JobFactory jobFactory){
		this.jobFactory = jobFactory;
	}
	/**
	 * 配置SchedulerFactoryBean
	 *
	 * 将一个方法产生为Bean并交给Spring容器管理
	 */
	@Bean(name="SchedulerFactory")
	@SneakyThrows
	public SchedulerFactoryBean schedulerFactoryBean() {
		SchedulerFactoryBean factory = new SchedulerFactoryBean();
		factory.setAutoStartup(true);
//注意这里是重点
		factory.setJobFactory(jobFactory);
		return factory;
	}


	@Bean(name="scheduler")
	public Scheduler scheduler(){
		return schedulerFactoryBean().getScheduler();
	}
}

创建一个包写上这两个类就可以确保Service正常注入使用了。

任务调度管理类

package com.tianfu.system.agent.quartzManager;

import org.quartz.*;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.Map;

@Service
public class QuartzManager {

	private Scheduler scheduler;

	public QuartzManager(Scheduler scheduler) {
		this.scheduler = scheduler;
	}

	/**
	 * 添加一个定时任务
	 *
	 * @param jobName          任务名
	 * @param jobGroupName     任务组名
	 * @param triggerName      触发器名
	 * @param triggerGroupName 触发器组名
	 * @param jobClass         任务
	 * @param cron             时间设置，参考quartz说明文档
	 */
	@SuppressWarnings({"unchecked", "rawtypes"})
	@Transactional
	public void addJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName, Class jobClass, String cron, Map<String, Object> params, Date startTime) {
		try {
			// 任务名，任务组，任务执行类
			JobDetail job = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
			// 任务参数
			job.getJobDataMap().putAll(params);
			// 触发器
			TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
			// 触发器名,触发器组
			triggerBuilder.withIdentity(triggerName, triggerGroupName);
			triggerBuilder.startAt(startTime);
			// 触发器时间设定
			triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
			// 创建Trigger对象
			CronTrigger trigger = (CronTrigger) triggerBuilder.build();
			// 调度容器设置JobDetail和Trigger
			scheduler.scheduleJob(job, trigger);
			// 启动
			if (!scheduler.isShutdown()) {
				scheduler.start();

			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 修改一个任务的触发时间
	 *
	 * @param triggerName      触发器名
	 * @param triggerGroupName 触发器组名
	 * @param cron             时间设置，参考quartz说明文档
	 */
	public void modifyJobTime(String triggerName, String triggerGroupName, String cron) {
		try {
			TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
			CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
			if (trigger == null) {
				return;
			}

			String oldTime = trigger.getCronExpression();
			if (!oldTime.equalsIgnoreCase(cron)) {
				// 触发器
				TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
				// 触发器名,触发器组
				triggerBuilder.withIdentity(triggerName, triggerGroupName);
				triggerBuilder.startNow();
				// 触发器时间设定
				triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
				// 创建Trigger对象
				trigger = (CronTrigger) triggerBuilder.build();
				// 方式一 ：修改一个任务的触发时间
				scheduler.rescheduleJob(triggerKey, trigger);

			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 移除一个任务
	 *
	 * @param jobName          任务名
	 * @param jobGroupName     任务组名
	 * @param triggerName      触发器名
	 * @param triggerGroupName 触发器组名
	 */
	public void removeJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName) {
		try {
			TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
			// 停止触发器
			scheduler.pauseTrigger(triggerKey);
			// 移除触发器
			scheduler.unscheduleJob(triggerKey);
			// 删除任务
			scheduler.deleteJob(JobKey.jobKey(jobName, jobGroupName));
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 获取任务是否存在
	 * <p>
	 * STATE_BLOCKED 4 阻塞
	 * STATE_COMPLETE 2 完成
	 * STATE_ERROR 3 错误
	 * STATE_NONE -1 不存在
	 * STATE_NORMAL 0 正常
	 * STATE_PAUSED 1 暂停
	 */
	public Boolean notExists(String triggerName, String triggerGroupName) {
		try {
			return scheduler.getTriggerState(TriggerKey.triggerKey(triggerName, triggerGroupName)) == Trigger.TriggerState.NONE;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
}

ChriszStathum

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Quartz从学习到踩坑到成功使用

Quartz从学习到使用Quartz的功能Quartz的实现对于Quartz任务增删改的封装方法无法在Job实现类中使用@Autowired注入Servivce的解决方案Quartz使用的封装类Quartz封装类的使用示例Quartz的功能Quartz是一个开源的定时作业框架,它可以用来定时去执行多个任务,只要按约定好的规则保存好Job和Trigger的相关参数,就可以非常方便直观地去控制任务...
复制链接

扫一扫