Springboot集成quartz

项目中要用到定时任务，所以结合以前的项目和网上的找的东西，整合到了项目中，测试可用

首先是添加的jar包依赖

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-quartz</artifactId>
</dependency>
使用的SpringBoot版本是2.1.3.RELEASE

然后是一些相关的配置文件

# quartz config
spring.quartz.properties.org.quartz.scheduler.instanceName=clusteredScheduler
spring.quartz.properties.org.quartz.scheduler.id=AUTO
#spring.quartz.properties.org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
#spring.quartz.properties.org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#spring.quartz.properties.org.quartz.jobStore.tablePrefix=QRTZ_
#spring.quartz.properties.org.quartz.jobStore.isClustered=true
#spring.quartz.properties.org.quartz.jobStore.clusterCheckinInterval=10000
#spring.quartz.properties.org.quartz.jobStore.useProperties=false
spring.quartz.properties.org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
spring.quartz.properties.org.quartz.threadPool.threadCount=10
spring.quartz.properties.org.quartz.threadPool.threadPriority=5
spring.quartz.properties.org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread=true
#spring.quartz.job-store-type=jdbc

　因为使用的是SpringBoot的项目，去除掉了xml,所以有一些java Config的配置类

package com.voole.config.quartz;

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 VooleJobFactory extends AdaptableJobFactory{

	@Autowired
	private AutowireCapableBeanFactory capableBeanFactory;

	@Override
	protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
		Object jobInstance = super.createJobInstance(bundle);
		capableBeanFactory.autowireBean(jobInstance);
		return jobInstance;
	}
	
	
}

　　

package com.voole.config.quartz;


import org.springframework.boot.autoconfigure.quartz.SchedulerFactoryBeanCustomizer;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

@Configuration
public class SchedulerConfig implements SchedulerFactoryBeanCustomizer {

	@Override
	public void customize(SchedulerFactoryBean schedulerFactoryBean) {
		schedulerFactoryBean.setAutoStartup(true);
		schedulerFactoryBean.setOverwriteExistingJobs(true);
	}

}

　　

package com.voole.config.quartz;

import org.quartz.Scheduler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

@Configuration
public class QuartzConfigration {

	@Autowired
	private VooleJobFactory vooleJobFactory;
	
	@Bean
	public SchedulerFactoryBean schedulerFactoryBean() {
		SchedulerFactoryBean bean = new SchedulerFactoryBean();
		bean.setJobFactory(vooleJobFactory);
		return bean;
	}
	
	@Bean(name="scheduler")
	public Scheduler scheduler() {
		return	schedulerFactoryBean().getScheduler();
	}
}

　　因为想在任务类中添加Spring的注入特性，所以上面的有些配置是做的依赖注入相关的配置信息

接着是提供的对外暴露的方法

package com.voole.platform.task;

import java.util.Map;

public class ScheduleJob {

	public static final int TASK_MODEL_NOW = 0;// 立即执行
	public static final int TASK_MODEL_TIME = 1;// 定时执行
	public static final int TASK_MODEL_CRON = 2;//循环执行

	public static final int TASK_STATUS_DO = 0;// 任务未处理
	public static final int TASK_STATUS_SUCC = 1; // 任务成功
	public static final int TASK_STATUS_FAIL = 2;// // 任务执行完成存在错误
	public static final int TASK_STATUS_DOING = 3;// 任务正在执行
	public static final int TASK_STATUS_DISCARD = 4;// 任务废弃
	
    public static final int RECORD_STATUS_DO = 0;//任务未处理
    public static final int RECORD_STATUS_SUCC = 1; //任务成功
    public static final int RECORD_STATUS_FAIL = 2;//任务失败

	private Long id;
	private String taskType;
	private int taskModel;
	private String cron;
	private int status;
	private String taskClass;
	
	private Map<String,String> data;
	

	

	public Long getId() {
		return id;
	}

	public void setId(Long id) {
		this.id = id;
	}

	public String getTaskType() {
		return taskType;
	}

	public void setTaskType(String taskType) {
		this.taskType = taskType;
	}

	public int getTaskModel() {
		return taskModel;
	}

	public void setTaskModel(int taskModel) {
		this.taskModel = taskModel;
	}

	

	public String getCron() {
		return cron;
	}

	public void setCron(String cron) {
		this.cron = cron;
	}


	public int getStatus() {
		return status;
	}

	public void setStatus(int status) {
		this.status = status;
	}

	public String getTaskClass() {
		return taskClass;
	}

	public void setTaskClass(String taskClass) {
		this.taskClass = taskClass;
	}

	

	public Map<String, String> getData() {
		return data;
	}

	public void setData(Map<String, String> data) {
		this.data = data;
	}
	
	
}

　　

package com.voole.platform.task;


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

import javax.annotation.PostConstruct;

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.SimpleTrigger;
import org.quartz.Trigger;
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;




