首先引入jar包，版本统一由springboot-starter-parent管理

  1.         <dependency>
  2.             <groupId>org.quartz-scheduler</groupId>
  3.             <artifactId>quartz</artifactId>
  4.             <version>2.2.3</version>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>org.quartz-scheduler</groupId>
  8.             <artifactId>quartz-jobs</artifactId>
  9.             <version>2.2.3</version>
  10.         </dependency>
  11.         <dependency>
  12.             <groupId>org.springframework</groupId>
  13.             <artifactId>spring-context-support</artifactId>
  14.             <version>4.1.6.RELEASE</version>
  15.         </dependency>

编写配置类

工厂类JobFactory

  1. /**
  2.  * 定时任务工厂类配置
  3.  *
  4.  * @author lijun
  5.  * @date 2021/11/23 11:12
  6.  */
  7. @Component
  8. public class JobFactory extends AdaptableJobFactory implements ApplicationContextAware {
  10.     @Autowired
  11.     private transient AutowireCapableBeanFactory factory;
  13.     @Override
  14.     protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
  15.         // 实例化对象
  16.         Object job = super.createJobInstance(bundle);
  17.         // 进行注入（Spring管理该Bean）
  18.         factory.autowireBean(job);
  19.         //返回对象
  20.         return job;
  21.     }
  23.     @Override
  24.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  25.         factory = applicationContext.getAutowireCapableBeanFactory();
  26.     }
  27. }

注入工厂对象及任务调度对象

  1. /**
  2.  * 定时任务配置
  3.  *
  4.  * @author lijun
  5.  * @date 2021/11/23 11:18
  6.  */
  7. @Configuration
  8. public class QuartzConfig {
  10.     @Autowired
  11.     private JobFactory jobFactory;
  13.     //创建调度器工厂
  14.     @Bean(name = "SchedulerFactory")
  15.     public SchedulerFactoryBean schedulerFactoryBean(){
  16.         SchedulerFactoryBean factoryBean=new SchedulerFactoryBean();
  17.         factoryBean.setJobFactory(jobFactory);
  18.         return factoryBean;
  19.     }
  21.     @Bean(name = "scheduler")
  22.     public Scheduler scheduler() {
  23.         return schedulerFactoryBean().getScheduler();
  24.     }
  27. }

