springboot 自定义配置Quartz动态定时器

在整个项目规划中，有的时候需要定时的去执行某一段代码，触发时间能随时修改，并且不影响项目的整体运行。所以，定时器的设计就必须要灵活，能随时的增，删，改定时任务。

1. 数据库设计

CREATE TABLE `sys_task` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `created_at` datetime NOT NULL COMMENT '创建时间',
  `updated_at` datetime NOT NULL COMMENT '修改时间',
  `task_name` varchar(255) DEFAULT NULL COMMENT '任务名称',
  `task_remark` varchar(255) DEFAULT NULL COMMENT '说明',
  `job_class` varchar(255) NOT NULL COMMENT '任务类',
  `cron_expression` varchar(255) NOT NULL COMMENT '规则表达式',
  `is_enable` smallint(1) NOT NULL COMMENT '是否启用',
  `status` varchar(25) DEFAULT NULL COMMENT '状态',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=40 DEFAULT CHARSET=utf8 COMMENT='系统任务调度';

2.maven 依赖

<dependency>
  <groupId>org.quartz-scheduler</groupId>
  <artifactId>quartz</artifactId>
  <version>2.2.1</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context-support</artifactId>
  <version>4.3.7.RELEASE</version>
</dependency>

3. 调度器类

import java.util.Date;

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.SchedulerException;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;

/**
 * 任务调度
 *
 */
@Configuration
public class QuartzScheduler {

	@Autowired
	private Scheduler scheduler;
	
	
	/**
     * 获取Job信息
     * 
     * @param name 类名
     * @return
     * @throws SchedulerException
     */
    public String getJobInfo(String name) throws SchedulerException {
        TriggerKey triggerKey = new TriggerKey(name, scheduler.DEFAULT_GROUP);
        CronTrigger cronTrigger = (CronTrigger) scheduler.getTrigger(triggerKey);
        return String.format("time:%s,state:%s", cronTrigger.getCronExpression(),
                scheduler.getTriggerState(triggerKey).name());
    }
	
    /**
     * 修改某个任务的执行时间
     * 
     * @param name 类名
     * @param time 任务触发时间
     * @return
     * @throws SchedulerException
     */
    public boolean modifyJob(String name, String time) throws SchedulerException {
        Date date = null;
        TriggerKey triggerKey = new TriggerKey(name, scheduler.DEFAULT_GROUP);
        CronTrigger cronTrigger = (CronTrigger) scheduler.getTrigger(triggerKey);
        String oldTime = cronTrigger.getCronExpression();
        if (!oldTime.equalsIgnoreCase(time)) {
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(time);
            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(name, scheduler.DEFAULT_GROUP)
                    .withSchedule(cronScheduleBuilder).build();
            date = scheduler.rescheduleJob(triggerKey, trigger);
        }
        return date != null;
    }

    /**
     * 暂停所有任务
     * 
     * @throws SchedulerException
     */
    public void pauseAllJob() throws SchedulerException {
        scheduler.pauseAll();
    }

    /**
     * 暂停某个任务
     * 
     * @param name 类名
     */
    public void pauseJob(String name) throws SchedulerException {
        JobKey jobKey = new JobKey(name, scheduler.DEFAULT_GROUP);
        JobDetail jobDetail = scheduler.getJobDetail(jobKey);
        if (jobDetail == null)
            return;
        scheduler.pauseJob(jobKey);
    }

    /**
     * 恢复所有任务
     * 
     * @throws SchedulerException
     */
    public void resumeAllJob() throws SchedulerException {
        scheduler.resumeAll();
    }

    /**
     * 恢复某个任务
     * 
     * @param name  类名
     */
    public void resumeJob(String name) throws SchedulerException {
        JobKey jobKey = new JobKey(name, scheduler.DEFAULT_GROUP);
        JobDetail jobDetail = scheduler.getJobDetail(jobKey);
        if (jobDetail == null)
            return;
        scheduler.resumeJob(jobKey);
    }

    /**
     * 删除某个任务
     * 
     * @param name 类名
     */
    public void deleteJob(String name) throws SchedulerException {
        JobKey jobKey = new JobKey(name, scheduler.DEFAULT_GROUP);
        JobDetail jobDetail = scheduler.getJobDetail(jobKey);
        if (jobDetail == null)
            return;
        scheduler.deleteJob(jobKey);
    }
    
    /**
     * 添加定时器
     * 
     * @param name 类名
     * @param time 任务触发时间
     * @throws SchedulerException
     */
    public void addJob(String name,String time) throws SchedulerException {
    	Class classs = null;
		try {
			classs = Class.forName(name);
		} catch (ClassNotFoundException e1) {
			e1.printStackTrace();
		}
    	JobDetail jobDetail = JobBuilder.newJob(classs).withIdentity(name, scheduler.DEFAULT_GROUP).build();
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(time);
        CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity(name, scheduler.DEFAULT_GROUP)
                .withSchedule(cronScheduleBuilder).build();
        scheduler.scheduleJob(jobDetail, cronTrigger);
    }
}

4.初始化任务

import java.util.List;

import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ContextRefreshedEvent;



import tk.mybatis.mapper.entity.Example;
import tk.mybatis.mapper.entity.Example.Criteria;

/**
 * 任务初始化调度

 *
 */
@Configuration
public class ApplicationStartQuartzJob implements ApplicationListener<ContextRefreshedEvent> {
	@Autowired
	private SysTaskService sysTaskService;
	@Override
	public void onApplicationEvent(ContextRefreshedEvent event) {
		Example example=new Example(SysTask.class);
		Criteria createCriteria = example.createCriteria();
		createCriteria.andEqualTo("isEnable", 1);
		List<SysTask> sysTaskList = sysTaskService.selectByExample(example);
		Scheduler scheduler=null;
		try {
			scheduler = scheduler();
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
		if(!sysTaskList.isEmpty()){
			for (SysTask sysTask : sysTaskList) {
				Class classs=null;
				try {
					classs = Class.forName(sysTask.getJobClass());
				} catch (ClassNotFoundException e) {
					e.printStackTrace();
				}
			JobDetail jobDetail = JobBuilder.newJob(classs).withIdentity(sysTask.getJobClass(), scheduler.DEFAULT_GROUP).build();
		    CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(sysTask.getCronExpression());
		    CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity(sysTask.getJobClass(), scheduler.DEFAULT_GROUP)
		                .withSchedule(cronScheduleBuilder).build();
		        try {
					scheduler.scheduleJob(jobDetail, cronTrigger);
				} catch (SchedulerException e) {
					e.printStackTrace();
				}
		 }
	  }
		try {
			scheduler.start();
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
	}
	 /**
     * 初始注入scheduler
     * @return
     * @throws SchedulerException
     */
    @Bean
    public Scheduler scheduler() throws SchedulerException{
        SchedulerFactory schedulerFactoryBean = new StdSchedulerFactory();
        return schedulerFactoryBean.getScheduler(); 
    }

}

5.编写测试类

public class Test1 implements Job {

   @Override
	public void execute(JobExecutionContext context)
			throws JobExecutionException {
        //任务执行逻辑代码片段
   }

}

Spring Boot与quartz的整合已经完成了，可以通过配置表sys_task表中的数据数来灵活的配置定时任务了。