springBoot使用quartz，单表持久化到数据库，

Quartz定时任务持久化到数据库，单表
1.表结构
DAO层使用mybatis-generator自动生成

2.pom.xml文件加入依赖

<dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.1</version>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
            <version>2.2.1</version>
 </dependency>

3.application.properties中配置quartz线程池的线程数量，避免造成不必要的开销
spring.quartz.properties.org.quartz.threadPool.threadCount=3

4.新建一个类，配置SchedulerFactoryBean（可以不用配置，使用默认的）

 @Configuration
    public class QuartzFactoryBean implements SchedulerFactoryBeanCustomizer {
        @Override
        public void customize(SchedulerFactoryBean schedulerFactoryBean) {
            schedulerFactoryBean.setStartupDelay(10);
            schedulerFactoryBean.setOverwriteExistingJobs(true);
        }
    }

5.动态修改任务工具类，具体可以参考https://www.w3cschool.cn/quartz_doc/

public class QuartzManager {
	//应用启动后，Scheduler已经装配到ioc容器中了，无需重新new一个
    private static Scheduler sched = SpringContextUtils.getBean(Scheduler.class);
   
    public static void addJob(String jobName, String jobGroupName,
                          String triggerName, String triggerGroupName, Class jobClass, String cron) {
        try {
            // 任务名，任务组，任务执行类
            JobDetail jobDetail= 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
            sched.scheduleJob(jobDetail, trigger);

            // 启动
            /*if (!sched.isShutdown()) {
                sched.start();
            }*/
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

6.QuartzManager中SpringContextUtils工具，用于获取ioc容器中的bean实例

@Component
    public class SpringContextUtils implements ApplicationContextAware {
        /**
         * 上下文对象实例
         */
        private static ApplicationContext applicationContext;

        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            this.applicationContext = applicationContext;
        }
        /**
         * 获取applicationContext
         */
        public static ApplicationContext getApplicationContext() {
            return applicationContext;
        }
        /**
         * 通过name获取 Bean.
         */
        public static Object getBean(String name) {
            return getApplicationContext().getBean(name);
        }
        /**
         * 通过class获取Bean.
         */
        public static <T> T getBean(Class<T> clazz) {
            return getApplicationContext().getBean(clazz);
        }
        /**
         * 通过name,以及Clazz返回指定的Bean
         */
        public static <T> T getBean(String name, Class<T> clazz) {
            return getApplicationContext().getBean(name, clazz);
        }

7.创建任务实例

package com.taiyu.save.config.QuartzConfig;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

/*@Author xwf
*@Description DisallowConcurrentExecution不允许并发执行
*@Date 2019/1/16 0016 11:29
*@Param
*@Return
**/
@DisallowConcurrentExecution
public class TestJob extends QuartzJobBean {
    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        System.out.println("testtest");
    }
}

8.springboot启动之后，查询数据库中的任务实例
两种方式
8.1 实现ApplicationRunner接口

     @Component
public class  ApplicationRunnerImpl implements ApplicationRunner {
    @Resource
    private TasksService tasksService;
    @Override
    public void run(ApplicationArguments args){
        Tasks tasks = new Tasks();
        tasks.setStatus(1);
        List<Tasks> tasksList = tasksService.selectByExample(tasks);
        tasksList.forEach(item->{
            QuartzManager.addJobByTasks(item);
        });
    }
}

8.2 实现CommandLineRunner接口

    @Component
public class QuartzCommandLineRunner implements CommandLineRunner {
    @Resource
    private TasksService tasksService;
    @Override
    public void run(String... args){
        Tasks tasks = new Tasks();
        tasks.setStatus(1);
        List<Tasks> tasksList = tasksService.selectByExample(tasks);
        tasksList.forEach(item->{
            QuartzManager.addJobByTasks(item);
        });
    }
}

两种实现方式的不同之处在于run方法中接收的参数类型不一样