本文源码：GitHub·点这里 || GitEE·点这里

一、QuartJob简介

1、一句话描述

Quartz是一个完全由java编写的开源作业调度框架，形式简易，功能强大。

2、核心API

(1)、Scheduler

代表一个 Quartz 的独立运行容器，Scheduler 将 Trigger 绑定到特定 JobDetail， 这样当 Trigger 触发时， 对应的 Job 就会被调度。

(2)、Trigger

描述 Job 执行的时间触发规则。主要有 SimpleTrigger 和 CronTrigger 两个子类，通过一个 TriggerKey 唯一标识。

(3)、Job

定义一个任务，规定了任务是执行时的行为。JobExecutionContext 提供了调度器的上下文信息，Job 的数据可从 JobDataMap 中获取。

(4)、JobDetail

Quartz 在每次执行 Job 时，都重新创建一个 Job 实例，所以它不直接接受一个 Job 的实例，相反它接收一个 Job 实现类。描述 Job 的实现类及其它相关的静态信息，如 Job 名字、描述等。

二、与SpringBoot2.0 整合

1、项目结构



版本描述

  1. spring-boot：2.1.3.RELEASE
  2. quart-job：2.3.0

2、定时器配置

  1. import org.springframework.context.annotation.Bean;
  2. import org.springframework.context.annotation.Configuration;
  3. import org.springframework.scheduling.quartz.SchedulerFactoryBean;
  4. import javax.sql.DataSource;
  5. import java.util.Properties;
  6. @Configuration
  7. public class ScheduleConfig {
  8.     @Bean
  9.     public SchedulerFactoryBean schedulerFactoryBean(DataSource dataSource) {
  10.         // Quartz参数配置
  11.         Properties prop = new Properties();
  12.         // Schedule调度器的实体名字
  13.         prop.put("org.quartz.scheduler.instanceName", "HuskyScheduler");
  14.         // 设置为AUTO时使用，默认的实现org.quartz.scheduler.SimpleInstanceGenerator是基于主机名称和时间戳生成。
  15.         prop.put("org.quartz.scheduler.instanceId", "AUTO");
  16.         // 线程池配置
  17.         prop.put("org.quartz.threadPool.class", "org.quartz.simpl.SimpleThreadPool");
  18.         prop.put("org.quartz.threadPool.threadCount", "20");
  19.         prop.put("org.quartz.threadPool.threadPriority", "5");
  20.         // JobStore配置:Scheduler在运行时用来存储相关的信息
  21.         // JDBCJobStore和JobStoreTX都使用关系数据库来存储Schedule相关的信息。
  22.         // JobStoreTX在每次执行任务后都使用commit或者rollback来提交更改。
  23.         prop.put("org.quartz.jobStore.class", "org.quartz.impl.jdbcjobstore.JobStoreTX");
  24.         // 集群配置：如果有多个调度器实体的话则必须设置为true
  25.         prop.put("org.quartz.jobStore.isClustered", "true");
  26.         // 集群配置：检查集群下的其他调度器实体的时间间隔
  27.         prop.put("org.quartz.jobStore.clusterCheckinInterval", "15000");
  28.         // 设置一个频度(毫秒)，用于实例报告给集群中的其他实例
  29.         prop.put("org.quartz.jobStore.maxMisfiresToHandleAtATime", "1");
  30.         // 触发器触发失败后再次触犯的时间间隔
  31.         prop.put("org.quartz.jobStore.misfireThreshold", "12000");
  32.         // 数据库表前缀
  33.         prop.put("org.quartz.jobStore.tablePrefix", "qrtz_");
  34.         // 从 LOCKS 表查询一行并对这行记录加锁的 SQL 语句
  35.         prop.put("org.quartz.jobStore.selectWithLockSQL", "SELECT * FROM {0}LOCKS UPDLOCK WHERE LOCK_NAME = ?");
  37.         // 定时器工厂配置
  38.         SchedulerFactoryBean factory = new SchedulerFactoryBean();
  39.         factory.setDataSource(dataSource);
  40.         factory.setQuartzProperties(prop);
  41.         factory.setSchedulerName("HuskyScheduler");
  42.         factory.setStartupDelay(30);
  43.         factory.setApplicationContextSchedulerContextKey("applicationContextKey");
  44.         // 可选，QuartzScheduler 启动时更新己存在的Job
  45.         factory.setOverwriteExistingJobs(true);
  46.         // 设置自动启动，默认为true
  47.         factory.setAutoStartup(true);
  48.         return factory;
  49.     }
  50. }

