Spring整合Quartz分布式调度的示例代码

前言

为了保证应用的高可用和高并发性,一般都会部署多个节点;对于定时任务,如果每个节点都执行自己的定时任务,一方面耗费了系统资源,

另一方面有些任务多次执行,可能引发应用逻辑问题,所以需要一个分布式的调度系统,来协调每个节点执行定时任务。

Spring整合Quartz

Quartz是一个成熟的任务调度系统,Spring对Quartz做了兼容,方便开发,下面看看具体如何整合:

1.Maven依赖文件

<dependencies>
 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-core</artifactId>
  <version>4.3.5.RELEASE</version>
 </dependency>
 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context-support</artifactId>
  <version>4.3.5.RELEASE</version>
 </dependency>
 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-tx</artifactId>
  <version>4.3.5.RELEASE</version>
 </dependency>
 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-jdbc</artifactId>
  <version>4.3.5.RELEASE</version>
 </dependency>
 <dependency>
  <groupId>org.quartz-scheduler</groupId>
  <artifactId>quartz</artifactId>
  <version>2.2.3</version>
 </dependency>
 <dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.29</version>
 </dependency>
 </dependencies>

主要就是Spring相关库、quartz库以及mysql驱动库,注:分布式调度需要用到数据库,这里选用mysql;

2.配置job

提供了两种方式来配置job,分别是:MethodInvokingJobDetailFactoryBean和JobDetailFactoryBean

2.1MethodInvokingJobDetailFactoryBean

要调用特定bean的一个方法的时候使用,具体配置如下:

<bean id="firstTask" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
  <property name="targetObject" ref="firstService" />
  <property name="targetMethod" value="service" />
</bea>

2.2JobDetailFactoryBean

这种方式更加灵活,可以设置传递参数,具体如下:

<bean id="firstTask"
 class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
 <property name="jobClass" value="zh.maven.SQuartz.task.FirstTask" />
 <property name="jobDataMap">
  <map>
  <entry key="firstService" value-ref="firstService" />
  </map>
 </property>
</bean>

jobClass定义的任务类,继承QuartzJobBean,实现executeInternal方法;jobDataMap用来给job传递数据

3.配置调度使用的触发器

同样提供了两种触发器类型:SimpleTriggerFactoryBean和CronTriggerFactoryBean

重点看CronTriggerFactoryBean,这种类型更加灵活,具体如下:

<bean id="firstCronTrigger"
 class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
 <property name="jobDetail" ref="firstTask" />
 <property name="cronExpression" value="0/5 * * ? * *" />
 </bean>

jobDetail指定的就是在步骤2中配置的job,cronExpression配置了每5秒执行一次job;

4.配置Quartz调度器的SchedulerFactoryBean

同样提供了两种方式:内存RAMJobStore和数据库方式

4.1内存RAMJobStore

job的相关信息存储在内存里,每个节点存储各自的,互相隔离,配置如下:

<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
 <property name="triggers">
  <list>
  <ref bean="firstCronTrigger" />
  </list>
 </property>
 </bean>

4.2数据库方式

job的相关信息存储在数据库中,所有节点共用数据库,每个节点通过数据库来通信,保证一个job同一时间只会在一个节点上执行,并且

如果某个节点挂掉,job会被分配到其他节点执行,具体配置如下:

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
 destroy-method="close">
 <property name="driverClass" value="com.mysql.jdbc.Driver" />
 <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/quartz" />
 <property name="user" value="root" />
 <property name="password" value="root" />
 </bean>
 <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
 <property name="dataSource" ref="dataSource" />
 <property name="configLocation" value="classpath:quartz.properties" />
 <property name="triggers">
  <list>
  <ref bean="firstCronTrigger" />
  </list>
 </property>
 </bean>

dataSource用来配置数据源,数据表相关信息,可以到官网下载gz包,sql文件在路径:docs\dbTables下,里面提供了主流数据库的sql文件;

configLocation配置的quartz.properties文件在quartz.jar的org.quartz包下,里面提供了一些默认的数据,比如org.quartz.jobStore.class

org.quartz.jobStore.class: org.quartz.simpl.RAMJobStore

这里需要将quartz.properties拷贝出来做一些修改,具体修改如下:

org.quartz.scheduler.instanceId: AUTO
org.quartz.jobStore.class: org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.isClustered: true
org.quartz.jobStore.clusterCheckinInterval: 1000

5.相关类

public class FirstTask extends QuartzJobBean {

 private FirstService firstService;

 @Override
 protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
 firstService.service();
 }

 public void setFirstService(FirstService firstService) {
 this.firstService = firstService;
 }
}

