Spring+Mybatis +Quartz 实现定时任务管理

任务要求：通过开源任务调度框架Quartz,实现定时任务的添加、修改、删除、暂停、恢复和分页查询功能。

第一步:base 模块添加quartz jar包依赖：

	<!-- 定时任务框架  --> 
		<dependency> 
			<groupId>org.quartz-scheduler</groupId> 
			<artifactId>quartz</artifactId> 
			<version>2.3.0</version> 
		</dependency>

第二步：新增Quartz配置类对象：SchedulerConfig.java

import java.io.IOException; 
import java.util.Properties; 
 
import org.quartz.Scheduler; 
import org.quartz.ee.servlet.QuartzInitializerListener; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.beans.factory.config.PropertiesFactoryBean; 
import org.springframework.context.annotation.Bean; 
import org.springframework.context.annotation.Configuration; 
import org.springframework.core.io.ClassPathResource; 
import org.springframework.scheduling.quartz.SchedulerFactoryBean; 
 
import com.***.ucas.job.factory.CustomerJobFactory; 
 
@Configuration 
public class SchedulerConfig { 
	@Autowired 
	private CustomerJobFactory jobFactory; 
 
	@Bean 
	public SchedulerFactoryBean schedulerFactoryBean() throws IOException { 
		SchedulerFactoryBean factory = new SchedulerFactoryBean(); 
		factory.setOverwriteExistingJobs(true); 
		// 延时启动 
		factory.setStartupDelay(20); 
 
		// 加载quartz数据源配置 
		factory.setQuartzProperties(quartzProperties()); 
 
		// 自定义Job Factory，用于Spring注入 
		factory.setJobFactory(jobFactory); 
		return factory; 
	} 
 
	@Bean 
	public Properties quartzProperties() throws IOException { 
		PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean(); 
		propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties")); 
		// 在quartz.properties中的属性被读取并注入后再初始化对象 
		propertiesFactoryBean.afterPropertiesSet(); 
		return propertiesFactoryBean.getObject(); 
	} 
 
	/* 
	 * quartz初始化监听器 
	 */ 
	@Bean 
	public QuartzInitializerListener executorListener() { 
		return new QuartzInitializerListener(); 
	} 
 
	/* 
	 * 通过SchedulerFactoryBean获取Scheduler的实例 
	 */ 
	@Bean(name = "scheduler") 
	public Scheduler scheduler() throws Exception { 
		return schedulerFactoryBean().getScheduler(); 
	} 
}

自定义定时任务工厂:CustomerJobFactory.java

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 CustomerJobFactory extends AdaptableJobFactory { 
	 @Autowired 
	 private AutowireCapableBeanFactory capableBeanFactory; 
 
	@Override 
	protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception { 
		// 调用父类的方法 
        Object jobInstance = super.createJobInstance(bundle); 
        // 进行注入 
        capableBeanFactory.autowireBean(jobInstance); 
        return jobInstance; 
	} 
}

三、添加Quartz的配置文件：在service模块的src/main/resource文件夹下新建quartz.properties 配置文件，配置文件的内容如下：

# 固定前缀org.quartz 
# 主要分为scheduler、threadPool、jobStore、plugin等部分 
org.quartz.scheduler.instanceName = DefaultQuartzScheduler 
org.quartz.scheduler.rmi.export = false 
org.quartz.scheduler.rmi.proxy = false 
org.quartz.scheduler.wrapJobExecutionInUserTransaction = false 
 
# 实例化ThreadPool时，使用的线程类为SimpleThreadPool 
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool 
 
# threadCount和threadPriority将以setter的形式注入ThreadPool实例 
# 并发个数 
org.quartz.threadPool.threadCount = 5 
# 优先级 
org.quartz.threadPool.threadPriority = 5 
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true 
org.quartz.jobStore.misfireThreshold = 5000 
 
 
#MySQL 持久化 
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX 
# 表名前缀 
org.quartz.jobStore.tablePrefix = qrtz_ 
# 指定数据库 
org.quartz.jobStore.dataSource = ucas 
# 指定mysql 驱动 
org.quartz.dataSource.ucas.driver = com.mysql.cj.jdbc.Driver 
# 数据库连接地址 
org.quartz.dataSource.ucas.URL = jdbc:mysql://192.168.*.**:3306/ucas?serverTimezone=UTC&useSSL=false&allowPublicKeyRetrieval=true&allowMultiQueries=true 
# 数据库账户 
org.quartz.dataSource.ucas.user = root 
# 数据库密码 
org.quartz.dataSource.ucas.password = ****** 
# 配置最大连接数 
org.quartz.dataSource.ucas.maxConnections = 10

