java定时调度工具quartz

一. Jar包依赖

使用Maven进行Jar包的管理，使用的jar包如下：

<!-- quartz 的jar -->
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>
<version>2.2.1</version>
</dependency>
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz-jobs</artifactId>
<version>2.2.1</version>
</dependency>
<!-- spring相关jar -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.0.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>4.0.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>4.0.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>4.0.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>4.0.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>3.2.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>4.0.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-oxm</artifactId>
<version>4.0.5.RELEASE</version>
</dependency>

<!-- 日志相关jar包 -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.5</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>1.7.5</version>
</dependency>
<dependency><!--   Failed to load class "org.slf4j.impl.StaticLoggerBinder". -->
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.0.13</version>
</dependency>
<!-- MySql的包 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.31</version>
</dependency>

Spring框架中的Quartz学习使用

原创 2016年08月13日
14:00:50

1598

Spring框架中的Quartz使用:

首先简单介绍下Quartz,它是一个完全由Java编写的开源作业调度框架，为在Java应用程序中进行作业调度提供了简单却强大的机制,相当于java.util.Timer，但是比Timer多了很多的功能:

1.持久性作业，就是保持调度定时的状态;

2.作业管理，对调度作业进行有效的管理；

3.类Corn的定时支持，可以用Corn的方式来执行作业；

4.线程处理模型 Timer是单线程作业的，但是Quartz支持线程缓冲池。

在Spring中可以很方便的使用Quartz来实现定时任务等功能，我先介绍一下不使用Spring的Quartz实现，主要就是讲解Schedule（任务调度器），Job（作业任务）和Trigger（触发器）三者的关系。具体的体系结构从网上copy过来，讲的比较详细：

●Job：是一个接口，只有一个方法void execute(JobExecutionContext context)，开发者实现该接口定义运行任务，JobExecutionContext类提供了调度上下文的各种信息。

●JobDetail：Quartz在每次执行Job时，都重新创建一个Job实例，所以它不直接接受一个Job的实例，相反它接收一个Job实现类，以便运行时通过newInstance()的反射机制实例化Job。因此需要通过一个类来描述Job的实现类及其它相关的静态信息，如Job名字、描述、关联监听器等信息，JobDetail承担了这一角色。

●Trigger：是一个类，描述触发Job执行的时间触发规则。主要有SimpleTrigger和CronTrigger这两个子类。当仅需触发一次或者以固定时间间隔周期执行，SimpleTrigger是最适合的选择；而CronTrigger则可以通过Cron表达式定义出各种复杂时间规则的调度方案：如每早晨9:00执行，周一、周三、周五下午5:00执行等。

●Scheduler：代表一个Quartz的独立运行容器，Trigger和JobDetail可以注册到Scheduler中，两者在Scheduler中拥有各自的组及名称，组及名称是Scheduler查找定位容器中某一对象的依据，Trigger的组及名称必须唯一，JobDetail的组和名称也必须唯一（但可以和Trigger的组和名称相同，因为它们是不同类型的）。Scheduler定义了多个接口方法，允许外部通过组及名称访问和控制容器中Trigger和JobDetail。

Scheduler可以将Trigger绑定到某一JobDetail中，这样当Trigger触发时，对应的Job就被执行。一个Job可以对应多个Trigger，但一个Trigger只能对应一个Job。可以通过SchedulerFactory创建一个Scheduler实例。Scheduler拥有一个SchedulerContext，它类似于ServletContext，保存着Scheduler上下文信息，Job和Trigger都可以访问SchedulerContext内的信息。SchedulerContext内部通过一个Map，以键值对的方式维护这些上下文数据，SchedulerContext为保存和获取数据提供了多个put()和getXxx()的方法。可以通过Scheduler#
getContext()获取对应的SchedulerContext实例。

下面简单的helloword代码感受一下Quartz的工作流程：

[java] view
plain copy

package quartz;

import java.util.Date;

import org.quartz.Job;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

public class HelloWord implements Job{

//实现自己的定时方法

public void execute(JobExecutionContext arg0) throws JobExecutionException {

System.out.println("hello world " + new Date());

}

}

[java] view
plain copy

package quartz;

import java.util.Date;

import org.quartz.JobBuilder;

import org.quartz.JobDetail;

