Quartz定时持久化-SpringBoot

1.官方提供的quartz定时持久化表(11张SQL表格)

#持久化 表一
create table QRTZ_CALENDARS
(
  SCHED_NAME    varchar(120) not null,
  CALENDAR_NAME varchar(200) not null,
  CALENDAR      blob         not null,
  primary key (SCHED_NAME, CALENDAR_NAME)
);

#持久化 表二

create table QRTZ_FIRED_TRIGGERS
(
  SCHED_NAME        varchar(120) not null,
  ENTRY_ID          varchar(95)  not null,
  TRIGGER_NAME      varchar(200) not null,
  TRIGGER_GROUP     varchar(200) not null,
  INSTANCE_NAME     varchar(200) not null,
  FIRED_TIME        bigint(13)   not null,
  SCHED_TIME        bigint(13)   not null,
  PRIORITY          int          not null,
  STATE             varchar(16)  not null,
  JOB_NAME          varchar(200) null,
  JOB_GROUP         varchar(200) null,
  IS_NONCONCURRENT  varchar(1)   null,
  REQUESTS_RECOVERY varchar(1)   null,
  primary key (SCHED_NAME, ENTRY_ID)
);
#持久化 表三

create table QRTZ_JOB_DETAILS
(
  SCHED_NAME        varchar(120) not null,
  JOB_NAME          varchar(200) not null,
  JOB_GROUP         varchar(200) not null,
  DESCRIPTION       varchar(250) null,
  JOB_CLASS_NAME    varchar(250) not null,
  IS_DURABLE        varchar(1)   not null,
  IS_NONCONCURRENT  varchar(1)   not null,
  IS_UPDATE_DATA    varchar(1)   not null,
  REQUESTS_RECOVERY varchar(1)   not null,
  JOB_DATA          blob         null,
  primary key (SCHED_NAME, JOB_NAME, JOB_GROUP)
);

#持久化  表 四

create table QRTZ_LOCKS
(
  SCHED_NAME varchar(120) not null,
  LOCK_NAME  varchar(40)  not null,
  primary key (SCHED_NAME, LOCK_NAME)
);

#持久化  表 五

create table QRTZ_PAUSED_TRIGGER_GRPS
(
  SCHED_NAME    varchar(120) not null,
  TRIGGER_GROUP varchar(200) not null,
  primary key (SCHED_NAME, TRIGGER_GROUP)
);

#持久化  表六

create table QRTZ_SCHEDULER_STATE
(
  SCHED_NAME        varchar(120) not null,
  INSTANCE_NAME     varchar(200) not null,
  LAST_CHECKIN_TIME bigint(13)   not null,
  CHECKIN_INTERVAL  bigint(13)   not null,
  primary key (SCHED_NAME, INSTANCE_NAME)
);

#持久化  表七

create table QRTZ_TRIGGERS
(
  SCHED_NAME     varchar(120) not null,
  TRIGGER_NAME   varchar(200) not null,
  TRIGGER_GROUP  varchar(200) not null,
  JOB_NAME       varchar(200) not null,
  JOB_GROUP      varchar(200) not null,
  DESCRIPTION    varchar(250) null,
  NEXT_FIRE_TIME bigint(13)   null,
  PREV_FIRE_TIME bigint(13)   null,
  PRIORITY       int          null,
  TRIGGER_STATE  varchar(16)  not null,
  TRIGGER_TYPE   varchar(8)   not null,
  START_TIME     bigint(13)   not null,
  END_TIME       bigint(13)   null,
  CALENDAR_NAME  varchar(200) null,
  MISFIRE_INSTR  smallint(2)  null,
  JOB_DATA       blob         null,
  primary key (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP),
  constraint QRTZ_TRIGGERS_ibfk_1
  foreign key (SCHED_NAME, JOB_NAME, JOB_GROUP) references QRTZ_JOB_DETAILS (SCHED_NAME, JOB_NAME, JOB_GROUP)
);

#持久化  表八

create table QRTZ_BLOB_TRIGGERS
(
  SCHED_NAME    varchar(120) not null,
  TRIGGER_NAME  varchar(200) not null,
  TRIGGER_GROUP varchar(200) not null,
  BLOB_DATA     blob         null,
  primary key (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP),
  constraint QRTZ_BLOB_TRIGGERS_ibfk_1
  foreign key (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP) references QRTZ_TRIGGERS (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP)
);