FirstTask继承QuartzJobBean,实现executeInternal方法,调用FirstService

public class FirstService implements Serializable {

 private static final long serialVersionUID = 1L;

 public void service() {
 System.out.println(new SimpleDateFormat("YYYYMMdd HH:mm:ss").format(new Date()) + "---start FirstService");
 try {
  Thread.sleep(2000);
 } catch (InterruptedException e) {
  e.printStackTrace();
 }
 System.out.println(new SimpleDateFormat("YYYYMMdd HH:mm:ss").format(new Date()) + "---end FirstService");
 }
}

FirstService需要提供序列化接口,因为需要保存在数据库中;

public class App {
 public static void main(String[] args) {
 AbstractApplicationContext context = new ClassPathXmlApplicationContext("quartz.xml");
 }
}

主类用来加载quartz配置文件;

测试分布式调度

1.同时启动App两次,观察日志:

20180405 14:48:10---start FirstService
20180405 14:48:12---end FirstService
20180405 14:48:15---start FirstService
20180405 14:48:17---end FirstService

其中A1有日志输出,A2没有;当停掉A1以后,A2有日志输出;

2.添加新的job分别新建:SecondTask和SecondService,同时添加相关配置文件,启动App两次,观察日志:

A1日志如下:

20180405 15:03:15---start FirstService
20180405 15:03:15---start SecondService
20180405 15:03:17---end FirstService
20180405 15:03:17---end SecondService
20180405 15:03:20---start FirstService
20180405 15:03:22---end FirstService
20180405 15:03:25---start FirstService
20180405 15:03:27---end FirstService

A2日志如下:

20180405 15:03:20---start SecondService
20180405 15:03:22---end SecondService
20180405 15:03:25---start SecondService
20180405 15:03:27---end SecondService

可以发现A1和A2都有执行任务,但是同一任务同一时间只会在一个节点执行,并且只有在执行结束后才有可能分配到其他节点;

3.如果间隔时间小于任务执行时间,比如这里改成sleep(6000)

A1日志如下:

20180405 15:14:40---start FirstService
20180405 15:14:45---start FirstService
20180405 15:14:46---end FirstService
20180405 15:14:50---start FirstService
20180405 15:14:50---start SecondService
20180405 15:14:51---end FirstService

A2日志如下:

20180405 15:14:40---start SecondService
20180405 15:14:45---start SecondService
20180405 15:14:46---end SecondService
20180405 15:14:51---end SecondService

间隔时间是5秒,而任务执行需要6秒,观察日志可以发现,任务还没有结束,新的任务已经开始,这种情况可能引发应用的逻辑问题,其实就是任务能不能支持串行的问题;

4.@DisallowConcurrentExecution注解保证任务的串行

在FirstTask和SecondTask上分别添加@DisallowConcurrentExecution注解,日志结果如下:

A1日志如下:

20180405 15:32:45---start FirstService
20180405 15:32:51---end FirstService
20180405 15:32:51---start FirstService
20180405 15:32:51---start SecondService
20180405 15:32:57---end FirstService
20180405 15:32:57---end SecondService
20180405 15:32:57---start FirstService
20180405 15:32:57---start SecondService

A2日志如下:

20180405 15:32:45---start SecondService
20180405 15:32:51---end SecondService

观察日志可以发现,任务只有在end以后,才会开始新的任务,实现了任务的串行化;

总结

本文旨在对Spring+Quartz分布式调度有一个直观的了解,通过实际的使用来解决问题,当然可能还有很多疑问比如它是如何调度的,数据库如果挂了会怎么样等等,还需要做更加深入的了解。

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

(0)