3、定时器管理工具

  1. import com.quart.job.entity.ScheduleJobBean;
  2. import org.quartz.*;
  3. /**
  4.  * 定时器工具类
  5.  */
  6. public class ScheduleUtil {
  7.     private ScheduleUtil (){}
  8.     private static final String SCHEDULE_NAME = "HUSKY_" ;
  9.     /**
  10.      * 触发器 KEY
  11.      */
  12.     public static TriggerKey getTriggerKey(Long jobId){
  13.         return TriggerKey.triggerKey(SCHEDULE_NAME+jobId) ;
  14.     }
  15.     /**
  16.      * 定时器 Key
  17.      */
  18.     public static JobKey getJobKey (Long jobId){
  19.         return JobKey.jobKey(SCHEDULE_NAME+jobId) ;
  20.     }
  21.     /**
  22.      * 表达式触发器
  23.      */
  24.     public static CronTrigger getCronTrigger (Scheduler scheduler,Long jobId){
  25.         try {
  26.             return (CronTrigger)scheduler.getTrigger(getTriggerKey(jobId)) ;
  27.         } catch (SchedulerException e){
  28.             throw new RuntimeException("getCronTrigger Fail",e) ;
  29.         }
  30.     }
  31.     /**
  32.      * 创建定时器
  33.      */
  34.     public static void createJob (Scheduler scheduler, ScheduleJobBean scheduleJob){
  35.         try {
  36.             // 构建定时器
  37.             JobDetail jobDetail = JobBuilder.newJob(TaskJobLog.class).withIdentity(getJobKey(scheduleJob.getJobId())).build() ;
  38.             CronScheduleBuilder scheduleBuilder = CronScheduleBuilder
  39.                     .cronSchedule(scheduleJob.getCronExpression())
  40.                     .withMisfireHandlingInstructionDoNothing() ;
  41.             CronTrigger trigger = TriggerBuilder.newTrigger()
  42.                     .withIdentity(getTriggerKey(scheduleJob.getJobId()))
  43.                     .withSchedule(scheduleBuilder).build() ;
  44.             jobDetail.getJobDataMap().put(ScheduleJobBean.JOB_PARAM_KEY,scheduleJob);
  45.             scheduler.scheduleJob(jobDetail,trigger) ;
  46.             // 如果该定时器处于暂停状态
  47.             if (scheduleJob.getStatus() == 1){
  48.                 pauseJob(scheduler,scheduleJob.getJobId()) ;
  49.             }
  50.         } catch (SchedulerException e){
  51.             throw new RuntimeException("createJob Fail",e) ;
  52.         }
  53.     }
  54.     /**
  55.      * 更新定时任务
  56.      */
  57.     public static void updateJob(Scheduler scheduler, ScheduleJobBean scheduleJob) {
  58.         try {
  59.             // 构建定时器
  60.             TriggerKey triggerKey = getTriggerKey(scheduleJob.getJobId());
  61.             CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression())
  62.                     .withMisfireHandlingInstructionDoNothing();
  63.             CronTrigger trigger = getCronTrigger(scheduler, scheduleJob.getJobId());
  64.             trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
  65.             trigger.getJobDataMap().put(ScheduleJobBean.JOB_PARAM_KEY, scheduleJob);
  66.             scheduler.rescheduleJob(triggerKey, trigger);
  67.             // 如果该定时器处于暂停状态
  68.             if(scheduleJob.getStatus() == 1){
  69.                 pauseJob(scheduler, scheduleJob.getJobId());
  70.             }
  71.         } catch (SchedulerException e) {
  72.             throw new RuntimeException("updateJob Fail",e) ;
  73.         }
  74.     }
  75.     /**
  76.      * 停止定时器
  77.      */
  78.     public static void pauseJob (Scheduler scheduler,Long jobId){
  79.         try {
  80.             scheduler.pauseJob(getJobKey(jobId));
  81.         } catch (SchedulerException e){
  82.             throw new RuntimeException("pauseJob Fail",e) ;
  83.         }
  84.     }
  85.     /**
  86.      * 恢复定时器
  87.      */
  88.     public static void resumeJob (Scheduler scheduler,Long jobId){
  89.         try {
  90.             scheduler.resumeJob(getJobKey(jobId));
  91.         } catch (SchedulerException e){
  92.             throw new RuntimeException("resumeJob Fail",e) ;
  93.         }
  94.     }
  95.     /**
  96.      * 删除定时器
  97.      */
  98.     public static void deleteJob (Scheduler scheduler,Long jobId){
  99.         try {
  100.             scheduler.deleteJob(getJobKey(jobId));
  101.         } catch (SchedulerException e){
  102.             throw new RuntimeException("deleteJob Fail",e) ;
  103.         }
  104.     }
  105.     /**
  106.      * 执行定时器
  107.      */
  108.     public static void run (Scheduler scheduler, ScheduleJobBean scheduleJob){
  109.         try {
  110.             JobDataMap dataMap = new JobDataMap() ;
  111.             dataMap.put(ScheduleJobBean.JOB_PARAM_KEY,scheduleJob);
  112.             scheduler.triggerJob(getJobKey(scheduleJob.getJobId()),dataMap);
  113.         } catch (SchedulerException e){
  114.             throw new RuntimeException("run Fail",e) ;
  115.         }
  116.     }
  117. }

