springboot 整合 quartz定时任务 学习

springboot + quartz定时任务 学习

第一步：

引入依赖：

              <!-- quartz 模块 -->
		      <!-- c3p0 -->
	        	<dependency>
		            	<groupId>com.mchange</groupId>
			            <artifactId>mchange-commons-java</artifactId>
		           	    <version>0.2.11</version>
		        </dependency>
	        	<dependency>
		               	<groupId>c3p0</groupId>
	            		<artifactId>c3p0</artifactId>
			            <version>0.9.1.2</version>
		        </dependency>
		        <dependency>
		            	<groupId>org.quartz-scheduler</groupId>
			            <artifactId>quartz</artifactId>
			            <version>2.2.3</version>
		        </dependency>
		        <dependency>
			            <groupId>org.quartz-scheduler</groupId>
		            	<artifactId>quartz-jobs</artifactId>
		            	<version>2.2.3</version>
		        </dependency>
     

第二步：quartz.properties文件配置

#默认或是自己改名字都行
org.quartz.scheduler.instanceName = myQuartz
#如果使用集群，instanceId必须唯一，设置成AUTO
org.quartz.scheduler.instanceId = AUTO
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 = 10
org.quartz.threadPool.threadPriority = 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true


#持久化配置
org.quartz.jobStore.misfireThreshold = 60000
#存储方式使用JobStoreTX，也就是数据库
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#使用weblogic连接Oracle驱动
#org.quartz.jobStore.driverDelegateClass: org.quartz.impl.jdbcjobstore.oracle.weblogic.WebLogicOracleDelegate

#是否使用集群（如果项目只部署到 一台服务器，就不用了）
org.quartz.jobStore.isClustered = true
#使用自己的配置文件
org.quartz.jobStore.useProperties = true
org.quartz.jobStore.clusterCheckinInterval = 20000

#数据库中quartz表的表名前缀
org.quartz.jobStore.tablePrefix = qrtz_
org.quartz.jobStore.dataSource = shiro-learning


#配置数据源,quartz默认使用c3p0数据源可以被自定义数据源覆盖
org.quartz.dataSource.shiro-learning.driver = com.mysql.jdbc.Driver
org.quartz.dataSource.shiro-learning.URL = jdbc:mysql://127.0.0.1:3306/shiro-learning
org.quartz.dataSource.shiro-learning.user = root
org.quartz.dataSource.shiro-learning.password = 123456
org.quartz.dataSource.shiro-learning.maxConnections = 10

