SpringBoot学习-持久化Quartz定时任务管理

上一篇讲述了简单的QuartZ定时器的配置，这一次说一下持久化处理过程。

参考博文：http://blog.csdn.net/u012907049/article/details/73801122

首先是配置文件-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

# 默认存储在内存中
#org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore

#持久化
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX

org.quartz.jobStore.tablePrefix = QRTZ_

org.quartz.jobStore.dataSource = qzDS

org.quartz.dataSource.qzDS.driver = com.mysql.jdbc.Driver

org.quartz.dataSource.qzDS.URL = jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8

org.quartz.dataSource.qzDS.user = root

org.quartz.dataSource.qzDS.password = 123456

org.quartz.dataSource.qzDS.maxConnections = 10

比上一篇配置更详细，我参考的，有兴趣可以了解看看

接下里就是配置类-SchedulerConfig：

package com.example.demo.quartz;

import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.ee.servlet.QuartzInitializerListener;
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 javax.sql.DataSource;
import java.io.IOException;
import java.util.Properties;

@Configuration
public class SchedulerConfig {
@Bean
public SchedulerFactoryBean schedulerFactoryBean(DataSource dataSource) throws IOException, SchedulerException {
SchedulerFactoryBean factory = new SchedulerFactoryBean();
factory.setQuartzProperties(quartzProperties());
Scheduler scheduler = factory.getScheduler();
if(null != scheduler ){
scheduler.start();
}
return factory;
}

@Bean
public Properties quartzProperties() throws IOException {
PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
return propertiesFactoryBean.getObject();
}

@Bean
public QuartzInitializerListener executorListener() {
return new QuartzInitializerListener();
}
}

Job管理接口-JobController：

package com.example.demo.controller;

import com.example.demo.entities.JobDto;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.*;

/**
* Created by John.Zhang on 2017/10/25.
*/
@RestController
@RequestMapping(value="/job")
public class JobController
{
//    @Autowired
//    private IJobAndTriggerService iJobAndTriggerService;

private static Logger log = LoggerFactory.getLogger(JobController.class);

@PostMapping(value="/addjob")
public void addjob(@RequestBody JobDto jobDto) throws Exception
{
addJob(jobDto.getJobClassName(), jobDto.getJobGroupName(), jobDto.getCronExpression());
}

public static void addJob(String jobClassName, String jobGroupName, String cronExpression)throws Exception{

// 通过SchedulerFactory获取一个调度器实例
SchedulerFactory sf = new StdSchedulerFactory();

Scheduler sched = sf.getScheduler();

// 启动调度器
sched.start();

//构建job信息
JobDetail jobDetail = JobBuilder.newJob(getClass(jobClassName).getClass()).withIdentity(jobClassName, jobGroupName).build();

//表达式调度构建器(即任务执行的时间)
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

//按新的cronExpression表达式构建一个新的trigger
CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobClassName, jobGroupName)
.withSchedule(scheduleBuilder).build();

try {
sched.scheduleJob(jobDetail, trigger);

} catch (SchedulerException e) {
System.out.println("创建定时任务失败"+e);
throw new Exception("创建定时任务失败");
}
}

@PostMapping(value="/pausejob")
public void pausejob(@RequestBody JobDto jobDto) throws Exception
{
jobPause(jobDto.getJobClassName(), jobDto.getJobGroupName());
}

public static void jobPause(String jobClassName, String jobGroupName) throws Exception
{
// 通过SchedulerFactory获取一个调度器实例
SchedulerFactory sf = new StdSchedulerFactory();
Scheduler sched = sf.getScheduler();
sched.pauseJob(JobKey.jobKey(jobClassName, jobGroupName));
}

@PostMapping(value="/resumejob")
public void resumejob(@RequestBody JobDto jobDto) throws Exception
{
jobresume(jobDto.getJobClassName(), jobDto.getJobGroupName());
}

public static void jobresume(String jobClassName, String jobGroupName) throws Exception
{
// 通过SchedulerFactory获取一个调度器实例
SchedulerFactory sf = new StdSchedulerFactory();
Scheduler sched = sf.getScheduler();
sched.resumeJob(JobKey.jobKey(jobClassName, jobGroupName));
}

@PostMapping(value="/reschedulejob")
public void rescheduleJob(@RequestBody JobDto jobDto) throws Exception
{
jobreschedule(jobDto.getJobClassName() , jobDto.getJobGroupName(), jobDto.getCronExpression());
}

public static void jobreschedule(String jobClassName, String jobGroupName, String cronExpression) throws Exception
{
try {
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getScheduler();
TriggerKey triggerKey = TriggerKey.triggerKey(jobClassName, jobGroupName);
// 表达式调度构建器
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

// 按新的cronExpression表达式重新构建trigger
trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();

// 按新的trigger重新设置job执行
scheduler.rescheduleJob(triggerKey, trigger);
} catch (SchedulerException e) {
System.out.println("更新定时任务失败"+e);
throw new Exception("更新定时任务失败");
}
}

@PostMapping(value="/deletejob")
public void deletejob(@RequestBody JobDto jobDto) throws Exception
{
jobdelete(jobDto.getJobClassName(), jobDto.getJobGroupName());
}

public static void jobdelete(String jobClassName, String jobGroupName) throws Exception
{
// 通过SchedulerFactory获取一个调度器实例
SchedulerFactory sf = new StdSchedulerFactory();
Scheduler sched = sf.getScheduler();
sched.pauseTrigger(TriggerKey.triggerKey(jobClassName, jobGroupName));
sched.unscheduleJob(TriggerKey.triggerKey(jobClassName, jobGroupName));
sched.deleteJob(JobKey.jobKey(jobClassName, jobGroupName));
}

/*@GetMapping(value="/queryjob")
public Map<String, Object> queryjob(@RequestParam(value="pageNum")Integer pageNum, @RequestParam(value="pageSize")Integer pageSize)
{
PageInfo<JobAndTrigger> jobAndTrigger = iJobAndTriggerService.getJobAndTriggerDetails(pageNum, pageSize);
Map<String, Object> map = new HashMap<String, Object>();
map.put("JobAndTrigger", jobAndTrigger);
map.put("number", jobAndTrigger.getTotal());
return map;
}*/

public static Job getClass(String classname) throws Exception
{
Class<?> class1 = Class.forName(classname);
return (Job)class1.newInstance();
}
}

前后台传递实体类-JobDto ：

package com.example.demo.entities;

/**
* Created by John.Zhang on 2017/10/25.
*/
public class JobDto {
private String jobClassName;
private String jobGroupName;
private String cronExpression;

public String getJobClassName() {
return jobClassName;
}

public void setJobClassName(String jobClassName) {
this.jobClassName = jobClassName;
}

public String getJobGroupName() {
return jobGroupName;
}

public void setJobGroupName(String jobGroupName) {
this.jobGroupName = jobGroupName;
}

public String getCronExpression() {
return cronExpression;
}

public void setCronExpression(String cronExpression) {
this.cronExpression = cronExpression;
}
}

其他的调用接口执行就行，使用页面、测试类或者类似于PostMan之类的测试工具都可以