四、自定义定时任务对应的实体对象：SysCron.java

import java.util.Date; 
 
import com.***.common.model.BaseModel; 
 
@SuppressWarnings("serial") 
public class SysCron extends BaseModel { 
    private String id; 
 
    private String jobName; 
 
    private String jobDescription; 
 
    private String jobGroupName; 
 
    private String jobClassName; 
 
    private String triggerName; 
 
    private String triggerGroupName; 
 
    private String prevFireTime; 
 
    private String nextFireTime; 
 
    private String cronExpression; 
 
    private String triggerState; 
 
    public String getId() { 
        return id; 
    } 
 
    public void setId(String id) { 
        this.id = id == null ? null : id.trim(); 
    } 
 
    public String getJobName() { 
        return jobName; 
    } 
 
    public void setJobName(String jobName) { 
        this.jobName = jobName == null ? null : jobName.trim(); 
    } 
 
    public String getJobDescription() { 
        return jobDescription; 
    } 
 
    public void setJobDescription(String jobDescription) { 
        this.jobDescription = jobDescription == null ? null : jobDescription.trim(); 
    } 
 
    public String getJobGroupName() { 
        return jobGroupName; 
    } 
 
    public void setJobGroupName(String jobGroupName) { 
        this.jobGroupName = jobGroupName == null ? null : jobGroupName.trim(); 
    } 
 
    public String getJobClassName() { 
        return jobClassName; 
    } 
 
    public void setJobClassName(String jobClassName) { 
        this.jobClassName = jobClassName == null ? null : jobClassName.trim(); 
    } 
 
    public String getTriggerName() { 
        return triggerName; 
    } 
 
    public void setTriggerName(String triggerName) { 
        this.triggerName = triggerName == null ? null : triggerName.trim(); 
    } 
 
    public String getTriggerGroupName() { 
        return triggerGroupName; 
    } 
 
    public void setTriggerGroupName(String triggerGroupName) { 
        this.triggerGroupName = triggerGroupName == null ? null : triggerGroupName.trim(); 
    } 
 
    public String getPrevFireTime() { 
        return prevFireTime; 
    } 
 
    public void setPrevFireTime(String prevFireTime) { 
        this.prevFireTime = prevFireTime; 
    } 
 
    public String getNextFireTime() { 
        return nextFireTime; 
    } 
 
    public void setNextFireTime(String nextFireTime) { 
        this.nextFireTime = nextFireTime; 
    } 
 
    public String getCronExpression() { 
        return cronExpression; 
    } 
 
    public void setCronExpression(String cronExpression) { 
        this.cronExpression = cronExpression == null ? null : cronExpression.trim(); 
    } 
 
    public String getTriggerState() { 
        return triggerState; 
    } 
 
    public void setTriggerState(String triggerState) { 
        this.triggerState = triggerState == null ? null : triggerState.trim(); 
    } 
}

自定义接口服务层：SysCronService.java

import java.util.List; 
import java.util.Map; 
import com.***.common.model.PageParam; 
import com.***.common.page.PageData; 
import com.***.ucas.domain.SysCron; 
 
public interface SysCronService{ 
	 
	// 全部查询 
	List<SysCron> selectAll(Map<String,Object> parame); 
	//分页查询 
	PageData<SysCron> selectAllPage(Map<String,Object> parame, PageParam rb); 
	// 添加定时任务 
	public boolean addSysCron(SysCron entity); 
	// 更新定时任务 
	public boolean updateSysCron(SysCron entity); 
	// 删除定时任务 
	public boolean deleteSysCron(SysCron entity); 
	// 暂时定时任务 
	public boolean pauseSysCron(SysCron entity); 
	// 恢复定时任务 
	public boolean resumeJob(SysCron entity); 
} 

自定义接口服务实现层：SysCronServiceImpl .java （核心代码：实现定时任务新增、修改、暂停、恢复和删除功能）

import java.util.List; 
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.TriggerBuilder; 
import org.quartz.TriggerKey; 
import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.stereotype.Service; 
import com.***.common.job.BaseJob; 
import com.***.common.model.PageParam; 
import com.***.common.page.PageData; 
import com.***.ucas.api.SysCronService; 
import com.***.ucas.domain.SysCron; 
import com.***.ucas.mapper.SysCronMapper; 
import com.github.pagehelper.PageHelper; 
import com.github.pagehelper.PageInfo; 
 
@Service 
public class SysCronServiceImpl implements SysCronService { 
	private static final Logger log = LoggerFactory.getLogger(SysCronServiceImpl.class); 
 
	@Autowired 
	private Scheduler scheduler; 
	@Autowired 
	private SysCronMapper mapper; 
	 
