springboot+quartz整合做动态定时任务

背景：

        公司有个动态组的需求，就是从数据库查出来cron表达式，然后同时执行。

1、 首先导入需要的maven

<!-- SpringBoot 整合 Quartz 定时任务 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-quartz</artifactId>
			<version>2.3.5.RELEASE</version>
		</dependency>

2、动态定时任务工具类

package com.maiyue.uia.biz.task;

import org.quartz.*;

public class QuartzUtils {

	/**
	 * 创建定时任务 定时任务创建之后默认启动状态
	 * @param scheduler   调度器
	 * @param quartzBean  定时任务信息类
	 * @throws Exception
	 */
	public static void createScheduleJob(Scheduler scheduler, QuartzBean quartzBean){
		try {
			//获取到定时任务的执行类  必须是类的绝对路径名称
			//定时任务类需要是job类的具体实现 QuartzJobBean是job的抽象类。
			Class<? extends Job> jobClass = (Class<? extends Job>) Class.forName(quartzBean.getJobClass());
			// 构建定时任务信息
			JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(quartzBean.getJobName()).build();
			// 设置定时任务执行方式
			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(quartzBean.getCronExpression());
			// 构建触发器trigger
			CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(quartzBean.getJobName()).withSchedule(scheduleBuilder).build();
			scheduler.scheduleJob(jobDetail, trigger);
		} catch (ClassNotFoundException e) {
			System.out.println("定时任务类路径出错：请输入类的绝对路径");
		} catch (SchedulerException e) {
			System.out.println("创建定时任务出错："+e.getMessage());
		}
	}

	/**
	 * 根据任务名称暂停定时任务
	 * @param scheduler  调度器
	 * @param jobName    定时任务名称
	 * @throws SchedulerException
	 */
	public static void pauseScheduleJob(Scheduler scheduler, String jobName){
		JobKey jobKey = JobKey.jobKey(jobName);
		try {
			scheduler.pauseJob(jobKey);
		} catch (SchedulerException e) {
			System.out.println("暂停定时任务出错："+e.getMessage());
		}
	}

	/**
	 * 根据任务名称恢复定时任务
	 * @param scheduler  调度器
	 * @param jobName    定时任务名称
	 * @throws SchedulerException
	 */
	public static void resumeScheduleJob(Scheduler scheduler, String jobName) {
		JobKey jobKey = JobKey.jobKey(jobName);
		try {
			scheduler.resumeJob(jobKey);
		} catch (SchedulerException e) {
			System.out.println("启动定时任务出错："+e.getMessage());
		}
	}

	/**
	 * 根据任务名称立即运行一次定时任务
	 * @param scheduler     调度器
	 * @param jobName       定时任务名称
	 * @throws SchedulerException
	 */
	public static void runOnce(Scheduler scheduler, String jobName){
		JobKey jobKey = JobKey.jobKey(jobName);
		try {
			scheduler.triggerJob(jobKey);
		} catch (SchedulerException e) {
			System.out.println("运行定时任务出错："+e.getMessage());
		}
	}

	/**
	 * 更新定时任务
	 * @param scheduler   调度器
	 * @param quartzBean  定时任务信息类
	 * @throws SchedulerException
	 */
	public static void updateScheduleJob(Scheduler scheduler, QuartzBean quartzBean)  {
		try {
			//获取到对应任务的触发器
			TriggerKey triggerKey = TriggerKey.triggerKey(quartzBean.getJobName());
			//设置定时任务执行方式
			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(quartzBean.getCronExpression());
			//重新构建任务的触发器trigger
			CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
			trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
			//重置对应的job
			scheduler.rescheduleJob(triggerKey, trigger);
		} catch (SchedulerException e) {
			System.out.println("更新定时任务出错："+e.getMessage());
		}
	}

	/**
	 * 根据定时任务名称从调度器当中删除定时任务
	 * @param scheduler 调度器
	 * @param jobName   定时任务名称
	 * @throws SchedulerException
	 */
	public static void deleteScheduleJob(Scheduler scheduler, String jobName) {
		JobKey jobKey = JobKey.jobKey(jobName);
		try {
			scheduler.deleteJob(jobKey);
		} catch (SchedulerException e) {
			System.out.println("删除定时任务出错："+e.getMessage());
		}
	}
}

3、具体执行任务

package com.maiyue.uia.biz.task;


import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.maiyue.uia.api.group.entity.GroupMember;
import com.maiyue.uia.api.group.entity.Groups;
import com.maiyue.uia.biz.modular.group.service.GroupMemberService;
import com.maiyue.uia.biz.modular.group.service.GroupsService;
import lombok.extern.slf4j.Slf4j;
import org.quartz.JobExecutionContext;
import org.springframework.scheduling.quartz.QuartzJobBean;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

@Slf4j
public class GroupSchedulerTask extends QuartzJobBean {
	

	@Transactional(rollbackFor = Exception.class)
	@Override
	protected void executeInternal(JobExecutionContext context) {
		System.out.println("具体的执行代码");
	}
}

需要注意的是我这里是多个任务进行的操作是也一样的，所以就一个具体的执行类

4、将cron查询出来，加入动态任务组里面。项目启动完成后，将所有的从数据库查出来的cron表达式加入到动态组里面。

package com.maiyue.uia.biz.task;

import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.maiyue.uia.api.group.entity.Groups;
import com.maiyue.uia.biz.modular.group.service.GroupsService;
import org.quartz.Scheduler;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.List;

@Component
public class GroupTask {

	private final static String _url="com.maiyue.uia.biz.task.GroupSchedulerTask";

	@Resource
	private Scheduler scheduler;

	@Resource
	private GroupsService groupsService;

	/**
	 * 项目启动后，依赖关系加载完执行
	 */
	@PostConstruct
	public void dynamicGroupTask(){
		List<Groups> list = groupsService.list(Wrappers.<Groups>query().lambda().eq(Groups::getDynamic, "1"));
		if(!CollectionUtils.isEmpty(list)){
			list.forEach(e->{
				QuartzBean quartzBean = new QuartzBean();
				/**
				 * 执行类下的方法
				 */
				quartzBean.setJobClass(_url);
				/**
				 * 该任务在组中的名称
				 */
				quartzBean.setJobName(e.getResumeTime());
				/**
				 * 定时表达式
				 */
				quartzBean.setCronExpression(e.getResumeTime());
				QuartzUtils.createScheduleJob(scheduler,quartzBean);
			});
		}
	}
}