#持久化 表九

create table QRTZ_CRON_TRIGGERS
(
  SCHED_NAME      varchar(120) not null,
  TRIGGER_NAME    varchar(200) not null,
  TRIGGER_GROUP   varchar(200) not null,
  CRON_EXPRESSION varchar(200) not null,
  TIME_ZONE_ID    varchar(80)  null,
  primary key (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP),
  constraint QRTZ_CRON_TRIGGERS_ibfk_1
  foreign key (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP) references QRTZ_TRIGGERS (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP)
);

#持久化 表十

create table QRTZ_SIMPLE_TRIGGERS
(
  SCHED_NAME      varchar(120) not null,
  TRIGGER_NAME    varchar(200) not null,
  TRIGGER_GROUP   varchar(200) not null,
  REPEAT_COUNT    bigint(7)    not null,
  REPEAT_INTERVAL bigint(12)   not null,
  TIMES_TRIGGERED bigint(10)   not null,
  primary key (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP),
  constraint QRTZ_SIMPLE_TRIGGERS_ibfk_1
  foreign key (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP) references QRTZ_TRIGGERS (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP)
);

#持久化  表十一


create table QRTZ_SIMPROP_TRIGGERS
(
  SCHED_NAME    varchar(120)   not null,
  TRIGGER_NAME  varchar(200)   not null,
  TRIGGER_GROUP varchar(200)   not null,
  STR_PROP_1    varchar(512)   null,
  STR_PROP_2    varchar(512)   null,
  STR_PROP_3    varchar(512)   null,
  INT_PROP_1    int            null,
  INT_PROP_2    int            null,
  LONG_PROP_1   bigint         null,
  LONG_PROP_2   bigint         null,
  DEC_PROP_1    decimal(13, 4) null,
  DEC_PROP_2    decimal(13, 4) null,
  BOOL_PROP_1   varchar(1)     null,
  BOOL_PROP_2   varchar(1)     null,
  primary key (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP),
  constraint QRTZ_SIMPROP_TRIGGERS_ibfk_1
  foreign key (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP) references QRTZ_TRIGGERS (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP)
);

2.实例化的实体类pojo层

package com.whale.doteonme.web.module.web.quartz.pojo;

import java.math.BigInteger;

public class JobAndTrigger {
    private String JOB_NAME;
    private String JOB_GROUP;
    private String JOB_CLASS_NAME;
    private String TRIGGER_NAME;
    private String TRIGGER_GROUP;
    private BigInteger REPEAT_INTERVAL;
    private BigInteger TIMES_TRIGGERED;
    private String CRON_EXPRESSION;
    private String TIME_ZONE_ID;

    public String getJOB_NAME() {
        return JOB_NAME;
    }

    public void setJOB_NAME(String JOB_NAME) {
        this.JOB_NAME = JOB_NAME;
    }

    public String getJOB_GROUP() {
        return JOB_GROUP;
    }

    public void setJOB_GROUP(String JOB_GROUP) {
        this.JOB_GROUP = JOB_GROUP;
    }

    public String getJOB_CLASS_NAME() {
        return JOB_CLASS_NAME;
    }

    public void setJOB_CLASS_NAME(String JOB_CLASS_NAME) {
        this.JOB_CLASS_NAME = JOB_CLASS_NAME;
    }

    public String getTRIGGER_NAME() {
        return TRIGGER_NAME;
    }

    public void setTRIGGER_NAME(String TRIGGER_NAME) {
        this.TRIGGER_NAME = TRIGGER_NAME;
    }

    public String getTRIGGER_GROUP() {
        return TRIGGER_GROUP;
    }

    public void setTRIGGER_GROUP(String TRIGGER_GROUP) {
        this.TRIGGER_GROUP = TRIGGER_GROUP;
    }

    public BigInteger getREPEAT_INTERVAL() {
        return REPEAT_INTERVAL;
    }

    public void setREPEAT_INTERVAL(BigInteger REPEAT_INTERVAL) {
        this.REPEAT_INTERVAL = REPEAT_INTERVAL;
    }

    public BigInteger getTIMES_TRIGGERED() {
        return TIMES_TRIGGERED;
    }

    public void setTIMES_TRIGGERED(BigInteger TIMES_TRIGGERED) {
        this.TIMES_TRIGGERED = TIMES_TRIGGERED;
    }

    public String getCRON_EXPRESSION() {
        return CRON_EXPRESSION;
    }