封装定时任务管理类 负责增加、删除、启动、暂停等功能

  1. /**
  2.  * 定时任务管理类 负责增加、删除、启动、暂停定时任务
  3.  * @author lijun
  4.  */
  5. @Component
  6. public class QuartzManager {
  8.     private static final Logger logger = LoggerFactory.getLogger(QuartzManager.class);
  10.     @Autowired
  11.     private Scheduler scheduler;
  12.     /**
  13.      * 任务组
  14.      */
  15.     private static String JOB_GROUP_NAME = "任务组";
  16.     /**
  17.      * 触发器组
  18.      */
  19.     private static String TRIGGER_GROUP_NAME = "触发器组";
  21.     /**
  22.      * 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名
  23.      *
  24.      * @param jobName
  25.      *            任务名
  26.      * @param cls
  27.      *            任务
  28.      * @param time
  29.      *            时间设置，参考quartz说明文档
  30.      */
  31.     public void addJob(String jobName, Class<? extends Job> cls, String time) {
  32.         try {
  33.             logger.info("构建作业实例......");
  34.             // 用于描叙Job实现类及其他的一些静态信息，构建一个作业实例
  35.             JobDetail jobDetail = JobBuilder.newJob(cls).withIdentity(jobName, JOB_GROUP_NAME).build();
  36.             logger.info("创建触发器......");
  37.             // 创建一个新的TriggerBuilder来规范一个触发器
  38.             CronTrigger trigger = (CronTrigger) TriggerBuilder.newTrigger()
  39.                     // 给触发器起一个名字和组名
  40.                     .withIdentity(jobName, TRIGGER_GROUP_NAME)
  41.                     .withSchedule(CronScheduleBuilder.cronSchedule(time)).build();
  42.             scheduler.scheduleJob(jobDetail, trigger);
  43.             if (!scheduler.isShutdown()) {
  44.                 scheduler.start(); // 启动
  45.             }
  46.         } catch (Exception e) {
  47.             shutdownJobs();
  48.             throw new RuntimeException(e);
  49.         }
  50.     }
  52.     /**
  53.      * 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名 （带参数）
  54.      *
  55.      * @param jobName
  56.      *            任务名
  57.      * @param cls
  58.      *            任务
  59.      * @param time
  60.      *            时间设置，参考quartz说明文档
  61.      */
  62.     public void addJob(String jobName, Class<? extends Job> cls, String time, Map<String, Object> parameter) {
  63.         try {
  64.             // 用于描叙Job实现类及其他的一些静态信息，构建一个作业实例
  65.             JobDetail jobDetail = JobBuilder.newJob(cls).withIdentity(jobName, JOB_GROUP_NAME).build();
  66.             // 传参数
  67.             jobDetail.getJobDataMap().put("parameterMap", parameter);
  68.             // 创建一个新的TriggerBuilder来规范一个触发器
  69.             CronTrigger trigger = (CronTrigger) TriggerBuilder.newTrigger()
  70.                     // 给触发器起一个名字和组名
  71.                     .withIdentity(jobName, TRIGGER_GROUP_NAME)
  72.                     .withSchedule(CronScheduleBuilder.cronSchedule(time)).build();
  73.             scheduler.scheduleJob(jobDetail, trigger);
  74.             if (!scheduler.isShutdown()) {
  75.                 // 启动
  76.                 scheduler.start();
  77.             }
  78.         } catch (Exception e) {
  79.             throw new RuntimeException(e);
  80.         }
  81.     }
  83.     /**
  84.      * 添加一个定时任务
  85.      *
  86.      * @param jobName
  87.      *            任务名
  88.      * @param jobGroupName
  89.      *            任务组名
  90.      * @param triggerName
  91.      *            触发器名
  92.      * @param triggerGroupName
  93.      *            触发器组名
  94.      * @param jobClass
  95.      *            任务
  96.      * @param time
  97.      *            时间设置，参考quartz说明文档
  98.      */
  99.     public void addJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName,
  100.                               Class<? extends Job> jobClass, String time) {
  101.         try {
  102.             // 任务名，任务组，任务执行类
  103.             JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
  104.             // 触发器
  105.             CronTrigger trigger = (CronTrigger) TriggerBuilder
  106.                     .newTrigger().withIdentity(triggerName, triggerGroupName)
  107.                     .withSchedule(CronScheduleBuilder.cronSchedule(time)).build();
  108.             scheduler.scheduleJob(jobDetail, trigger);
  109.             if (!scheduler.isShutdown()) {
  110.                 // 启动
  111.                 scheduler.start();
  112.             }
  113.         } catch (Exception e) {
  114.             throw new RuntimeException(e);
  115.         }
  116.     }
  118.     /**
  119.      * 添加一个定时任务 （带参数）
  120.      *
  121.      * @param jobName
  122.      *            任务名
  123.      * @param jobGroupName
  124.      *            任务组名
  125.      * @param triggerName
  126.      *            触发器名
  127.      * @param triggerGroupName
  128.      *            触发器组名
  129.      * @param jobClass
  130.      *            任务
  131.      * @param time
  132.      *            时间设置，参考quartz说明文档
  133.      */
  134.     public void addJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName,
  135.                               Class<? extends Job> jobClass, String time, Map<String, Object> parameter) {
  136.         try {
  137.             JobDetail jobDetail = JobBuilder.newJob((Class<? extends Job>) jobClass).withIdentity(jobName, jobGroupName)
  138.                     // 任务名，任务组，任务执行类
  139.                     .build();
  140.             // 传参数
  141.             jobDetail.getJobDataMap().put("parameterMap", parameter);
  142.             // 触发器
  143.             CronTrigger trigger = (CronTrigger) TriggerBuilder
  144.                     .newTrigger().withIdentity(triggerName, triggerGroupName)
  145.                     .withSchedule(CronScheduleBuilder.cronSchedule(time)).build();
  146.             scheduler.scheduleJob(jobDetail, trigger);
  147.             if (!scheduler.isShutdown()) {
  148.                 scheduler.start(); // 启动
  149.             }
  150.         } catch (Exception e) {
  151.             throw new RuntimeException(e);
  152.         }
  153.     }
  155.     /**
  156.      * 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名)
  157.      *
  158.      * @param jobName
  159.      *            任务名
  160.      * @param time
  161.      *            新的时间设置
  162.      */
  163.     public void modifyJobTime(String jobName, String time) {
  164.         try {
  165.             // 通过触发器名和组名获取TriggerKey
  166.             TriggerKey triggerKey = TriggerKey.triggerKey(jobName, TRIGGER_GROUP_NAME);
  167.             // 通过TriggerKey获取CronTrigger
  168.             CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
  169.             if (trigger == null) {
  170.                 return;
  171.             }
  172.             String oldTime = trigger.getCronExpression();
  173.             if (!oldTime.equalsIgnoreCase(time)) {
  174.                 // 通过任务名和组名获取JobKey
  175.                 JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
  176.                 JobDetail jobDetail = scheduler.getJobDetail(jobKey);
  177.                 Class<? extends Job> objJobClass = jobDetail.getJobClass();
  178.                 removeJob(jobName);
  179.                 addJob(jobName, objJobClass, time);
  180.             }
  181.         } catch (Exception e) {
  182.             throw new RuntimeException(e);
  183.         }
  184.     }
  186.     /**
  187.      * 修改一个任务的触发时间
  188.      *
  189.      * @param triggerName
  190.      *            任务名称
  191.      * @param triggerGroupName
  192.      *            传过来的任务名称
  193.      * @param time
  194.      *            更新后的时间规则
  195.      */
  196.     public void modifyJobTime(String triggerName, String triggerGroupName, String time) {
  197.         try {
  198.             // 通过触发器名和组名获取TriggerKey
  199.             TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
  200.             // 通过TriggerKey获取CronTrigger
  201.             CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
  202.             if (trigger == null) {
  203.                 return;
  204.             }
  205.             CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(trigger.getCronExpression());
  206.             String oldTime = trigger.getCronExpression();
  207.             if (!oldTime.equalsIgnoreCase(time)) {
  208.                 // 重新构建trigger
  209.                 trigger = (CronTrigger) trigger.getTriggerBuilder()
  210.                         .withIdentity(triggerKey).withSchedule(scheduleBuilder)
  211.                         .withSchedule(CronScheduleBuilder.cronSchedule(time)).build();
  212.                 // 按新的trigger重新设置job执行
  213.                 scheduler.rescheduleJob(triggerKey, trigger);
  214.             }
  215.         } catch (Exception e) {
  216.             throw new RuntimeException(e);
  217.         }
  218.     }
  220.     /**
  221.      * 移除一个任务(使用默认的任务组名，触发器名，触发器组名)
  222.      *
  223.      * @param jobName
  224.      *            任务名称
  225.      */
  226.     public void removeJob(String jobName) {
  227.         try {
  228.             // 通过触发器名和组名获取TriggerKey
  229.             TriggerKey triggerKey = TriggerKey.triggerKey(jobName, TRIGGER_GROUP_NAME);
  230.             // 通过任务名和组名获取JobKey
  231.             JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
  232.             // 停止触发器
  233.             scheduler.pauseTrigger(triggerKey);
  234.             // 移除触发器
  235.             scheduler.unscheduleJob(triggerKey);
  236.             // 删除任务
  237.             scheduler.deleteJob(jobKey);
  238.         } catch (Exception e) {
  239.             throw new RuntimeException(e);
  240.         }
  241.     }
  243.     /**
  244.      * 移除一个任务
  245.      *
  246.      * @param jobName
  247.      *            任务名
  248.      * @param jobGroupName
  249.      *            任务组名
  250.      * @param triggerName
  251.      *            触发器名
  252.      * @param triggerGroupName
  253.      *            触发器组名
  254.      */
  255.     public void removeJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName) {
  256.         try {
  257.             // 通过触发器名和组名获取TriggerKey
  258.             TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
  259.             // 通过任务名和组名获取JobKey
  260.             JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
  261.             // 停止触发器
  262.             scheduler.pauseTrigger(triggerKey);
  263.             // 移除触发器
  264.             scheduler.unscheduleJob(triggerKey);
  265.             // 删除任务
  266.             scheduler.deleteJob(jobKey);
  267.         } catch (Exception e) {
  268.             throw new RuntimeException(e);
  269.         }
  270.     }
  272.     /**
  273.      * 启动所有定时任务
  274.      */
  275.     public void startJobs() {
  276.         try {
  277.             logger.info("启动定时器......");
  278.             scheduler.start();
  279.         } catch (Exception e) {
  280.             throw new RuntimeException(e);
  281.         }
  282.     }
  284.     /**
  285.      * 关闭所有定时任务
  286.      */
  287.     public void shutdownJobs() {
  288.         try {
  289.             if (!scheduler.isShutdown()) {
  290.                 logger.info("关闭定时器......");
  291.                 scheduler.shutdown();
  292.             }
  293.         } catch (Exception e) {
  294.             throw new RuntimeException(e);
  295.         }
  296.     }
  298. }