4、定时器执行和日志

  1. import com.quart.job.entity.ScheduleJobBean;
  2. import com.quart.job.entity.ScheduleJobLogBean;
  3. import com.quart.job.service.ScheduleJobLogService;
  4. import org.quartz.JobExecutionContext;
  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;
  7. import org.springframework.scheduling.quartz.QuartzJobBean;
  8. import java.lang.reflect.Method;
  9. import java.util.Date;
  10. /**
  11.  * 定时器执行日志记录
  12.  */
  13. public class TaskJobLog extends QuartzJobBean {
  15.     private static final Logger LOG = LoggerFactory.getLogger(TaskJobLog.class) ;
  17.     @Override
  18.     protected void executeInternal(JobExecutionContext context) {
  19.         ScheduleJobBean jobBean = (ScheduleJobBean)context.getMergedJobDataMap().get(ScheduleJobBean.JOB_PARAM_KEY) ;
  20.         ScheduleJobLogService scheduleJobLogService = (ScheduleJobLogService)SpringContextUtil.getBean("scheduleJobLogService") ;
  21.         // 定时器日志记录
  22.         ScheduleJobLogBean logBean = new ScheduleJobLogBean () ;
  23.         logBean.setJobId(jobBean.getJobId());
  24.         logBean.setBeanName(jobBean.getBeanName());
  25.         logBean.setParams(jobBean.getParams());
  26.         logBean.setCreateTime(new Date());
  27.         long beginTime = System.currentTimeMillis() ;
  28.         try {
  29.             // 加载并执行定时器的 run 方法
  30.             Object target = SpringContextUtil.getBean(jobBean.getBeanName());
  31.             Method method = target.getClass().getDeclaredMethod("run", String.class);
  32.             method.invoke(target, jobBean.getParams());
  33.             long executeTime = System.currentTimeMillis() - beginTime;
  34.             logBean.setTimes((int)executeTime);
  35.             logBean.setStatus(0);
  36.             LOG.info("定时器 === >> "+jobBean.getJobId()+"执行成功,耗时 === >> " + executeTime);
  37.         } catch (Exception e){
  38.             // 异常信息
  39.             long executeTime = System.currentTimeMillis() - beginTime;
  40.             logBean.setTimes((int)executeTime);
  41.             logBean.setStatus(1);
  42.             logBean.setError(e.getMessage());
  43.         } finally {
  44.             scheduleJobLogService.insert(logBean) ;
  45.         }
  46.     }
  47. }

三、定时器服务封装