    public void setCRON_EXPRESSION(String CRON_EXPRESSION) {
        this.CRON_EXPRESSION = CRON_EXPRESSION;
    }

    public String getTIME_ZONE_ID() {
        return TIME_ZONE_ID;
    }

    public void setTIME_ZONE_ID(String TIME_ZONE_ID) {
        this.TIME_ZONE_ID = TIME_ZONE_ID;
    }
}

3.后台操作定时任务(非必须,但必要)dao层

package com.whale.doteonme.web.module.web.quartz.dao;


import com.whale.doteonme.web.module.web.quartz.pojo.JobAndTrigger;
import org.apache.ibatis.annotations.Select;

import java.util.List;

//查询所有定义任务相关的接口
public interface JobAndTriggerMapper {
    @Select("SELECT " + "QRTZ_JOB_DETAILS.JOB_NAME, " + "QRTZ_JOB_DETAILS.JOB_GROUP, " + "QRTZ_JOB_DETAILS.JOB_CLASS_NAME, " +
    "QRTZ_TRIGGERS.TRIGGER_NAME, " + "QRTZ_TRIGGERS.TRIGGER_GROUP, " + "QRTZ_CRON_TRIGGERS.CRON_EXPRESSION, " + "QRTZ_CRON_TRIGGERS.TIME_ZONE_ID "
            + "FROM " + "QRTZ_JOB_DETAILS " + "JOIN QRTZ_TRIGGERS " + "JOIN QRTZ_CRON_TRIGGERS ON QRTZ_JOB_DETAILS.JOB_NAME = QRTZ_TRIGGERS.JOB_NAME "
            + "AND QRTZ_TRIGGERS.TRIGGER_NAME = QRTZ_CRON_TRIGGERS.TRIGGER_NAME " + "AND QRTZ_TRIGGERS.TRIGGER_GROUP = QRTZ_CRON_TRIGGERS.TRIGGER_GROUP")
    public List<JobAndTrigger> getJobAndTriggerDetails();
}

4.quartz定时任务设置job层

我们的job任务继承Job

package com.whale.doteonme.web.module.web.quartz.job;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;


public interface BaseJob extends Job {
    public void execute(JobExecutionContext context) throws JobExecutionException;
}

我们实例化的job任务实现上一步的job接口 ---- 有空指针异常,原因在于quartz定时没有提供注入类对象到工厂中

package com.whale.doteonme.web.module.web.quartz.job;

import com.whale.doteonme.web.common.constant.Constant;
import com.whale.doteonme.web.common.util.JsonUtil;
import com.whale.doteonme.web.module.web.donation.dao.PmDonationMatchMapper;
import com.whale.doteonme.web.module.web.donation.model.PmDonationMatch;
import org.apache.commons.lang.time.DateUtils;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import javax.annotation.Resource;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


public class DonationJob implements BaseJob{

    @Resource
    PmDonationMatchMapper pmDonationMatchMapper;  //这里之前会出现null值,原因是没有注入到Jobfactory工厂

    public DonationJob(){}
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        String value = pmDonationMatchMapper.selectProperty(1);
}

5.quartz定时任务的配置quartz层

JobFactory工厂

package com.whale.doteonme.web.module.web.quartz.quartz;

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.AdaptableJobFactory;
import org.springframework.stereotype.Component;

@Component
public class JobFactory extends AdaptableJobFactory {
    /**
     * AutowireCapableBeanFactory接口是BeanFactory的子类
     * 可以连接和填充那些生命周期不被Spring管理的已存在的bean实例
     */
    private AutowireCapableBeanFactory factory;
    public JobFactory(AutowireCapableBeanFactory factory){
        this.factory = factory;
    }
    /**
     * 创建Job实例
     */
    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        // 实例化对象
        Object job = super.createJobInstance(bundle);
        // 进行注入（Spring管理该Bean）
        factory.autowireBean(job);
        //返回对象
        return job;
    }
}

SchedulerConfig

package com.whale.doteonme.web.module.web.quartz.quartz;


import org.quartz.Scheduler;
import org.quartz.ee.servlet.QuartzInitializerListener;
import org.springframework.beans.factory.annotation.Qualifier;
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 java.io.IOException;
import java.util.Properties;

@Configuration
public class SchedulerConfig {

    private JobFactory jobFactory;

