Spring 整合 Quartz 分布式调度

发表于 阅读次数： 阅读次数： 本文字数： 11k 阅读时长 ≈ 10 分钟

Spring整合Quartz分布式调度

前言

最近在做项目时，项目中涉及到很多定时任务相关的功能，并且很多定时都是动态的。为了业务开发时定时调度更加方便，且能清晰的管理所有定时任务，我决定将调度中心这个模块做成可视化的管理界面；此外，考虑到后期项目的壮大，应用的高可用和高并发性，可能会有采用集群部署多个节点；对于定时任务，如果每个节点都执行自己的定时任务，一方面耗费了系统资源，另一方面有些任务多次执行，可能引发应用逻辑问题，所以需要一个分布式的调度系统，来协调每个节点执行定时任务，定时任务采用动态配置并持久化到数据库。

版本选择

spring 对于 quartz 的支持，是通过 org.springframework.scheduling.quartz.CronTriggerBean 继承 org.quartz.CronTrigger 来实现的。在 quartz1.x 系列中 org.quartz.CronTrigger 是个类，而在 quartz2.x 系列中 org.quartz.CronTrigger 变成了接口，这就造成了无法用 spring 的方式配置 quartz 的触发器（trigger）。因此，在 spring3.1 以下的版本必须使用 quartz1.x 系列，3.1 以上的版本才支持 quartz 2.x，否则会出错。
本次采用版本：spring 版本 4.3.5.RELEASE，quartz 版本 2.3.0
quartz-2.3.0 CronTrigger

Spring 整合 Quartz

Maven 依赖文件

pom.xml
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
33
<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.3.0</version>
        </dependency>
        <!--分布式调度持久化选用mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.29</version>
        </dependency>
    </dependencies>

配置 job

Quartz 是一个成熟的任务调度系统提供了两种方式来配置 job，分别是：

  • MethodInvokingJobDetailFactoryBean
  • JobDetailFactoryBean

MethodInvokingJobDetailFactoryBean

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

applicationContext-job.xml
1
2
3
4
<bean id="firstTask" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
    <property name="targetObject" ref="springFrameworkQuartzJobDemo" />
    <property name="targetMethod" value="springFrameworkQuartzJobDemoJob" />
</bea>

JobDetailFactoryBean

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

applicationContext-job.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<bean id="springFrameworkQuartzJobDemoBeanId"
    class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
    <property name="jobClass"
        value="com.syshlang.quartz.core.quartz.schedulerframework.SpringFrameworkQuartzJobDemo"/>
    <property name="name" value="springFrameworkQuartzJobDemoJob"/>
    <property name="durability" value="true" />
    <!--
    <property name="jobDataMap">
        <map>
            <entry key="firstService" value-ref="firstService" />
        </map>
    </property>
    -->
</bean>

jobClass 定义的任务类，继承 QuartzJobBean，实现 executeInternal 方法；可以使用 jobDataMap 来给 job 传递数据；

配置调度触发器

调度的触发器同样也提供了两种类型，分别是：

  • SimpleTriggerFactoryBean
  • CronTriggerFactoryBean
    CronTriggerFactoryBean 相对更加灵活，本例中也是采用这种类型的触发器，如下：
applicationContext-job.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<!-- 执行定时器 -->
<bean id="springFrameworkQuartzJobDemoId"
    class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
    <!--
                     每隔5秒执行一次：*/5 * * * * ?
                     每隔1分钟执行一次：0 */1 * * * ?
                     每天23点执行一次：0 0 23 * * ?
                     每天凌晨1点执行一次：0 0 1 * * ?
                     每月1号凌晨1点执行一次：0 0 1 1 * ?
                     每月最后一天23点执行一次：0 0 23 L * ?
                     每周星期天凌晨1点实行一次：0 0 1 ? * L
                     在26分、29分、33分执行一次：0 26,29,33 * * * ?
                     每天的0点、13点、18点、21点都执行一次：0 0 0,13,18,21 * * ?
     -->
    <property name="cronExpression" value="*/5 * * * * ?"/>
    <property name="jobDetail" ref="springFrameworkQuartzJobDemoBeanId"/>
