Springboot 集成Quartz 使用笔记

1.首先就是导包，因为项目用的是springboot, 里面集成了quartz, 所以直接引入以下的jar包；

springboot 版本为2.0.3.RELEASE

     <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
     </dependency>

2.Quartz 配置类

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

@Configuration
public class QuartzConfig {

	private SpringJobFactory jobFactory;

    public QuartzConfig(SpringJobFactory jobFactory){
        this.jobFactory = jobFactory;
    }

    /**
     * 配置SchedulerFactoryBean
     *
     * 将一个方法产生为Bean并交给Spring容器管理
     */
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() {
        // Spring提供SchedulerFactoryBean为Scheduler提供配置信息,并被Spring容器管理其生命周期
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        // 设置自定义Job Factory，用于Spring管理Job bean
        factory.setJobFactory(jobFactory);
        return factory;
    }

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

3.解决SpringBoot不能再Quartz中注入Bean的问题

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;

/**
 * 解决SpringBoot不能再Quartz中注入Bean的问题
 * @author jinlei
 *
 */
@Component
public class SpringJobFactory extends AdaptableJobFactory{

	 @Autowired 
	 private AutowireCapableBeanFactory capableBeanFactory; 
	 
	 @Override 
	 protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception { 
		 // 调用父类的方法 
		 Object jobInstance = super.createJobInstance(bundle); 
		 // 进行注入 
		 capableBeanFactory.autowireBean(jobInstance); 
		 return jobInstance; 
	}
}				

4.将quartz 任务类封装成一个Service 层

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.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.springframework.stereotype.Service;

@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" })
	public void addJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName, Class jobClass,
			String cron) {
		try {
			// 任务名，任务组，任务执行类
			JobDetail job = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
			// 触发器
			TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
			// 触发器名,触发器组
			triggerBuilder.withIdentity(triggerName, triggerGroupName);
			triggerBuilder.startNow();
			// 触发器时间设定
			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);
		}
	}

	/**
	 * 获取任务是否存在
	 *
	 * 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);
		}
	}
}

5.然后在控制器里面调用就好；

@RequestMapping(value="create",method=RequestMethod.POST)
	public void create(String time) {
		String cron="0 32 14 27 07 ? 2018";
		String jobName="job";
		String jobGroupName="jobGroup";
		String triggerName="name";
		String triggerGroupName="name";
		quartzManager.addJob(jobName, jobGroupName, triggerName, triggerGroupName, ScheduledTask.class, cron);	
	}