import org.quartz.Scheduler;

import org.quartz.SchedulerException;

import org.quartz.Trigger;

import org.quartz.TriggerBuilder;

import org.quartz.impl.StdSchedulerFactory;

public class SimpleExample {

public static void main(String[] args) throws SchedulerException{

SimpleExample example=new SimpleExample();

example.run();

}

public void run() throws SchedulerException {

//获取scheduler实例

Scheduler scheduler=StdSchedulerFactory.getDefaultScheduler();

scheduler.start();

//当前时间

Date runTime=new Date();

//定义一个 job 对象并绑定我们写的 HelloWord 类

// 真正执行的任务并不是Job接口的实例，而是用反射的方式实例化的一个JobDetail实例

JobDetail job=JobBuilder.newJob(HelloWord.class).withIdentity("job1","group1").build();

// 定义一个触发器，startAt方法定义了任务应当开始的时间 .即下一个整数分钟执行

Trigger trigger=TriggerBuilder.newTrigger().withIdentity("trigger1","group1").startAt(runTime).build();

// 将job和Trigger放入scheduler

scheduler.scheduleJob(job, trigger);

//启动

scheduler.start();

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

scheduler.shutdown();

}

}

}

在实际web应用中，我们可用通过使用spring框架来使用Quartz实现定时任务，而且很方便，一共有三种方式：

(在Srping3.0版本后,使用Quartz需要加入依赖:

[html] view
plain copy

<dependency>

<span style="white-space:pre"> </span><groupId>org.springframework</groupId>

<artifactId>spring-context-support</artifactId>

<version>3.2.8.RELEASE</version>

</dependency>

否则会报错)

1.第一种方式，需要继承JobBean，并重写executeInternal(JobExecutionContext context)，然后配置spring-quratz.xml文件，里配置三部分：1.任务调用类；2.任务调用方式；3.任务调用工厂：

[java] view
plain copy

<pre name="code" class="java">package spring.demo.pojo;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

import org.springframework.scheduling.quartz.QuartzJobBean;

//继承QuartzJobBean,并重写executeInternal方法

public class QuartzTask extends QuartzJobBean{

private int timeout;

private static int i = 0;

//调度工厂实例化后，经过timeout时间开始执行调度

public void setTimeout(int timeout) {

this.timeout = timeout;

}

@Override

protected void executeInternal(JobExecutionContext context)

throws JobExecutionException {

System.out.println("task running..."+ ++i + "进行中...");

}

}

[html] view
plain copy

<!-- 配置任务类 -->

<bean id="quartzTask" class="org.springframework.scheduling.quartz.JobDetailBean">

<property name="name" value="exampleJob"></property>

<property name="quartzClass" value="spring.demo.pojo.QuartzTask"></property>

<property name="jobDataAsMap">

<map>

<entry key="timeout" value="0" />

</map>

</property>

</bean>

[html] view
plain copy

<!-- 调度触发器方式 -->

<bean id="cronTriggerBean"

class="org.springframework.scheduling.quartz.CronTriggerBean">

<property name="jobDetail">

<ref bean="quartzTask" />

</property>

<!-- cron表达式 -->

<property name="cronExpression">

<value>10,15,20,25,30,35,40,45,50,55 * * * * ?</value>

</property>

</bean>

[html] view
plain copy

<!-- 调度工厂 -->

<bean id="SpringJobSchedulerFactoryBean"

class="org.springframework.scheduling.quartz.SchedulerFactoryBean">

<property name="triggers">

<list>

<ref bean="cronTriggerBean" />

</list>

</property>

</bean>

2.第二种方式，不需要继承基类，这样仍然是pojo，而是在spring-quratz.xml配置文件中，配置包装类，其他两个配置与上述一样：

[java] view
plain copy

package spring.demo.pojo;

public class QuartzJob {

public void work(){

System.out.println("work running...");

}

}

[java] view
plain copy

<pre name="code" class="html"><!-- 包装工作类 -->

<bean id="quartzJob" class="spring.demo.pojo.QuartzJob"></bean>

<bean id="jobTask"

class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">

<!-- 需要包装的类,即调度类 -->

<property name="targetObject">

<ref bean="quartzJob" />

</property>

<!-- 调用类中的方法 -->

<property name="targetMethod">

<!-- 具体的方法 -->