相关推荐

  • 基于spring+quartz的分布式定时任务框架实现

    问题背景 我公司是一个快速发展的创业公司,目前有200人,主要业务是旅游和酒店相关的,应用迭代更新周期比较快,因此,开发人员花费了更多的时间去更=跟上迭代的步伐,而缺乏了对整个系统的把控 没有集群之前,公司定时任务的实现方式 在初期应用的访问量并不是那么大,一台服务器完全满足使用,应用中有很多定时任务需要执行 有了集群之后,公司定时任务实现的方式 随着用户的增加,访问量也就随之增加,一台服务器满足不了高并发的要求,因此公司把应用给部署到集群中,前端通过nginx代理(应用服务器ip可能是用防火墙

  • Spring整合Quartz分布式调度的示例代码

    前言 为了保证应用的高可用和高并发性,一般都会部署多个节点:对于定时任务,如果每个节点都执行自己的定时任务,一方面耗费了系统资源, 另一方面有些任务多次执行,可能引发应用逻辑问题,所以需要一个分布式的调度系统,来协调每个节点执行定时任务. Spring整合Quartz Quartz是一个成熟的任务调度系统,Spring对Quartz做了兼容,方便开发,下面看看具体如何整合: 1.Maven依赖文件 <dependencies> <dependency> <groupId>

  • Spring整合quartz做定时任务的示例代码

    今天我们来分享一波在spring项目使用quartz做定时任务. 首先我这里的项目已经是一个可以跑起来的完整项目,web.xml里面的配置我就不贴出来了. 1.新建一个类ConfigConsts 我们用来放cron表达式: ​​更多cron表达式​​ package com.aowang.quartz; public abstract class ConfigConsts { /** 30分钟执行一次 */ public static final String quartzInterval =

  • SprinBoot整合Quart实现定时调度的示例代码

    Quartz是一款开源的定时任务调度框架,Quartz的官网是:http://www.quartz-scheduler.org/.本文主要是讲诉使用springboot整合quartz实现定时任务调度管理的用例.主要的内容有如下三部分: 1. springboot整合quartz的相关配置 2. 实现基于simpleTrigger的定时任务 3. 实现基于cronTrigger的定时任务 一.导入相关的pom依赖 <?xml version="1.0" encoding=&quo

  • SpringBoot整合Redis正确的实现分布式锁的示例代码

    前言 最近在做分块上传的业务,使用到了Redis来维护上传过程中的分块编号. 每上传完成一个分块就获取一下文件的分块集合,加入新上传的编号,手动接口测试下是没有问题的,前端通过并发上传调用就出现问题了,并发的get再set,就会存在覆盖写现象,导致最后的分块数据不对,不能触发分块合并请求. 遇到并发二话不说先上锁,针对执行代码块加了一个JVM锁之后问题就解决了. 仔细一想还是不太对,项目是分布式部署的,做了负载均衡,一个节点的代码被锁住了,请求轮询到其他节点还是可以进行覆盖写,并没有解决到问题啊

  • Spring整合Quartz开发代码实例

    我们使用Spring整合Quartz开发,本实例采用数据库模式的demo. xml文件配置如下: <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns

  • spring整合Quartz框架过程详解

    这篇文章主要介绍了spring整合Quartz框架过程详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 1.Quartz框架简介 Quartz是一个完全由Java编写的开源任务调度的框架,通过触发器设置作业定时运行规则,控制作业的运行时间.其中quartz集群通过故障切换和负载平衡的功能,能给调度器带来高可用性和伸缩性.主要用来执行定时任务,如:定时发送信息.定时生成报表等等. Quartz框架的主要特点: · 强大的调度功能,例如丰富多样的

  • Spring整合Quartz Job以及Spring Task的实现方法

    Spring中常用的定时任务的主要有两种 1.Spring整合Quartz Job 2.Spring 3.0以后自带的Task 一.两种定时任务的实现方式 Quartz job 1.首先编写任务类 package com.yjf.job; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * @author yjf */ public class ExampleJob { private static final Logge

  • 使用spring整合Quartz实现—定时器功能

    使用spring整合Quartz实现-定时器(Maven项目做演示) 不基于特定的基类的方法 一,开发环境以及依赖的jar包 Spring 4.2.6.RELEASE Maven 3.3.9 Jdk 1.7 Idea 15.04 二,不可少的jar依赖(添加在maven项目里面的pom.xml文件里面) <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context

  • SpringBoot中使用Session共享实现分布式部署的示例代码

    前言:我们知道,在单体项目中,我们将用户信息存在 session 中,那么在该 session 过期之前,我们都可以从 session 中获取到用户信息,通过登录拦截,进行操作 但是分布式部署的时候,我们请求的服务器可能不是同一台服务器,那么我们就必须要面对 session 共享的问题,下面介绍的是在 SpringBoot 实现 session 共享的方式 一.创建项目 创建 SpringBoot 项目,选择 Maven 依赖 最终 pom.xml 文件如下: <!-- redis的依赖 -->

  • SpringBoot集成redis实现分布式锁的示例代码

    1.准备 使用redis实现分布式锁,需要用的setnx(),所以需要集成Jedis 需要引入jar,jar最好和redis的jar版本对应上,不然会出现版本冲突,使用的时候会报异常redis.clients.jedis.Jedis.set(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;I)Ljava/lang/String; 我使用的redis版本是2.3.0,Jedis使用的是3.3.0 <de

随机推荐