定时任务的增删停止，此处添加定时任务方法都是通过传入自己实现的Job类，然后反射创建对象，构造JobDetail（同一个Job构造的是不同的JobDetail）,最后用schedule调度任务

定时任务类

  1. /**
  2.  * 定时任务获取参数实例且执行任务
  3.  *
  4.  * @author lijun
  5.  * @date 2021/8/17 14:29
  6.  */
  7. @Component
  8. public class MyJob implements Job {
  10.     @Resource
  11.     private TaskJob taskJob;
  13.     @Override
  14.     public void execute(JobExecutionContext context) throws JobExecutionException {
  15.         JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
  16.         Map<String,Object> parameterMap = (Map<String,Object>)jobDataMap.get("parameterMap");
  17.         String type = (String)parameterMap.get("type");
  18.         if("task1".equals(type)){
  19.             taskJob.task1();
  20.         }else if("task2".equals(type)){
  21.             taskJob.task2();
  22.         }
  23.     }
  24. }

TaskJob类

  1. /**
  2.  * 公共 定时任务 类
  3.  *
  4.  * @author lijun
  5.  * @date 2021/11/25 9:34
  6.  */
  7. @Service
  8. public class TaskJob {
  11.     @Resource
  12.     CommonMapper commonMapper;
  14.     public void task1(){
  15.         //需要执行的业务
  16.         List<Object> list = commonMapper.selectTask1();
  17.     }
  19.     public void task2(){
  20.         //需要执行的业务
  21.         List<Object> list = commonMapper.selectTask2();
  22.     }
  24. }

