当前位置: 开发笔记 > 运维 > 正文

springboot+Quartz实现任务调度的示例代码

作者：天气不再变化_207 | 来源：互联网 | 2021-12-01 00:46

在spring框架中通过 @Schedule 可以实现定时任务，通过该注解 cron 的属性描述的规则，spring会去调用这个方法。 s

在spring框架中通过 @Schedule 可以实现定时任务，通过该注解 cron 的属性描述的规则，spring会去调用这个方法。

spring已经简单粗暴的实现了定时任务，为什么要使用Quartz ？

如果你现在有很多个定时任务，规则不同，例如:

想每月25号，信用卡自动还款
想每年4月1日自己给当年暗恋女神发一封匿名贺卡
想每隔1小时，备份一下自己的爱情动作片学习笔记到云盘

maven 依赖


   org.quartz-scheduler
   quartz
   2.2.1
 
 
   org.quartz-scheduler
   quartz-jobs
   2.2.1

以下是bootdo开源学习框架的源码

我并没有用到全部的字段，思路是先查询DB，

封装以下两个对象

JobDetail 负责存放 job 所需要的数据
Trigger 设置 job 的 key，规则（cron）何时开启任务等属性

当触发条件满足时，会根据所设置的beanClass 找到该类（必须实现org.quartz.Job），这时可以取出JobDetail 中的数据，执行具体业务逻辑

@Component
public class WelcomeJob implements Job{
  @Override
  public void execute(JobExecutionContext arg0) throws JobExecutionException {
    //你的业务逻辑
  }
}

表结构