    public SchedulerConfig(JobFactory jobFactory){
        this.jobFactory = jobFactory;
    }

    /**
     * 调度器工厂对象,并设置quartz属性
     * @param quartzProperties
     * @return
     * @throws IOException
     */
    @Bean(name = "SchedulerFactory")
    public SchedulerFactoryBean schedulerFactoryBean(@Qualifier("quartzProperties")
                                                     Properties quartzProperties) throws IOException{
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setQuartzProperties(quartzProperties);
        factory.setJobFactory(jobFactory);
        return factory;
    }

    /**
     * 加载quartz的配置
     * @return
     * @throws IOException
     */
    @Bean
    public Properties quartzProperties() throws IOException{
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        //在quartz.properties中的属性被读取并注入后再初始化对象
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }

    /**
     * quartz初始化监听器
     * @return
     */
    @Bean(name = "quartz.properties")
    public QuartzInitializerListener executorListener(){
        return new QuartzInitializerListener();
    }

    /**
     * 通过SchedulerFactoryBean获取Scheduler 调度器的实例
     * @param schedulerFactoryBean
     * @return
     * @throws IOException
     */
    @Bean(name = "Scheduler")
    public Scheduler scheduler(SchedulerFactoryBean schedulerFactoryBean) throws IOException{
        return schedulerFactoryBean.getScheduler();
    }
}

6.quartz定时任务的配置service层(非必须但必要)

service的接口

package com.whale.doteonme.web.module.web.quartz.service;


import com.github.pagehelper.PageInfo;
import com.whale.doteonme.web.module.web.quartz.pojo.JobAndTrigger;

public interface IJobAndTriggerService {
    public PageInfo<JobAndTrigger> getJobAndTriggerDetails(int pageNum, int pageSize);
}

serviceImpl实现层

package com.whale.doteonme.web.module.web.quartz.service.impl;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.whale.doteonme.web.module.web.quartz.dao.JobAndTriggerMapper;
import com.whale.doteonme.web.module.web.quartz.pojo.JobAndTrigger;
import com.whale.doteonme.web.module.web.quartz.service.IJobAndTriggerService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;

@Service
public class JobAndTriggerImpl implements IJobAndTriggerService {
    @Resource
    private JobAndTriggerMapper jobAndTriggerMapper;

    /**
     * 获取定时信息
     * @param pageNum
     * @param pageSize
     * @return
     */
    @Override
    public PageInfo<JobAndTrigger> getJobAndTriggerDetails(int pageNum, int pageSize) {
        PageHelper.startPage(pageNum,pageSize);
        List<JobAndTrigger> list = jobAndTriggerMapper.getJobAndTriggerDetails();
        PageInfo<JobAndTrigger> info = new PageInfo<>(list);
        return info;
    }
}

7.quartz定时的controller层

package com.whale.doteonme.web.module.web.quartz.controller;


import com.github.pagehelper.PageInfo;
import com.whale.doteonme.web.module.web.quartz.job.BaseJob;
import com.whale.doteonme.web.module.web.quartz.pojo.JobAndTrigger;
import com.whale.doteonme.web.module.web.quartz.service.IJobAndTriggerService;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.Map;

@RestController
@RequestMapping(value = "/job")
public class JobController {
    @Autowired
    private IJobAndTriggerService iJobAndTriggerService;

    //加入Qulifier注解,通过名称注入bean
    @Autowired
    @Qualifier("Scheduler")
    private Scheduler scheduler;

    /**
     * 增加  请求路径:
     * @param jobClassName
     * @param jobGroupName
     * @param cronExpression
     * @throws Exception
     */
    @PostMapping(value = "/addJob")
    public void addjob(@RequestParam(value = "jobClassName") String jobClassName,
                       @RequestParam(value = "jobGroupName") String jobGroupName,
                       @RequestParam(value = "cronExpression") String cronExpression) throws Exception{
        addJob(jobClassName,jobGroupName,cronExpression);
    }
    public void addJob(String jobClassName,String jobGroupName,String cronExpression) throws Exception{
        //启动调度器
        scheduler.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 {
            scheduler.scheduleJob(jobDetail,trigger);
        } catch (SchedulerException e){
            System.out.println("创建定时任务失败"+e);
            throw new Exception("创建定时任务失败");
        }
    }

