查看: 1035|回复: 0

[Java语言] Spring整合Quartz分布式调度的示例代码

发表于 2018-5-6 09:00:18

前言

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

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

Spring整合Quartz

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

1.Maven依赖文件

  1. <dependencies>
  2. <dependency>
  3. <groupId>org.springframework</groupId>
  4. <artifactId>spring-core</artifactId>
  5. <version>4.3.5.RELEASE</version>
  6. </dependency>
  7. <dependency>
  8. <groupId>org.springframework</groupId>
  9. <artifactId>spring-context-support</artifactId>
  10. <version>4.3.5.RELEASE</version>
  11. </dependency>
  12. <dependency>
  13. <groupId>org.springframework</groupId>
  14. <artifactId>spring-tx</artifactId>
  15. <version>4.3.5.RELEASE</version>
  16. </dependency>
  17. <dependency>
  18. <groupId>org.springframework</groupId>
  19. <artifactId>spring-jdbc</artifactId>
  20. <version>4.3.5.RELEASE</version>
  21. </dependency>
  22. <dependency>
  23. <groupId>org.quartz-scheduler</groupId>
  24. <artifactId>quartz</artifactId>
  25. <version>2.2.3</version>
  26. </dependency>
  27. <dependency>
  28. <groupId>mysql</groupId>
  29. <artifactId>mysql-connector-java</artifactId>
  30. <version>5.1.29</version>
  31. </dependency>
  32. </dependencies>
复制代码

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

2.配置job

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

2.1MethodInvokingJobDetailFactoryBean

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

  1. <bean id="firstTask" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
  2. <property name="targetObject" ref="firstService" />
  3. <property name="targetMethod" value="service" />
  4. </bea>
复制代码

2.2JobDetailFactoryBean

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

  1. <bean id="firstTask"
  2. class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
  3. <property name="jobClass" value="zh.maven.SQuartz.task.FirstTask" />
  4. <property name="jobDataMap">
  5. <map>
  6. <entry key="firstService" value-ref="firstService" />
  7. </map>
  8. </property>
  9. </bean>
复制代码

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

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

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

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

  1. <bean id="firstCronTrigger"
  2. class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
  3. <property name="jobDetail" ref="firstTask" />
  4. <property name="cronExpression" value="0/5 * * ? * *" />
  5. </bean>
复制代码

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

4.配置Quartz调度器的SchedulerFactoryBean

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

4.1内存RAMJobStore

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

  1. <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
  2. <property name="triggers">
  3. <list>
  4. <ref bean="firstCronTrigger" />
  5. </list>
  6. </property>
  7. </bean>
复制代码

4.2数据库方式

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

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

  1. <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
  2. destroy-method="close">
  3. <property name="driverClass" value="com.mysql.jdbc.Driver" />
  4. <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/quartz" />
  5. <property name="user" value="root" />
  6. <property name="password" value="root" />
  7. </bean>
  8. <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
  9. <property name="dataSource" ref="dataSource" />
  10. <property name="configLocation" value="classpath:quartz.properties" />
  11. <property name="triggers">
  12. <list>
  13. <ref bean="firstCronTrigger" />
  14. </list>
  15. </property>
  16. </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. org.quartz.scheduler.instanceId: AUTO
  2. org.quartz.jobStore.class: org.quartz.impl.jdbcjobstore.JobStoreTX
  3. org.quartz.jobStore.isClustered: true
  4. org.quartz.jobStore.clusterCheckinInterval: 1000
复制代码

5.相关类

  1. public class FirstTask extends QuartzJobBean {
  2. private FirstService firstService;
  3. @Override
  4. protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
  5. firstService.service();
  6. }
  7. public void setFirstService(FirstService firstService) {
  8. this.firstService = firstService;
  9. }
  10. }
复制代码

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

  1. public class FirstService implements Serializable {
  2. private static final long serialVersionUID = 1L;
  3. public void service() {
  4. System.out.println(new SimpleDateFormat("YYYYMMdd HH:mm:ss").format(new Date()) + "---start FirstService");
  5. try {
  6. Thread.sleep(2000);
  7. } catch (InterruptedException e) {
  8. e.printStackTrace();
  9. }
  10. System.out.println(new SimpleDateFormat("YYYYMMdd HH:mm:ss").format(new Date()) + "---end FirstService");
  11. }
  12. }
复制代码

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

  1. public class App {
  2. public static void main(String[] args) {
  3. AbstractApplicationContext context = new ClassPathXmlApplicationContext("quartz.xml");
  4. }
  5. }
复制代码

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

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



回复

使用道具 举报