	@Override 
	public List<SysCron> selectAll(Map<String, Object> parame) { 
		return mapper.selectAll(parame); 
	} 
 
	@Override 
	public PageData<SysCron> selectAllPage(Map<String, Object> parame, PageParam rb) { 
		// TODO Auto-generated method stub 
		PageData<SysCron> pageData = new PageData<SysCron>(); 
		 
		PageHelper.startPage(rb.getPageNo(), rb.getLimit()); 
		List<SysCron> rs = mapper.selectAll(parame); 
		 
		PageInfo<SysCron> pageInfo = new PageInfo<SysCron>(rs); 
		pageData.setData(pageInfo.getList()); 
		pageData.setPageNum(pageInfo.getPageNum()); 
		pageData.setPageSize(pageInfo.getPageSize()); 
		pageData.setTotalCount(pageInfo.getTotal()); 
		return pageData; 
	} 
 
	 
	@Override 
	public boolean addSysCron(SysCron entity) { 
		boolean target = false; 
		try { 
			// 启动调度器 
			scheduler.start(); 
			// 构建job信息 
			JobDetail jobDetail = JobBuilder.newJob(getClass(entity.getJobClassName()).getClass()) 
					.withIdentity(entity.getJobClassName(), entity.getJobGroupName()).build(); 
			// 表达式调度构建器(即任务执行的时间) 
			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(entity.getCronExpression()); 
			// 按新的cronExpression表达式构建一个新的trigger 
			CronTrigger trigger = TriggerBuilder.newTrigger() 
					.withIdentity(entity.getJobClassName(), entity.getJobGroupName()).withSchedule(scheduleBuilder) 
					.build(); 
 
			scheduler.scheduleJob(jobDetail, trigger); 
			target = true; 
		} catch (Exception e) { 
			log.error("创建定时任务异常" + e.getMessage()); 
			return target; 
		} 
		return target; 
	} 
 
	@Override 
	public boolean updateSysCron(SysCron entity) { 
		boolean target = false; 
		try { 
			TriggerKey triggerKey = TriggerKey.triggerKey(entity.getJobClassName(), entity.getJobGroupName()); 
			// 表达式调度构建器 
			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(entity.getCronExpression()); 
			CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey); 
			// 按新的cronExpression表达式重新构建trigger 
			trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build(); 
			// 按新的trigger重新设置job执行 
			scheduler.rescheduleJob(triggerKey, trigger); 
			target = true; 
		} catch (Exception e) { 
			log.error("定时任务更新失败" + e.getMessage()); 
			return target; 
		} 
 
		return target; 
	} 
 
	@Override 
	public boolean deleteSysCron(SysCron entity) { 
		boolean target = false; 
		try { 
			scheduler.pauseTrigger(TriggerKey.triggerKey(entity.getJobClassName(), entity.getJobGroupName())); 
			scheduler.unscheduleJob(TriggerKey.triggerKey(entity.getJobClassName(), entity.getJobGroupName())); 
			scheduler.deleteJob(JobKey.jobKey(entity.getJobClassName(), entity.getJobGroupName())); 
			target = true; 
		} catch (Exception e) { 
			log.error("定时任务删除失败" + e.getMessage()); 
			return target; 
		} 
		return target; 
	} 
 
	@Override 
	public boolean pauseSysCron(SysCron entity) { 
		boolean target = false; 
		try { 
			scheduler.pauseJob(JobKey.jobKey(entity.getJobClassName(), entity.getJobGroupName())); 
			target = true; 
		} catch (Exception e) { 
			log.error("暂停定时任务失败" + e.getMessage()); 
			return target; 
		} 
		return target; 
	} 
 
	@Override 
	public boolean resumeJob(SysCron entity) { 
		boolean target = false; 
		try { 
			scheduler.resumeJob(JobKey.jobKey(entity.getJobClassName(), entity.getJobGroupName())); 
			target = true; 
		} catch (Exception e) { 
			log.error("恢复定时任务失败" + e.getMessage()); 
			return target; 
		} 
		return target; 
	} 
 
	/** 
	 *  
	 * @param classname 
	 * @return 
	 * @throws Exception 
	 */ 
	public static BaseJob getClass(String classname) throws Exception { 
		Class<?> class1 = Class.forName(classname); 
		return (BaseJob) class1.newInstance(); 
	} 
 
	 
 
} 

数据库mapp 接口定义和mapp 查询映射

import java.util.List; 
import java.util.Map; 
 
import com.***.common.model.PageParam; 
import com.***.common.page.PageData; 
import com.***.ucas.domain.SysCron; 
 