1、定时器初始化

  1. @Service
  2. public class ScheduleJobServiceImpl implements ScheduleJobService {
  4.     @Resource
  5.     private Scheduler scheduler ;
  6.     @Resource
  7.     private ScheduleJobMapper scheduleJobMapper ;
  9.     /**
  10.      * 定时器初始化
  11.      */
  12.     @PostConstruct
  13.     public void init (){
  14.         ScheduleJobExample example = new ScheduleJobExample() ;
  15.         List<ScheduleJobBean> scheduleJobBeanList = scheduleJobMapper.selectByExample(example) ;
  16.         for (ScheduleJobBean scheduleJobBean : scheduleJobBeanList) {
  17.             CronTrigger cronTrigger = ScheduleUtil.getCronTrigger(scheduler,scheduleJobBean.getJobId()) ;
  18.             if (cronTrigger == null){
  19.                 ScheduleUtil.createJob(scheduler,scheduleJobBean);
  20.             } else {
  21.                 ScheduleUtil.updateJob(scheduler,scheduleJobBean);
  22.             }
  23.         }
  24.     }
  25. }

2、添加定时器

  1. @Override
  2. @Transactional(rollbackFor = Exception.class)
  3. public int insert(ScheduleJobBean record) {
  4.     ScheduleUtil.createJob(scheduler,record);
  5.     return scheduleJobMapper.insert(record);
  6. }

3、立即执行一次定时器

  1. @Override
  2. @Transactional(rollbackFor = Exception.class)
  3. public void run(Long jobId) {
  4.     ScheduleJobBean scheduleJobBean = scheduleJobMapper.selectByPrimaryKey(jobId) ;
  5.     ScheduleUtil.run(scheduler,scheduleJobBean);
  6. }

4、更新定时器

  1. @Override
  2. @Transactional(rollbackFor = Exception.class)
  3. public int updateByPrimaryKeySelective(ScheduleJobBean record) {
  4.     ScheduleUtil.updateJob(scheduler,record);
  5.     return scheduleJobMapper.updateByPrimaryKeySelective(record);
  6. }

5、停止定时器

  1. @Override
  2. @Transactional(rollbackFor = Exception.class)
  3. public void pauseJob(Long jobId) {
  4.     ScheduleJobBean scheduleJobBean = scheduleJobMapper.selectByPrimaryKey(jobId) ;
  5.     ScheduleUtil.pauseJob(scheduler,jobId);
  6.     scheduleJobBean.setStatus(1);
  7.     scheduleJobMapper.updateByPrimaryKeySelective(scheduleJobBean) ;
  8. }

6、恢复定时器

  1. @Override
  2. @Transactional(rollbackFor = Exception.class)
  3. public void resumeJob(Long jobId) {
  4.     ScheduleJobBean scheduleJobBean = scheduleJobMapper.selectByPrimaryKey(jobId) ;
  5.     ScheduleUtil.resumeJob(scheduler,jobId);
  6.     scheduleJobBean.setStatus(0);
  7.     scheduleJobMapper.updateByPrimaryKeySelective(scheduleJobBean) ;
  8. }

7、删除定时器

  1. @Override
  2. @Transactional(rollbackFor = Exception.class)
  3. public void delete(Long jobId) {
  4.     ScheduleUtil.deleteJob(scheduler, jobId);
  5.     scheduleJobMapper.deleteByPrimaryKey(jobId) ;
  6. }

四、配置一个测试的定时器

1、定时接口封装

  1. public interface TaskService {
  2.     void run(String params);
  3. }

2、测试定时器

  1. @Component("getTimeTask")
  2. public class GetTimeTask implements TaskService {
  3.     private static final Logger LOG = LoggerFactory.getLogger(GetTimeTask.class.getName()) ;
  4.     private static final SimpleDateFormat format =
  5.             new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") ;
  6.     @Override
  7.     public void run(String params) {
  8.         LOG.info("Params === >> " + params);
  9.         LOG.info("当前时间::::"+format.format(new Date()));
  10.     }
  11. }

五、源代码

  1. GitHub·地址
  2. https://github.com/cicadasmile/middle-ware-parent
  3. GitEE·地址
  4. https://gitee.com/cicadasmile/middle-ware-parent

