服务器之家:专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|JavaScript|易语言|

服务器之家 - 编程语言 - Java教程 - Spring整合Quartz分布式调度的示例代码

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

2021-04-20 14:27zhaohui Java教程

本篇文章主要介绍了Spring整合Quartz分布式调度的示例代码,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧

前言

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

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

spring整合quartz

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

1.maven依赖文件

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
<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的一个方法的时候使用,具体配置如下:

?
1
2
3
4
<bean id="firsttask" class="org.springframework.scheduling.quartz.methodinvokingjobdetailfactorybean">
  <property name="targetobject" ref="firstservice" />
  <property name="targetmethod" value="service" />
</bea>

2.2jobdetailfactorybean

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

?
1
2
3
4
5
6
7
8
9
<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,这种类型更加灵活,具体如下:

?
1
2
3
4
5
<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的相关信息存储在内存里,每个节点存储各自的,互相隔离,配置如下:

?
1
2
3
4
5
6
7
<bean class="org.springframework.scheduling.quartz.schedulerfactorybean">
 <property name="triggers">
  <list>
  <ref bean="firstcrontrigger" />
  </list>
 </property>
 </bean>

4.2数据库方式

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

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<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

?
1
org.quartz.jobstore.class: org.quartz.simpl.ramjobstore

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

?
1
2
3
4
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.相关类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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需要提供序列化接口,因为需要保存在数据库中;

?
1
2
3
4
5
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分布式调度有一个直观的了解,通过实际的使用来解决问题,当然可能还有很多疑问比如它是如何调度的,数据库如果挂了会怎么样等等,还需要做更加深入的了解。

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

原文链接:http://codingo.xyz/index.php/2018/04/05/quartz1/

延伸 · 阅读

精彩推荐