</bean>

配置 Quartz 调度器的 SchedulerFactoryBean

Quartz 调度器的 SchedulerFactoryBean 同样也提供了两种方式：

  • 内存 RAMJobStore
  • 数据库方式

RAMJobStore

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

applicationContext-job.xml
1
2
3
4
5
6
7
8
9
<bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean" lazy-init="false">
    <property name="triggers">
        <list>
            <ref bean="springFrameworkQuartzJobDemoId" />
            <!-- 如果有多个定时任务就在这里添加 -->
            <!-- <ref bean="quartzTrigger2" /> -->
        </list>
    </property>
</bean>

数据库方式

job 的相关信息存储在数据库中，所有节点共用数据库，每个节点通过数据库来通信，保证一个 job 同一时间只会在一个节点上执行，并且如果某个节点挂掉，job 会被分配到其他节点执行，这也是集群部署时，分布式的调度系统采用的方式。

其原理如下：
分布式的调度系统
具体配置如下：

applicationContext-job.xml
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
<bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean" lazy-init="false">
    <property name="dataSource" ref="dataSource" />
    <property name="quartzProperties">
        <props>
            <prop key="org.quartz.scheduler.instanceName">EBMDynamicQuartz</prop>
            <prop key="org.quartz.scheduler.instanceId">AUTO</prop>
            <!-- 线程池配置 -->
            <prop key="org.quartz.threadPool.class">org.quartz.simpl.SimpleThreadPool</prop>
            <prop key="org.quartz.threadPool.threadCount">20</prop>
            <prop key="org.quartz.threadPool.threadPriority">5</prop>
            <!-- JobStore 配置 -->
            <prop key="org.quartz.jobStore.class">org.quartz.impl.jdbcjobstore.JobStoreTX</prop>
            <!-- 集群配置 -->
            <prop key="org.quartz.jobStore.isClustered">true</prop>
            <prop key="org.quartz.jobStore.clusterCheckinInterval">15000</prop>
            <prop key="org.quartz.jobStore.maxMisfiresToHandleAtATime">1</prop>
            <prop key="org.quartz.jobStore.misfireThreshold">120000</prop>
            <prop key="org.quartz.jobStore.tablePrefix">QRTZ_</prop>
        </props>
    </property>
    <property name="schedulerName" value="EBMDynamicQuartz" />
    <!--必须的，QuartzScheduler 延时启动，应用启动完后 QuartzScheduler 再启动 -->
    <property name="startupDelay" value="30" />
    <property name="applicationContextSchedulerContextKey" value="applicationContextKey" />
    <!--可选，QuartzScheduler 启动时更新己存在的Job，这样就不用每次修改targetObject后删除qrtz_job_details表对应记录了 -->
    <property name="overwriteExistingJobs" value="true" />
    <!-- 设置自动启动 -->
    <property name="autoStartup" value="true" />
    <!--<property name="configLocation" value="classpath:quartz.properties" />-->
</bean>

dataSource 用来配置数据源，数据表相关信息，可以到 quartz 官网下载 gz 包。面提供了主流数据库的 sql 文件，总共 11 张表，本例采用 mysql 数据库，表结构如下：

tables_mysql.sql
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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
#
# Quartz seems to work best with the driver mm.mysql-2.0.7-bin.jar
#
# PLEASE consider using mysql with innodb tables to avoid locking issues
#
# In your Quartz properties file, you'll need to set
# org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#

DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;
DROP TABLE IF EXISTS QRTZ_LOCKS;
DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;
DROP TABLE IF EXISTS QRTZ_CALENDARS;