    /**
     * 暂停
     * @param jobClassName
     * @param jobGroupName
     * @throws Exception
     */
    @PostMapping(value = "/pausejob")
    public void pausejob(@RequestParam(value = "jobClassName") String jobClassName, @RequestParam(value = "jobGroupName") String jobGroupName)
        throws Exception {
        jobPause(jobClassName,jobGroupName);
    }

    public void jobPause(String jobClassName,String jobGroupName) throws Exception{
        scheduler.pauseJob(JobKey.jobKey(jobClassName,jobGroupName));
    }

    /**
     * 继续
     * @param jobClassName
     * @param jobGroupName
     * @throws Exception
     */
    @PostMapping(value = "/resumejob")
    public void resumejob(@RequestParam(value = "jobClassName") String jobClassName,
                          @RequestParam(value = "jobGroupName") String jobGroupName) throws Exception{
        jobresume(jobClassName,jobGroupName);
    }

    public void jobresume(String jobClassName,String jobGroupName) throws Exception{
        scheduler.resumeJob(JobKey.jobKey(jobClassName,jobGroupName));
    }

    /**
     * 更新任务
     * @param jobClassName
     * @param jobGroupName
     * @param cronExpression
     * @throws Exception
     */
    @PostMapping(value = "/reschedulejob")
    public void rescheduleJob(@RequestParam(value = "jobClassName") String jobClassName,
                              @RequestParam(value = "jobGroupName") String jobGroupName,
                              @RequestParam(value = "cronExpression") String cronExpression) throws Exception{
        jobreschedule(jobClassName,jobGroupName,cronExpression);
    }

    public void jobreschedule(String jobClassName,String jobGroupName,String cronExpression) throws Exception{
        try {
            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("更新定时任务失败");
        }
    }

    /**
     * 删除任务
     * @param jobClassName
     * @param jobGroupName
     * @throws Exception
     */
    @PostMapping(value = "/deletejob")
    public void deletejob(@RequestParam(value = "jobClassName") String jobClassName,
                          @RequestParam(value = "jobGroupName") String jobGroupName) throws Exception{
        jobdelete(jobClassName,jobGroupName);
    }

    public void jobdelete(String jobClassName,String jobGroupName) throws Exception{
        scheduler.pauseTrigger(TriggerKey.triggerKey(jobClassName,jobGroupName));
        scheduler.unscheduleJob(TriggerKey.triggerKey(jobClassName,jobGroupName));
        scheduler.deleteJob(JobKey.jobKey(jobClassName,jobGroupName));
    }

    /**
     * 查询所有的job  非必须但必要
     * @param pageNum
     * @param pageSize
     * @return
     */
    @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 BaseJob getClass(String classname) throws Exception{
        Class<?> class1 = Class.forName(classname);
        return (BaseJob) class1.newInstance();
    }
}

7.quartz定时的controller层的请求方式

add: localhost:8083/job/addJob?jobClassName=com.whale.doteonme.web.module.web.quartz.job.DonationJob&jobGroupName=group1&cronExpression=*/40 * * * * ?

delete:localhost:8083/job/deletejob?jobClassName=com.whale.doteonme.web.module.web.quartz.job.DonationJob&jobGroupName=group1

其他的操作请求类似.

8.quartz定时的依赖pom.xml层

		<!--quartz定时-->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.3.0</version>
        </dependency>
        <!--spring支持quartz定时-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>

9.quartz定时的quartz.properties配置

org.quartz.scheduler.instanceName = DefaultQuartzScheduler
org.quartz.scheduler.rmi.export = false
org.quartz.scheduler.rmi.proxy = false
org.quartz.scheduler.wrapJobExecutionInUserTransaction = false
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
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.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://192.168.1.168:3306/doteonme_quartz?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&useSSL=false
org.quartz.dataSource.qzDS.user = root
org.quartz.dataSource.qzDS.password = root
org.quartz.dataSource.qzDS.maxConnections = 10

10.application.yml文件配置

server:
  port: 80
  tomcat:
    uri-encoding: utf-8
mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: top.javai.www.pojo
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.1.168:3306/doteonme_two?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&useSSL=false
    username: root
    password: root

11.启动类

package top.javai.www;


import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@MapperScan("com.whale.doteonme.web.module.web.*.dao")
@SpringBootApplication(scanBasePackages = {"com.whale.doteonme.web.module.web"})
public class DemoApplication {
    public static void main(String[] args){
        SpringApplication.run(DemoApplication.class,args);
    }
}

​

​

​