手动设置时间并且启动任务

  1. Map<String,Object> params= new HashMap<>(4);
  2. params.put("type","task1");
  3. //两分钟执行一次
  4. quartzManager.addJob("task1", MyJob.class,"0 */2 * * * ?",params);

自动启动任务

  1. /**
  2.  * 启动监听类
  3.  *
  4.  * @author lijun
  5.  * @date 2021/11/25 9:56
  6.  */
  7. @Slf4j
  8. @Component
  9. public class StartListener implements ApplicationListener<ApplicationStartedEvent> {
  12.     @Resource
  13.     private QuartzManager quartzManager;
  15.     /**
  16.      * 监听项目启动时运行定时任务
  17.      *
  18.      * @param event the event to respond to
  19.      */
  20.     @Override
  21.     public void onApplicationEvent(ApplicationStartedEvent event) {
  22.         log.info("定时程序启动:"+ DateUtil.dateToString(new Date(), SystemConstant.TIME_PATTEN));
  23.         synDepartData();
  24.         synPersonData();
  25.     }
  27.     public void synDepartData(){
  28.         Map<String,Object> params= new HashMap<>(4);
  29.         params.put("type","task1");
  30.         quartzManager.addJob("task1", MyJob.class,"0 0 18 * * ?",params);
  31. //        quartzManager.addJob("synDepartData", MyJob.class,"0 */2 * * * ?",params);
  32.     }
  34.     public void synPersonData(){
  35.         Map<String,Object> params= new HashMap<>(4);
  36.         params.put("type","task2");
  37.         quartzManager.addJob("task2", MyJob.class,"0 0 18 * * ?",params);
  38. //        quartzManager.addJob("synPersonData", MyJob.class,"0 */2 * * * ?",params);
  39.     }
  41. }

参考地址：
springboot+Quartz开机启动定时任务，cron可配置