CREATE TABLE `sys_task` (
 `id` bigint(20) NOT NULL AUTO_INCREMENT,
 `cronExpression` varchar(255) DEFAULT NULL COMMENT 'cron表达式',
 `methodName` varchar(255) DEFAULT NULL COMMENT '任务调用的方法名',
 `isConcurrent` varchar(255) DEFAULT NULL COMMENT '任务是否有状态',
 `description` varchar(255) DEFAULT NULL COMMENT '任务描述',
 `updateBy` varchar(64) DEFAULT NULL COMMENT '更新者',
 `beanClass` varchar(255) DEFAULT NULL COMMENT '任务执行时调用哪个类的方法 包名+类名',
 `createDate` datetime DEFAULT NULL COMMENT '创建时间',
 `jobStatus` varchar(255) DEFAULT NULL COMMENT '任务状态',
 `jobGroup` varchar(255) DEFAULT NULL COMMENT '任务分组',
 `updateDate` datetime DEFAULT NULL COMMENT '更新时间',
 `createBy` varchar(64) DEFAULT NULL COMMENT '创建者',
 `springBean` varchar(255) DEFAULT NULL COMMENT 'Spring bean',
 `jobName` varchar(255) DEFAULT NULL COMMENT '任务名',
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT;

配置类

import java.io.IOException;
import java.util.Properties;
import org.quartz.Scheduler;
import org.springframework.beans.factory.annotation.Autowired;
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 com.txgl.common.quartz.factory.JobFactory;
@Configuration
public class QuartzConfigration {

  @Autowired
  JobFactory jobFactory;

  @Bean
  public SchedulerFactoryBean schedulerFactoryBean() {
    SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
    try {
      schedulerFactoryBean.setOverwriteExistingJobs(true);
      schedulerFactoryBean.setQuartzProperties(quartzProperties());
      schedulerFactoryBean.setJobFactory(jobFactory);
    } catch (IOException e) {
      e.printStackTrace();
    }
    return schedulerFactoryBean;
  }

  // 指定quartz.properties
  @Bean
  public Properties quartzProperties() throws IOException {
    PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
    propertiesFactoryBean.setLocation(new ClassPathResource("/config/quartz.properties"));
    propertiesFactoryBean.afterPropertiesSet();
    return propertiesFactoryBean.getObject();
  }

  // 创建schedule
  @Bean(name = "scheduler")
  public Scheduler scheduler() {
    return schedulerFactoryBean().getScheduler();
  }
}

QuartzManager的代码是关键，通过注入Scheduler 对任务进行操作

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import org.apache.log4j.Logger;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.DateBuilder;
import org.quartz.DateBuilder.IntervalUnit;
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.impl.matchers.GroupMatcher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Service;
import org.springframework.web.context.support.SpringBeanAutowiringSupport;
import com.bootdo.common.domain.ScheduleJob;
import com.bootdo.common.quartz.factory.*;
import com.bootdo.common.utils.SpringContextHolder;;

/**
 * 
 * 
 * @title: QuartzManager.java
 * @description: 计划任务管理
 *
 */
@Service
public class QuartzManager {
  public final Logger log = Logger.getLogger(this.getClass());
  // private SchedulerFactoryBean schedulerFactoryBean
  // =SpringContextHolder.getBean(SchedulerFactoryBean.class);
  // @Autowired
  // @Qualifier("schedulerFactoryBean")
  // private SchedulerFactoryBean schedulerFactoryBean;
  @Autowired
  private Scheduler scheduler;

  /**
   * 添加任务
   * 
   * @param scheduleJob
   * @throws SchedulerException
   */
  
  public void addJob(ScheduleJob job) {
    try {
      // 创建jobDetail实例，绑定Job实现类
      // 指明job的名称，所在组的名称，以及绑定job类
      Class<&＃63; extends Job> jobClass = (Class<&＃63; extends Job>) (Class.forName(job.getBeanClass()).newInstance()
          .getClass());
      JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(job.getJobName(), job.getJobGroup())// 任务名称和组构成任务key
          .build();
      // 定义调度触发规则
      // 使用cornTrigger规则
      Trigger trigger = TriggerBuilder.newTrigger().withIdentity(job.getJobName(), job.getJobGroup())// 触发器key
          .startAt(DateBuilder.futureDate(1, IntervalUnit.SECOND))
          .withSchedule(CronScheduleBuilder.cronSchedule(job.getCronExpression())).startNow().build();
      // 把作业和触发器注册到任务调度中
      scheduler.scheduleJob(jobDetail, trigger);
      // 启动
      if (!scheduler.isShutdown()) {
        scheduler.start();
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
// public void addJob(ScheduleJob job) throws SchedulerException {
//   if (job == null || !ScheduleJob.STATUS_RUNNING.equals(job.getJobStatus())) {
//     return;
//   }
//
//   TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName(), job.getJobGroup());
//
//   CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
//
//   // 不存在，创建一个
//
//   if (null == trigger) {
//     Class<&＃63; extends Job> clazz = ScheduleJob.CONCURRENT_IS.equals(job.getIsConcurrent())
//         &＃63; QuartzJobFactory.class
//         : QuartzJobFactoryDisallowConcurrentExecution.class;
//
//     JobDetail jobDetail = JobBuilder.newJob(clazz).withIdentity(job.getJobName(), job.getJobGroup()).build();
//
//     jobDetail.getJobDataMap().put("scheduleJob", job);
//
//     CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());
//
//     trigger = TriggerBuilder.newTrigger().withIdentity(job.getJobName(), job.getJobGroup())
//         .withSchedule(scheduleBuilder).build();
//
//     scheduler.scheduleJob(jobDetail, trigger);
//   } else {
//     // Trigger已存在，那么更新相应的定时设置
//
//     CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());
//
//     // 按新的cronExpression表达式重新构建trigger
//
//     trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
//
//     // 按新的trigger重新设置job执行
//
//     scheduler.rescheduleJob(triggerKey, trigger);
//   }
// }

  /**
   * 获取所有计划中的任务列表
   * 
   * @return
   * @throws SchedulerException
   */
  public List getAllJob() throws SchedulerException {
    GroupMatcher matcher = GroupMatcher.anyJobGroup();
    Set jobKeys = scheduler.getJobKeys(matcher);
    List jobList = new ArrayList();
    for (JobKey jobKey : jobKeys) {
      List<&＃63; extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
      for (Trigger trigger : triggers) {
        ScheduleJob job = new ScheduleJob();
        job.setJobName(jobKey.getName());
        job.setJobGroup(jobKey.getGroup());
        job.setDescription("触发器:" + trigger.getKey());
        Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
        job.setJobStatus(triggerState.name());
        if (trigger instanceof CronTrigger) {
          CronTrigger crOnTrigger= (CronTrigger) trigger;
          String crOnExpression= cronTrigger.getCronExpression();
          job.setCronExpression(cronExpression);
        }
        jobList.add(job);
      }
    }
    return jobList;
  }

  /**
   * 所有正在运行的job
   * 
   * @return
   * @throws SchedulerException
   */
  public List getRunningJob() throws SchedulerException {
    List executingJobs = scheduler.getCurrentlyExecutingJobs();
    List jobList = new ArrayList(executingJobs.size());
    for (JobExecutionContext executingJob : executingJobs) {
      ScheduleJob job = new ScheduleJob();
      JobDetail jobDetail = executingJob.getJobDetail();
      JobKey jobKey = jobDetail.getKey();
      Trigger trigger = executingJob.getTrigger();
      job.setJobName(jobKey.getName());
      job.setJobGroup(jobKey.getGroup());
      job.setDescription("触发器:" + trigger.getKey());
      Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
      job.setJobStatus(triggerState.name());
      if (trigger instanceof CronTrigger) {
        CronTrigger crOnTrigger= (CronTrigger) trigger;
        String crOnExpression= cronTrigger.getCronExpression();
        job.setCronExpression(cronExpression);
      }
      jobList.add(job);
    }
    return jobList;
  }

  /**
   * 暂停一个job
   * 
   * @param scheduleJob
   * @throws SchedulerException
   */
  public void pauseJob(ScheduleJob scheduleJob) throws SchedulerException {
    JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
    scheduler.pauseJob(jobKey);
  }

  /**
   * 恢复一个job
   * 
   * @param scheduleJob
   * @throws SchedulerException
   */
  public void resumeJob(ScheduleJob scheduleJob) throws SchedulerException {
    JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
    scheduler.resumeJob(jobKey);
  }

  /**
   * 删除一个job
   * 
   * @param scheduleJob
   * @throws SchedulerException
   */
  public void deleteJob(ScheduleJob scheduleJob) throws SchedulerException {
    JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
    scheduler.deleteJob(jobKey);

  }

  /**
   * 立即执行job
   * 
   * @param scheduleJob
   * @throws SchedulerException
   */
  public void runAJobNow(ScheduleJob scheduleJob) throws SchedulerException {
    JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
    scheduler.triggerJob(jobKey);
  }

  /**
   * 更新job时间表达式
   * 
   * @param scheduleJob
   * @throws SchedulerException
   */
  public void updateJobCron(ScheduleJob scheduleJob) throws SchedulerException {

    TriggerKey triggerKey = TriggerKey.triggerKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());

    CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

    CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression());

    trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();

    scheduler.rescheduleJob(triggerKey, trigger);
  }
}

service实现

import com.bootdo.common.config.Constant;
import com.bootdo.common.dao.TaskDao;
import com.bootdo.common.domain.ScheduleJob;
import com.bootdo.common.domain.TaskDO;
import com.bootdo.common.quartz.utils.QuartzManager;
import com.bootdo.common.service.JobService;
import com.bootdo.common.utils.ScheduleJobUtils;
import org.quartz.SchedulerException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class JobServiceImpl implements JobService {

  @Autowired
  private TaskDao taskScheduleJobMapper;

  @Autowired
  QuartzManager quartzManager;

  @Override
  public TaskDO get(Long id) {
    return taskScheduleJobMapper.get(id);
  }

  @Override
  public List list(Map map) {
    return taskScheduleJobMapper.list(map);
  }

  @Override
  public int count(Map map) {
    return taskScheduleJobMapper.count(map);
  }

  @Override
  public int save(TaskDO taskScheduleJob) {
    return taskScheduleJobMapper.save(taskScheduleJob);
  }

  @Override
  public int update(TaskDO taskScheduleJob) {
    return taskScheduleJobMapper.update(taskScheduleJob);
  }

  @Override
  public int remove(Long id) {
    try {
      TaskDO scheduleJob = get(id);
      quartzManager.deleteJob(ScheduleJobUtils.entityToData(scheduleJob));
      return taskScheduleJobMapper.remove(id);
    } catch (SchedulerException e) {
      e.printStackTrace();
      return 0;
    }

  }

  @Override
  public int batchRemove(Long[] ids) {
    for (Long id : ids) {
      try {
        TaskDO scheduleJob = get(id);
        quartzManager.deleteJob(ScheduleJobUtils.entityToData(scheduleJob));
      } catch (SchedulerException e) {
        e.printStackTrace();
        return 0;
      }
    }
    return taskScheduleJobMapper.batchRemove(ids);
  }

  @Override
  public void initSchedule() throws SchedulerException {
    // 这里获取任务信息数据
    List jobList = taskScheduleJobMapper.list(new HashMap(16));
    for (TaskDO scheduleJob : jobList) {
      if ("1".equals(scheduleJob.getJobStatus())) {
        ScheduleJob job = ScheduleJobUtils.entityToData(scheduleJob);
        quartzManager.addJob(job);
      }

    }
  }

  @Override
  public void changeStatus(Long jobId, String cmd) throws SchedulerException {
    TaskDO scheduleJob = get(jobId);
    if (scheduleJob == null) {
      return;
    }
    if (Constant.STATUS_RUNNING_STOP.equals(cmd)) {
      quartzManager.deleteJob(ScheduleJobUtils.entityToData(scheduleJob));
      scheduleJob.setJobStatus(ScheduleJob.STATUS_NOT_RUNNING);
    } else {
      if (!Constant.STATUS_RUNNING_START.equals(cmd)) {
      } else {
        scheduleJob.setJobStatus(ScheduleJob.STATUS_RUNNING);
        quartzManager.addJob(ScheduleJobUtils.entityToData(scheduleJob));
      }
    }
    update(scheduleJob);
  }

  @Override
  public void updateCron(Long jobId) throws SchedulerException {
    TaskDO scheduleJob = get(jobId);
    if (scheduleJob == null) {
      return;
    }
    if (ScheduleJob.STATUS_RUNNING.equals(scheduleJob.getJobStatus())) {
      quartzManager.updateJobCron(ScheduleJobUtils.entityToData(scheduleJob));
    }
    update(scheduleJob);
  }
}

启动一个监听去初始化Quartz

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import com.bootdo.common.quartz.utils.QuartzManager;
import com.bootdo.common.service.JobService;
@Component
@Order(value = 1)
public class ScheduleJobInitListener implements CommandLineRunner {

  @Autowired
  JobService scheduleJobService;

  @Autowired
  QuartzManager quartzManager;

  @Override
  public void run(String... arg0) throws Exception {
    try {
      scheduleJobService.initSchedule();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。

推荐阅读

apache
Maven + Spring + MyBatis + MySQL 环境搭建与实例解析

本文详细介绍如何使用MySQL数据库进行环境搭建，包括创建数据库表并插入示例数据。随后，逐步指导如何配置Maven项目，整合Spring框架与MyBatis，实现高效的数据访问。 ... [详细]

蜡笔小新 2024-11-21 18:39:23
apache
2023年1月28日网络安全热点

涵盖最新的网络安全动态，包括OpenSSH和WordPress的安全更新、VirtualBox提权漏洞、以及谷歌推出的新证书验证机制等内容。 ... [详细]

蜡笔小新 2024-11-24 10:29:06
服务器
专业版 Pro Git：全面掌握版本控制

本书《Pro Git》深入探讨了 Git 版本控制系统的核心概念与高级功能，旨在帮助开发者和团队有效管理代码变更。通过实例和最佳实践，读者将学习如何利用 Git 提升工作效率。 ... [详细]

蜡笔小新 2024-11-26 12:09:09
linux
如何更换Anaconda和pip的国内镜像源

本文详细介绍了如何通过国内多个知名镜像站（如北京外国语大学、中国科学技术大学、阿里巴巴等）更换Anaconda和pip的源，以提高软件包的下载速度和安装效率。 ... [详细]

蜡笔小新 2024-11-26 10:06:26
linux
c程序（打印日历、数转成素数乘积、猜随机数、九宫格，汉诺塔问题、main中命令行参数）

1.打印日历打印日历判断是否是闰年#include<stdio.h>inta[]{0,31,28,31,30,31,30,31,31 ... [详细]

蜡笔小新 2024-11-26 09:47:35
运维
解决宝塔面板Nginx反向代理缓存问题

本文介绍如何在宝塔控制面板中通过编辑Nginx配置文件来解决反向代理中的缓存问题，确保每次请求都能从服务器获取最新的数据。 ... [详细]

蜡笔小新 2024-11-25 16:54:14
服务器
利用SSH密钥实现Linux服务器间免密码登录

工作中频繁在不同Linux服务器之间切换时，频繁输入密码不仅耗时还影响效率。本文介绍如何通过设置SSH密钥认证，简化登录流程，提高工作效率。 ... [详细]

蜡笔小新 2024-11-25 14:39:01
server
Java毕业设计：在线办公工作流系统MyBatis+源码+调试部署+数据库+论文

本文介绍了基于Java的在线办公工作流系统的毕业设计方案，涵盖了MyBatis框架的应用、源代码分析、调试与部署流程、数据库设计以及相关论文撰写指导。 ... [详细]

蜡笔小新 2024-11-25 10:21:47
服务器
深入理解PHP中的超全局变量与AJAX技术

本文详细介绍了PHP中的几种超全局变量，包括$GLOBAL、$_SERVER、$_POST、$_GET等，并探讨了AJAX的工作原理及其优缺点。通过具体示例，帮助读者更好地理解和应用这些技术。 ... [详细]

蜡笔小新 2024-11-24 16:35:09
apache
深入解析Apache Mina开发指南

本文由chszs撰写，详细介绍了Apache Mina框架的核心开发流程及自定义协议处理方法。文章涵盖从创建IoService实例到协议编解码的具体步骤，适合希望深入了解Mina框架应用的开发者。 ... [详细]

蜡笔小新 2024-11-23 15:02:21
apache
Spring Security基础配置详解

本文详细介绍了Spring Security的基础配置方法，包括如何搭建Maven多模块工程以及具体的安全配置步骤，帮助开发者更好地理解和应用这一强大的安全框架。 ... [详细]

蜡笔小新 2024-11-22 20:52:07
apache
最适合初学者的编程语言

本文探讨了适合编程新手的最佳语言选择，包括Python、JavaScript等易于上手且功能强大的语言，以及如何通过有效的学习方法提高编程技能。 ... [详细]

蜡笔小新 2024-11-22 16:17:04
服务器
搭建个人博客：WordPress安装详解

计划建立个人博客来分享生活与工作的见解和经验，选择WordPress是因为它专为博客设计，功能强大且易于使用。 ... [详细]

蜡笔小新 2024-11-22 11:13:36
apache
HBase 数据复制与灾备同步策略

本文探讨了HBase在企业级应用中的数据复制与灾备同步解决方案，包括存量数据迁移及增量数据实时同步的方法。 ... [详细]

蜡笔小新 2024-11-21 19:20:03
apache
CentOS 中 SWAP 分区的创建与管理

本文详细介绍了在 CentOS 系统中如何创建和管理 SWAP 分区，包括临时创建交换文件、永久性增加交换空间的方法，以及如何手动释放内存缓存。 ... [详细]

蜡笔小新 2024-11-21 19:01:54

天气不再变化_207

这个家伙很懒，什么也没留下！

Tags | 热门标签

RankList | 热门文章