@Service
public class JobTaskService {
	
	private final static Logger logger = LoggerFactory.getLogger(JobTaskService.class);
	
	//默认任务组名
	public static final String DEFAULT_JOB_GROUP_NAME = "DEFAULT_JOBGROUP";
	public static final String DEFAULT_TRIGGER_GROUP_NAME = "DEFAULT_TRIGGERGROUP";
	
	@Autowired
	private Scheduler scheduler;
	
	
	/**
	 * 
	 * <p>Title: addJob</p>
	 * <p>Description: 添加任务</p>
	 * @param job
	 * @param jobName
	 * @throws Exception
	 * @author 冯浩  2018年11月6日 下午3:55:13
	 */
	public void addJob(ScheduleJob job,String jobName) throws Exception{
		if(job == null) {
			return;
		}
		
		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		
		if(!scheduler.isStarted()) {
			//notify all scheduler listeners
			scheduler.start();
		}
		JobDetail jobDetail = scheduler.getJobDetail(JobKey.jobKey(jobName, DEFAULT_JOB_GROUP_NAME));
		if(jobDetail == null) {
			Class clazz = Class.forName(job.getTaskClass());
			jobDetail = JobBuilder.newJob(getClass(clazz).getClass()).withIdentity(jobName, DEFAULT_JOB_GROUP_NAME).build();
			jobDetail.getJobDataMap().putAll(job.getData());
			
			int taskModel = job.getTaskModel();
			Trigger trigger = null;
			if (taskModel == ScheduleJob.TASK_MODEL_TIME) {
				Date startDate = dateFormat.parse(job.getCron() == null ? dateFormat.format(new Date()) : job.getCron());
				trigger = (SimpleTrigger)TriggerBuilder.newTrigger().withIdentity(jobName, DEFAULT_JOB_GROUP_NAME).startAt(startDate).build();
			} else if(taskModel == ScheduleJob.TASK_MODEL_NOW){
				trigger = (SimpleTrigger)TriggerBuilder.newTrigger().withIdentity(jobName,DEFAULT_JOB_GROUP_NAME).startNow().build();
			} else if(taskModel == ScheduleJob.TASK_MODEL_CRON) {
				CronScheduleBuilder cronSchedule = CronScheduleBuilder.cronSchedule(job.getCron());
				trigger = (CronTrigger)TriggerBuilder.newTrigger().withIdentity(jobName,DEFAULT_JOB_GROUP_NAME).withSchedule(cronSchedule).build();
			}
			scheduler.scheduleJob(jobDetail, trigger);
			
		}
	}
	
	public void addJob(ScheduleJob job) throws Exception {
		if (job == null) {
			return;
		}
		String jobName = job.getTaskType() + job.getId();
		addJob(job, jobName);
	}
	
	/**
	 * 移除一个任务(使用默认的任务组名，触发器名，触发器组名)
	 */
	public void removeJob(String jobClassName,String jobGroupName) {
		try {
			scheduler.pauseTrigger(TriggerKey.triggerKey(jobClassName, jobGroupName));
			scheduler.unscheduleJob(TriggerKey.triggerKey(jobClassName, jobGroupName));
			scheduler.deleteJob(JobKey.jobKey(jobClassName, jobGroupName));
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
	
	
	/**
	 * 移除一个任务同时修改cron_task状态
	 * @param jobName
	 * @param triggerName
	 * @author
	 * @time   2016-11-24
	 */
	public void clearJob(String jobName,String triggerName){
		try {
			JobDetail jobDetail = scheduler.getJobDetail(JobKey.jobKey(jobName, DEFAULT_JOB_GROUP_NAME));
			if(jobDetail == null){
				return;
			}
			removeJob(jobName,triggerName);
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
	}
	

	public Job getClass(@SuppressWarnings("rawtypes") Class clazz) throws Exception {
		return (Job)clazz.newInstance();
	}
	
	

}

　　然后是测试任务

package com.voole.platform.task.job;

import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.stereotype.Service;

@Service
public class IndexJob implements Job {

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
        Object orderid = jobDataMap.get("orderid");
        System.out.println(orderid);
    }

}

最后是测试类，做的是使用controller做的任务触发

@ApiOperation(value="定时任务测试")
    @GetMapping("quartz")
    public String quartz() throws Exception {
        Map<String,String> data = new HashMap<>();
        data.put("orderid", "123456789");
        ScheduleJob job = new ScheduleJob();
        job.setId(1l);
        job.setTaskType("order");
        job.setTaskClass("com.voole.platform.task.job.IndexJob");
        job.setTaskModel(ScheduleJob.TASK_MODEL_CRON);
        Date addMinutes = DateUtils.addMinutes(1);
        String format = DateUtils.format(addMinutes);
        job.setCron("1/2 * * * * ?");
        job.setData(data);
        taskService.addJob(job);
        return "Sucess";
    }

打完了！