第三步：表 schedule_table.sql 共11张表 ，我用的mysql的数据库

  SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for qrtz_blob_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_blob_triggers`;
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,
  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`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for qrtz_calendars
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_calendars`;
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`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for qrtz_cron_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_cron_triggers`;
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) DEFAULT 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`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for qrtz_fired_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_fired_triggers`;
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(11) NOT NULL,
  `STATE` varchar(16) NOT NULL,
  `JOB_NAME` varchar(200) DEFAULT NULL,
  `JOB_GROUP` varchar(200) DEFAULT NULL,
  `IS_NONCONCURRENT` varchar(1) DEFAULT NULL,
  `REQUESTS_RECOVERY` varchar(1) DEFAULT NULL,
  PRIMARY KEY (`SCHED_NAME`,`ENTRY_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for qrtz_job_details
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_job_details`;
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) DEFAULT 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,
  PRIMARY KEY (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for qrtz_locks
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_locks`;
CREATE TABLE `qrtz_locks` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `LOCK_NAME` varchar(40) NOT NULL,
  PRIMARY KEY (`SCHED_NAME`,`LOCK_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for qrtz_paused_trigger_grps
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_paused_trigger_grps`;
CREATE TABLE `qrtz_paused_trigger_grps` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_GROUP` varchar(200) NOT NULL,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for qrtz_scheduler_state
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_scheduler_state`;
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`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for qrtz_simple_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_simple_triggers`;
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`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for qrtz_simprop_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_simprop_triggers`;
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) DEFAULT NULL,
  `STR_PROP_2` varchar(512) DEFAULT NULL,
  `STR_PROP_3` varchar(512) DEFAULT NULL,
  `INT_PROP_1` int(11) DEFAULT NULL,
  `INT_PROP_2` int(11) DEFAULT NULL,
  `LONG_PROP_1` bigint(20) DEFAULT NULL,
  `LONG_PROP_2` bigint(20) DEFAULT NULL,
  `DEC_PROP_1` decimal(13,4) DEFAULT NULL,
  `DEC_PROP_2` decimal(13,4) DEFAULT NULL,
  `BOOL_PROP_1` varchar(1) DEFAULT NULL,
  `BOOL_PROP_2` varchar(1) DEFAULT 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`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for qrtz_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_triggers`;
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) DEFAULT NULL,
  `NEXT_FIRE_TIME` bigint(13) DEFAULT NULL,
  `PREV_FIRE_TIME` bigint(13) DEFAULT NULL,
  `PRIORITY` int(11) DEFAULT NULL,
  `TRIGGER_STATE` varchar(16) NOT NULL,
  `TRIGGER_TYPE` varchar(8) NOT NULL,
  `START_TIME` bigint(13) NOT NULL,
  `END_TIME` bigint(13) DEFAULT NULL,
  `CALENDAR_NAME` varchar(200) DEFAULT NULL,
  `MISFIRE_INSTR` smallint(2) DEFAULT NULL,
  `JOB_DATA` blob,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  KEY `SCHED_NAME` (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
  CONSTRAINT `QRTZ_TRIGGERS_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`) REFERENCES `qrtz_job_details` (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

第四步：新建一个定时任务的存储的表，app_quartz

CREATE TABLE `app_quartz` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `job_name` varchar(255) DEFAULT NULL,
  `job_group` varchar(255) DEFAULT NULL,
  `job_description` varchar(255) DEFAULT NULL,
  `job_class_name` varchar(255) DEFAULT NULL,
  `cronExpression` varchar(255) DEFAULT NULL,
  `status` varchar(255) DEFAULT NULL,
  `old_job_name` varchar(255) DEFAULT NULL,
  `old_job_group` varchar(255) DEFAULT NULL,
  `invokeParam` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;

 /**
       * 任务类
       * 存放定时任务基本信息和描述等信息
      */
    public class AppQuartz implements Serializable{

    private Integer id;

    private String jobName;//任务名称

    private String jobGroup;//任务分组

    private String jobDescription;//任务描述

    private String jobClassName;//执行类

    private String cronExpression;//执行时间

    private String status;//任务状态 0：禁用   1：启用

    private String oldJobName;//任务名称 用于修改

    private String oldJobGroup;//任务分组 用于修改

    private String invokeParam;//需要传递的参数

    省略get，set方法

创建job 实例工厂JobFactory

 package com.shiro_learning.demo.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;

    /**
     * 创建job 实例工厂，解决spring注入问题，如果使用默认会导致spring的@Autowired 无法注入问题
     */
    @Component
    public class JobFactory extends AdaptableJobFactory{

     @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;

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

创建定时任务配置类 SchedulerConfig

package com.shiro_learning.demo.config.quartz;

    import org.quartz.Scheduler;
    import org.quartz.ee.servlet.QuartzInitializerListener;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.beans.factory.config.PropertiesFactoryBean;
    import org.springframework.context.ApplicationListener;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.event.ContextRefreshedEvent;
    import org.springframework.core.io.ClassPathResource;
    import org.springframework.scheduling.quartz.SchedulerFactoryBean;
    import javax.sql.DataSource;
    import java.io.IOException;
    import java.util.Properties;

    @Configuration
    public class SchedulerConfig implements ApplicationListener<ContextRefreshedEvent> {

    @Autowired
    private JobFactory jobFactory;//自定义的factory

    @Autowired
    @Qualifier("dataSource")
    private DataSource primaryDataSource;

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        System.out.println("任务已经启动..."+event.getSource());
    }

    /**
     * 获取工厂的bean
     * @return
     * @throws IOException
     */
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
        //获取配置属性
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        //在quartz.properties中的属性被读取并注入后再初始化对象
        propertiesFactoryBean.afterPropertiesSet();
        Properties properties = propertiesFactoryBean.getObject();
        //创建SchedulerFactoryBean
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setQuartzProperties(properties);
        //使用数据源，自定义数据源
        factory.setDataSource(this.primaryDataSource);
        factory.setJobFactory(jobFactory);
        factory.setWaitForJobsToCompleteOnShutdown(true);//这样当spring关闭时，会等待所有已经启动的quartz job结束后spring才能完全shutdown。
        factory.setOverwriteExistingJobs(false);
        //延时2秒启动
        factory.setStartupDelay(2);
        return factory;
    }


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


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

业务demo

controller：

package com.shiro_learning.demo.controller;

    import com.shiro_learning.demo.entity.AppQuartz;
    import com.shiro_learning.demo.service.IQuartzService;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;

    @Controller
    @RequestMapping("/quartz")
    public class QuartzController {
    private static Logger logger = LoggerFactory.getLogger(QuartzController.class);
    @Autowired
    private IQuartzService iQuartzService;

    /**
     * 新建任务
     * @param appQuartz
     */
    @RequestMapping(value = "/allJob", method = RequestMethod.GET)
    public void allJob(AppQuartz appQuartz) {
        //保存定时任务基本信息和描述等信AppQuartz appQuartz息
        iQuartzService.insertAppQuartz(appQuartz);
        //添加任务
        iQuartzService.addJob(appQuartz);
    }


    /**
     * 测试
     */
    @RequestMapping(value = "/test", method = RequestMethod.GET)
    public void test() {
        AppQuartz appQuartz = new AppQuartz();
        logger.info("add electricity schedule ......");
        appQuartz.setCronExpression("*/5 * * * * ?");//每隔5s执行一次
        appQuartz.setJobName("test");
        appQuartz.setJobClassName("TestJob");//定时任务执行的类
        appQuartz.setInvokeParam("");
        appQuartz.setJobGroup("test");
        appQuartz.setJobDescription("test");
        iQuartzService.insertAppQuartz(appQuartz);
        iQuartzService.addJob(appQuartz);
      }
    }

service接口:

 package com.shiro_learning.demo.service;

    import com.shiro_learning.demo.entity.AppQuartz;

    public interface IQuartzService {
           public void insertAppQuartz(AppQuartz appQuartz);
           public void addJob(AppQuartz appQuartz);
    }

service实现类：

 package com.shiro_learning.demo.service.impl;

     import com.baomidou.mybatisplus.service.impl.ServiceImpl;
     import com.shiro_learning.demo.dao.IQuartzMapper;
     import com.shiro_learning.demo.entity.AppQuartz;
     import com.shiro_learning.demo.service.IQuartzService;
     import org.apache.commons.lang3.StringUtils;
     import org.quartz.*;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.beans.factory.annotation.Qualifier;
     import org.springframework.stereotype.Service;

    @Service
    public class IQuartzServiceImpl implements IQuartzService {
    private static Logger logger = LoggerFactory.getLogger(IQuartzServiceImpl.class);

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

    @Autowired
    private IQuartzMapper iQuartzMapper;


    @Override
    public void insertAppQuartz(AppQuartz appQuartz) {
        iQuartzMapper.insertAppQuartz(appQuartz);
    }

    /**
     * 添加任务
     * @param appQuartz
     */
    @Override
    public void addJob(AppQuartz appQuartz) {
        logger.debug("添加任务："+appQuartz.toString());
        try{
            String jobName = appQuartz.getJobName();
            String jobGroup = appQuartz.getJobGroup();
            String jobDescription = appQuartz.getJobDescription();
            String jobClassName = "com.shiro_learning.demo.job."+appQuartz.getJobClassName();//包名+类名
            /**
             * 获取Scheduler实例、使用自动注入的scheduler、否则spring的service将无法注入
             * 如果是修改 ,展示旧的任务,再删除
             */
            if(StringUtils.isNotEmpty(appQuartz.getOldJobGroup())){
                JobKey jobKey = new JobKey(appQuartz.getJobName(),appQuartz.getOldJobGroup());
                scheduler.deleteJob(jobKey);
            }
            //任务执行类
            Class cls = Class.forName(jobClassName);
            cls.newInstance();

            //构建任务详情
            JobDetail jobDetail = JobBuilder.newJob(cls).withIdentity("jobDetail"+jobName,"jobDetail"+jobGroup).withDescription(jobDescription).build();

            //传参数
            jobDetail.getJobDataMap().put("job_data", appQuartz.getInvokeParam());

            //触发时间点
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(appQuartz.getCronExpression());

            // 创建Trigger对象
            Trigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger"+jobName,"trigger"+jobGroup).startNow().withSchedule(cronScheduleBuilder).build();

            //调度容器设置JobDetail和Trigger（交由Scheduler安排触发
            scheduler.scheduleJob(jobDetail,trigger);
            try {
                //启动
                if(!scheduler.isShutdown()){
                    scheduler.start();
                }
            }catch (SchedulerException e){
                logger.info("任务【"+appQuartz.getJobName()+"】添加失败！"+e.getMessage());
            }
        }catch (Exception e){
            e.printStackTrace();
        }
       }
    }

mapper：

 package com.shiro_learning.demo.dao;

    import com.shiro_learning.demo.entity.AppQuartz;
    import org.springframework.web.bind.annotation.RequestBody;

    //@Component
    //Mapper
    public interface IQuartzMapper {
          public void insertAppQuartz(@RequestBody AppQuartz appQuartz);
    }

xml：

 <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
    <mapper namespace="com.shiro_learning.demo.dao.IQuartzMapper" >
    <resultMap id="BaseResultMap" type="com.shiro_learning.demo.entity.AppQuartz" >
        <constructor >
            <idArg column="id" jdbcType="INTEGER" javaType="java.lang.Integer" />
            <arg column="job_name" jdbcType="VARCHAR" javaType="java.lang.String" />
            <arg column="job_group" jdbcType="VARCHAR" javaType="java.lang.String" />
            <arg column="job_description" jdbcType="VARCHAR" javaType="java.lang.String" />
            <arg column="job_class_name" jdbcType="VARCHAR" javaType="java.lang.String" />
            <arg column="cronExpression" jdbcType="VARCHAR" javaType="java.lang.String" />
            <arg column="status" jdbcType="VARCHAR" javaType="java.lang.String" />
            <arg column="old_job_name" jdbcType="VARCHAR" javaType="java.lang.String" />
            <arg column="old_job_group" jdbcType="VARCHAR" javaType="java.lang.String" />
            <arg column="invokeParam" jdbcType="VARCHAR" javaType="java.lang.String" />
        </constructor>
    </resultMap>
    <sql id="Base_Column_List" >
           id,
           job_name,
           job_group,
           job_description,
           job_class_name,
           cronExpression,
           status,
           old_job_name,
           old_job_group,
           invokeParam
    </sql>
   
    <insert id="insertAppQuartz" parameterType="com.shiro_learning.demo.entity.AppQuartz" >
        insert into app_quartz (
           id,
           job_name,
           job_group,
           job_description,
           job_class_name,
           cronExpression,
           status,
           old_job_name,
           old_job_group,
           invokeParam
        )
        values (
           #{id,jdbcType=INTEGER},
           #{jobName,jdbcType=VARCHAR},
           #{jobGroup,jdbcType=VARCHAR},
           #{jobDescription,jdbcType=VARCHAR},
           #{jobClassName,jdbcType=VARCHAR},
           #{cronExpression,jdbcType=VARCHAR},
           #{status,jdbcType=VARCHAR},
           #{oldJobName,jdbcType=VARCHAR},
           #{oldJobGroup,jdbcType=VARCHAR},
           #{invokeParam,jdbcType=VARCHAR}
        )
    </insert>

</mapper>

定时执行的类 Job

 package com.shiro_learning.demo.job;

    import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;

    /**
     * 定时任务测试job类
     */
    public class TestJob implements Job {
    private static Logger logger = LoggerFactory.getLogger(TestJob.class);

	@Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
           logger.info("任务执行成功");
       }
    }

测试结果

参考资料：

https://segmentfault.com/a/1190000016554033
https://www.cnblogs.com/drift-ice/p/3817269.html
https://blog.csdn.net/zzzffhh/article/details/80733729
https://www.cnblogs.com/superman66/p/4565723.html