public interface SysCronMapper { 
    // 全部查询 
 	List<SysCron> selectAll(Map<String,Object> parame); 
 	//分页查询 
 	PageData<SysCron> selectAllPage(Map<String,Object> parame, PageParam rb); 
}

<?xml version="1.0" encoding="UTF-8"?> 
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> 
<mapper namespace="com.digipower.ucas.mapper.SysCronMapper"> 
 
  <!-- 公共查询条件  --> 
  <sql id="condition"> 
  		<if test="jobClassName != null"> 
  			and jd.job_class_name = #{jobClassName,jdbcType=VARCHAR} 
  		</if> 
  		<if test="jobGroupName != null"> 
  			and jd.job_group = #{jobGroupName,jdbcType=VARCHAR} 
  		</if> 
  		<if test="triggerName != null"> 
  			and t.trigger_name = #{triggerName,jdbcType=VARCHAR} 
  		</if> 
  		<if test="triggerGroupName != null"> 
  			and t.trigger_group = #{triggerGroupName,jdbcType=VARCHAR} 
  		</if> 
  		<if test="triggerState != null"> 
  			and t.trigger_state = #{triggerState, jdbcType=VARCHAR} 
  		</if> 
  </sql> 
 
	 <!-- 全部查询 --> 
    <select id="selectAll" resultType="com.digipower.ucas.domain.SysCron"> 
            select 
                jd.job_name as jobname, 
                jd.description as jobdescription, 
                jd.job_group as jobgroupname, 
                jd.job_class_name as jobclassname, 
                t.trigger_name as triggername, 
                t.trigger_group as triggergroupname, 
                from_unixtime(t.prev_fire_time/1000,'%y-%m-%d %t') as prevfiretime, 
                from_unixtime(t.next_fire_time/1000,'%y-%m-%d %t') as nextfiretime, 
                ct.cron_expression as cronexpression, 
                t.trigger_state as triggerstate 
            from 
                qrtz_job_details jd 
            join qrtz_triggers t 
            join qrtz_cron_triggers ct on jd.job_name = t.job_name 
            and t.trigger_name = ct.trigger_name 
            and t.trigger_group = ct.trigger_group 
            where 1 = 1 
            <include refid="condition" /> 
    </select> 
</mapper>

至此，Spring + Mybatis + Quartz 实现定义任务管理的基本功能封装完毕。

效果截图：待补充

第五步：添加自定义定时任务：

定义通用公共基础任务:BaseJob.java

import org.quartz.Job; 
import org.quartz.JobExecutionContext; 
import org.quartz.JobExecutionException; 
 
/** 
 * 定时任务基础类 
 * @author zzg 
 * 
 */ 
public interface BaseJob extends Job { 
	public void execute(JobExecutionContext context) throws JobExecutionException; 
} 

添加自定义Job 

import java.util.Date; 
import org.quartz.JobExecutionContext; 
import org.quartz.JobExecutionException; 
import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 
import com.***.common.job.BaseJob; 
 
public class SimpleJob implements BaseJob { 
	private static final Logger log = LoggerFactory.getLogger(SimpleJob.class); 
	 
	public SimpleJob(){ 
		System.out.println(new Date() + "SimpleJob"); 
        try { 
            Thread.sleep(10000); 
            System.out.println("任务 SimpleJob 开始干活。。。"); 
        } catch (InterruptedException e) { 
            e.printStackTrace(); 
            log.error("SimpleJob 定时任务报错：" + e.getMessage()); 
        } 
        System.out.println(new Date() + "SimpleJob 任务结束------------------------------------"); 
	} 
 
	@Override 
	public void execute(JobExecutionContext context) throws JobExecutionException { 
		// TODO Auto-generated method stub 
		 System.out.println("SimpleJob执行时间: " + new Date()); 
	} 
 
}

import java.util.List; 
import org.quartz.JobExecutionContext; 
import org.quartz.JobExecutionException; 
import org.springframework.beans.factory.annotation.Autowired; 
import com.alibaba.fastjson.JSONObject; 
import com.***.common.job.BaseJob; 
import com.***.ucas.domain.SysDataCategory; 
import com.***.ucas.mapper.SysDataCategoryMapper; 
 
public class SysDataCategoryJob implements BaseJob { 
 
	@Autowired 
	private SysDataCategoryMapper mapper; 
	 
	@Override 
	public void execute(JobExecutionContext context) throws JobExecutionException { 
		List<SysDataCategory> list = mapper.selectAll(); 
		if(list != null && list.size() > 0){ 
			String json = JSONObject.toJSONString(list); 
			System.out.println("json 内容:" + json); 
		} 
	} 
 
}

补充说明：Quartz.2.x MySQL 建库脚本：请参考：https://blog.csdn.net/zhouzhiwengang/article/details/101776655