<value>work</value>

</property>

</bean>

[html] view
plain copy

<!-- 调度触发器方式 -->

<bean id="cronTriggerBean"

class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">

<property name="jobDetail">

<ref bean="jobTask"/>

</property>

<!-- cron表达式 -->

<property name="cronExpression">

<value>10,15,20,25,30,35,40,45,50,55 * * * * ?</value>

</property>

</bean>

[html] view
plain copy

<!-- 调度工厂 -->

<bean id="SpringJobSchedulerFactoryBean"

class="org.springframework.scheduling.quartz.SchedulerFactoryBean">

<property name="triggers">

<list>

<ref bean="cronTriggerBean" />

</list>

</property>

</bean>

3.第三种方式，通过@Scheduled注解的方式实现，需要修改applicationContext.xml三个部分内容：

1.xmlns添加：

[java] view
plain copy

xmlns:task="http://www.springframework.org/schema/task"

2.xsi:schemaLocation添加：

[java] view
plain copy
http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.1.xsd
3.applicationContext.xml中添加:

[java] view
plain copy

<task:annotation-driven/>

最后在我们的定时任务上添加上@Scheduled注解即可，一般都采用cronTrigger方式，即@Scheduled（cron=“相应的定时表达式”）

[java] view
plain copy

package spring.demo.service;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import org.springframework.scheduling.annotation.Scheduled;

import org.springframework.stereotype.Service;

@Service

public class QuartzService {

@Scheduled(cron = "0/2 * * * * *")

public void process() {

System.out.println("job run...");

}

public static void main(String[] args) throws InterruptedException {

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

while (true) {

System.out.println("main running...");

Thread.sleep(10000);

}

}

}

个人建议采用第二种和第三种的方式实现Quartz比较简洁方便,下面顺便在网上查阅关于cron表达式的资料,不过我记得好像有一些工具可以方便生成这些表达式(Visual Cron Editor)目前没有具体的研究过,当然有些表达式也可以百度查阅到：

Cron表达式包含6个必要组件和一个可选组件，如下表所示：



特殊字符的含义，见下表：



Cron表达式举例：

"30 * * * * ?" 每半分钟触发任务

"30 10 * * * ?" 每小时的10分30秒触发任务

"30 10 1 * * ?" 每天1点10分30秒触发任务

"30 10 1 20 * ?" 每月20号1点10分30秒触发任务

"30 10 1 20 10 ? *" 每年10月20号1点10分30秒触发任务

"30 10 1 20 10 ? 2011" 2011年10月20号1点10分30秒触发任务

"30 10 1 ? 10 * 2011" 2011年10月每天1点10分30秒触发任务

"30 10 1 ? 10 SUN 2011" 2011年10月每周日1点10分30秒触发任务

"15,30,45 * * * * ?" 每15秒，30秒，45秒时触发任务

"15-45 * * * * ?" 15到45秒内，每秒都触发任务

"15/5 * * * * ?" 每分钟的每15秒开始触发，每隔5秒触发一次

"15-30/5 * * * * ?" 每分钟的15秒到30秒之间开始触发，每隔5秒触发一次

"0 0/3 * * * ?" 每小时的第0分0秒开始，每三分钟触发一次

"0 15 10 ? * MON-FRI" 星期一到星期五的10点15分0秒触发任务

"0 15 10 L * ?" 每个月最后一天的10点15分0秒触发任务

"0 15 10 LW * ?" 每个月最后一个工作日的10点15分0秒触发任务

"0 15 10 ? * 5L" 每个月最后一个星期四的10点15分0秒触发任务

"0 15 10 ? * 5#3" 每个月第三周的星期四的10点15分0秒触发任务
注：在企业级开发过程中，正常情况下不会使用RAM方式进行任务的存储，都是使用JDBC方式。方便学习，这两种方式都进行介绍！

1：RAM存储方式的xml配置文件