CREATE TABLE QRTZ_JOB_DETAILS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    JOB_NAME  VARCHAR(200) NOT NULL,
    JOB_GROUP VARCHAR(200) NOT NULL,
    DESCRIPTION VARCHAR(250) NULL,
    JOB_CLASS_NAME   VARCHAR(250) NOT NULL,
    IS_DURABLE VARCHAR(1) NOT NULL,
    IS_NONCONCURRENT VARCHAR(1) NOT NULL,
    IS_UPDATE_DATA VARCHAR(1) NOT NULL,
    REQUESTS_RECOVERY VARCHAR(1) NOT NULL,
    JOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
);

CREATE TABLE QRTZ_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    JOB_NAME  VARCHAR(200) NOT NULL,
    JOB_GROUP VARCHAR(200) NOT NULL,
    DESCRIPTION VARCHAR(250) NULL,
    NEXT_FIRE_TIME BIGINT(13) NULL,
    PREV_FIRE_TIME BIGINT(13) NULL,
    PRIORITY INTEGER NULL,
    TRIGGER_STATE VARCHAR(16) NOT NULL,
    TRIGGER_TYPE VARCHAR(8) NOT NULL,
    START_TIME BIGINT(13) NOT NULL,
    END_TIME BIGINT(13) NULL,
    CALENDAR_NAME VARCHAR(200) NULL,
    MISFIRE_INSTR SMALLINT(2) NULL,
    JOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
        REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP)
);

CREATE TABLE QRTZ_SIMPLE_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    REPEAT_COUNT BIGINT(7) NOT NULL,
    REPEAT_INTERVAL BIGINT(12) NOT NULL,
    TIMES_TRIGGERED BIGINT(10) NOT NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_CRON_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    CRON_EXPRESSION VARCHAR(200) NOT NULL,
    TIME_ZONE_ID VARCHAR(80),
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_SIMPROP_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    STR_PROP_1 VARCHAR(512) NULL,
    STR_PROP_2 VARCHAR(512) NULL,
    STR_PROP_3 VARCHAR(512) NULL,
    INT_PROP_1 INT NULL,
    INT_PROP_2 INT NULL,
    LONG_PROP_1 BIGINT NULL,
    LONG_PROP_2 BIGINT NULL,
    DEC_PROP_1 NUMERIC(13,4) NULL,
    DEC_PROP_2 NUMERIC(13,4) NULL,
    BOOL_PROP_1 VARCHAR(1) NULL,
    BOOL_PROP_2 VARCHAR(1) NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_BLOB_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    BLOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_CALENDARS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    CALENDAR_NAME  VARCHAR(200) NOT NULL,
    CALENDAR BLOB NOT NULL,
    PRIMARY KEY (SCHED_NAME,CALENDAR_NAME)
);

CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_GROUP  VARCHAR(200) NOT NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_FIRED_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    ENTRY_ID VARCHAR(95) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    INSTANCE_NAME VARCHAR(200) NOT NULL,
    FIRED_TIME BIGINT(13) NOT NULL,
    SCHED_TIME BIGINT(13) NOT NULL,
    PRIORITY INTEGER NOT NULL,
    STATE VARCHAR(16) NOT NULL,
    JOB_NAME VARCHAR(200) NULL,
    JOB_GROUP VARCHAR(200) NULL,
    IS_NONCONCURRENT VARCHAR(1) NULL,
    REQUESTS_RECOVERY VARCHAR(1) NULL,
    PRIMARY KEY (SCHED_NAME,ENTRY_ID)
);

CREATE TABLE QRTZ_SCHEDULER_STATE
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    INSTANCE_NAME VARCHAR(200) NOT NULL,
    LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
    CHECKIN_INTERVAL BIGINT(13) NOT NULL,
    PRIMARY KEY (SCHED_NAME,INSTANCE_NAME)
);

CREATE TABLE QRTZ_LOCKS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    LOCK_NAME  VARCHAR(40) NOT NULL,
    PRIMARY KEY (SCHED_NAME,LOCK_NAME)
);


commit;

附：本次项目地址
https://github.com/syshlang/syshlang-spring-quartz.git