SpringBoot2.0 整合 QuartJob ,实现定时器实时管理的更多相关文章

  1. （六）整合 QuartJob ,实现定时器实时管理

    整合 QuartJob ,实现定时器实时管理 1.QuartJob简介 1.1 核心API 2.SpringBoot整合QuartJob 2.1 项目结构 2.2 定时器配置 2.3 定时器管理工具 ...

  2. SpringBoot2.0 整合 Swagger2 ,构建接口管理界面

    一.Swagger2简介 1.Swagger2优点 整合到Spring Boot中,构建强大RESTful API文档.省去接口文档管理工作,修改代码,自动更新,Swagger2也提供了强大的页面测试 ...

  3. springboot2.0整合logback日志(详细)

    <div class="post"> <h1 class="postTitle"> springboot2.0整合logback日志(详 ...

  4. 第二篇：SpringBoot2.0整合ActiveMQ

    本篇开始将具体介绍SpringBoot如何整合其它项目. 如何创建SpringBoot项目 访问https://start.spring.io/. 依次选择构建工具Maven Project.语言ja ...

  5. SpringBoot2.0 整合 Dubbo框架 ,实现RPC服务远程调用

    一.Dubbo框架简介 1.框架依赖 图例说明: 1)图中小方块 Protocol, Cluster, Proxy, Service, Container, Registry, Monitor 代表层 ...

  6. SpringBoot2.0 整合 Redis集群 ,实现消息队列场景

    本文源码:GitHub·点这里 || GitEE·点这里 一.Redis集群简介 1.RedisCluster概念 Redis的分布式解决方案,在3.0版本后推出的方案,有效地解决了Redis分布式的 ...

  7. SpringBoot2.0应用（三）：SpringBoot2.0整合RabbitMQ

    如何整合RabbitMQ 1.添加spring-boot-starter-amqp <dependency> <groupId>org.springframework.boot ...

  8. SpringBoot2.0整合fastjson的正确姿势

            SpringBoot2.0如何集成fastjson?在网上查了一堆资料,但是各文章的说法不一,有些还是错的,可能只是简单测试一下就认为ok了,最后有没生效都不知道.恰逢公司项目需要将J ...

  9. Activiti工作流框架学习笔记（二）之springboot2.0整合工作流Activiti6.0

    以前在工作当中做过不少与工作流Activiti有关的工作,当时都是spring集成activiti5.22的项目,现在回过头去看,其实版本已经稍微老了,因此,基于先前的工作经验,决定用较新版本的技术来 ...

随机推荐

  1. EasyPusher实现将asterisk直播流以RTSP转发实现通话直播与录像

    本文转自博客:http://blog.csdn.net/jinlong0603/article/details/56047145 EasyPusher RTP直播推送介绍 EasyPusher是一个推 ...

  2. java集合类学习心得

    java集合类学习心得 看了java从入门到精通的第十章,做个总结,图片均取自网络. 常用集合的继承关系 Linked 改快读慢 Array 读快改慢 Hash 两都之间 Collection是集合接 ...

  3. 操作系统 资源管理 zookeeper yarn 进程管理 分布式 yarn诞生背景

    zookeeper 信息保管员 YARN 简介 https://www.ibm.com/developerworks/cn/data/library/bd-yarn-intro/index.html

  4. 调用Windows API实现GBK和UTF-8的相互转换

    GBK转UTF-8示例 GbkToUtf8.cpp #include <Windows.h> #include <iostream> #include <string&g ...

  5. css定位的元素内层不自动扩高解决

        给最外层的CSS加上一行: 1 position: relative;             /* 给最外层加上这行 */

  6. JS获取当前页面的URL

    如果获取“当前”域名 host = window.location.host; url=document.domain; url = window.location.href; 取得完整url路径: ...

  7. jmeter中的响应断言

    断言就类似LoadRunner中的检查点.对上一个请求返回的信息,做字符串.数据包大小.HTML.XML.图片等做判断,确保返回的信息的准确性. jmeter的断言有好多,下面是一个响应断言 新建一个 ...

  8. hdu 1711 Number Sequence（kmp找子串第一次出现的位置）

    题意:裸kmp 思路:kmp模板 #include<iostream> #include<stdio.h> #include<string.h> using nam ...

  9. openssl生成公钥私钥对 加解密

    在计算机软件开发世界中,编程语言种类极多,数据在各种语言的表现形式可能有所差异,但数据本身的处理可能,或者说本质上是完全一样的:比如数据在某个算法中的运算过程是一样的.在这里,我以加密与解密来作为例子 ...

  10. Logcat不显示Application的解决办法

    Window - show view - devices - debug ----2014.12.1------ 只有在DDMS的device中显示进程名,logcat中的Application标签才 ...