（1）：配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd"> 
<!--
Spring整合Quartz进行配置遵循下面的步骤：
1：定义工作任务的Job
2：定义触发器Trigger，并将触发器与工作任务绑定
3：定义调度器，并将Trigger注册到Scheduler
-->
<!-- 1：定义任务的bean ，这里使用JobDetailFactoryBean,也可以使用MethodInvokingJobDetailFactoryBean ，配置类似-->
<bean name="hwJob" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
<!-- 指定job的名称 -->
<property name="name" value="hw_job"/>
<!-- 指定job的分组 -->
<property name="group" value="hw_group"/>
<!-- 指定具体的job类 -->
<property name="jobClass" value="com.dufy.spring.quartz.chapter01.job.HelloWorldJob"/>
<!-- 必须设置为true，如果为false，当没有活动的触发器与之关联时会在调度器中会删除该任务  -->
<property name="durability" value="true"/>
<!-- 指定spring容器的key，如果不设定在job中的jobmap中是获取不到spring容器的 -->
<property name="applicationContextJobDataKey" value="applicationContext"/>
</bean>
<!-- 2.1：定义触发器的bean，定义一个Simple的Trigger，一个触发器只能和一个任务进行绑定 -->
<!-- <bean name="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean">
指定Trigger的名称
<property name="name" value="hw_trigger"/>
指定Trigger的名称
<property name="group" value="hw_trigger_group"/>
指定Tirgger绑定的Job
<property name="jobDetail" ref="hwJob"/>
指定Trigger的延迟时间 1s后运行
<property name="startDelay" value="1000"/>
指定Trigger的重复间隔  5s
<property name="repeatInterval" value="5000"/>
指定Trigger的重复次数
<property name="repeatCount" value="5"/>
</bean> -->

<!-- 2.2：定义触发器的bean，定义一个Cron的Trigger，一个触发器只能和一个任务进行绑定 -->
<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
<!-- 指定Trigger的名称 -->
<property name="name" value="hw_trigger"/>
<!-- 指定Trigger的名称 -->
<property name="group" value="hw_trigger_group"/>
<!-- 指定Tirgger绑定的Job -->
<property name="jobDetail" ref="hwJob"/>
<!-- 指定Cron 的表达式 ，当前是每隔1s运行一次 -->
<property name="cronExpression" value="0/1 * * * * ?" />
</bean>

<!-- 3.定义调度器，并将Trigger注册到调度器中 -->
<bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
<list>
<!-- <ref bean="simpleTrigger"/> -->
<ref bean="cronTrigger"/>
</list>
</property>
<!-- <property name="autoStartup" value="true" /> -->
</bean>

</beans>

JDBC存储方式的xml配置文件

（1）：配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd"> 
<!-- =========JDBC版=========== -->
<!--
持久化数据配置，需要添加quartz.properties
-->
<bean name="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="applicationContextSchedulerContextKey" value="applicationContextKey"/>
<property name="configLocation" value="classpath:quartz.properties"/>
</bean>

</beans>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
[/code]

（2）：quartz.properties

# Default Properties file for use by StdSchedulerFactory
# to create a Quartz Scheduler Instance, if a different
# properties file is not explicitly specified.
#

#============================================================================
# Configure Main Scheduler Properties
#============================================================================
org.quartz.scheduler.instanceName: dufy_test
org.quartz.scheduler.instanceId = AUTO

org.quartz.scheduler.rmi.export: false
org.quartz.scheduler.rmi.proxy: false
org.quartz.scheduler.wrapJobExecutionInUserTransaction: false
#============================================================================
# Configure ThreadPool
#============================================================================
org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount: 2
org.quartz.threadPool.threadPriority: 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true

org.quartz.jobStore.misfireThreshold: 60000
#============================================================================
# Configure JobStore
#============================================================================

#default config
#org.quartz.jobStore.class: org.quartz.simpl.RAMJobStore
#持久化配置
org.quartz.jobStore.class:org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass:org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.useProperties:true

#============================================================================
#havent cluster spring
#============================================================================
org.quartz.jobStore.isClustered = false

#数据库表前缀
org.quartz.jobStore.tablePrefix:qrtz_
org.quartz.jobStore.dataSource:qzDS

#============================================================================
# Configure Datasources
#============================================================================
#JDBC驱动
org.quartz.dataSource.qzDS.driver:com.mysql.jdbc.Driver
org.quartz.dataSource.qzDS.URL:jdbc:mysql://localhost:3306/quartz_test
org.quartz.dataSource.qzDS.user:root
org.quartz.dataSource.qzDS.password:root
org.quartz.dataSource.qzDS.maxConnection:10