Quartz是一款性能强大的定时任务调度器。开发人员可以使用Quartz让任务在特定时间特定阶段进行运行。比如对特定类型新闻或股指期货指数等内容的爬取，可以编写爬虫程序然后使用Quartz在后台指定特定时间点对任务进行执行，来自动收集信息。大型系统间数据的按时批量导入任务也可由Quartz进行调度。Quartz提供两种类型的任务触发方式，一种是按指定时间间隔触发任务，另一种是按指定日历时间触发任务。下面将对Quartz进行详细介绍。

一、Hello Quartz

  下面首先实现一个简单实例。 
新建maven项目，在pom.xml导入Quartz的jar包：

<dependency><groupId>org.quartz-scheduler</groupId><artifactId>quartz</artifactId><version>2.2.1</version>
</dependency>

定义HelloJob类，实现Job接口并定义具体的任务逻辑。

public class HelloJob implements Job {@Overridepublic void execute(JobExecutionContext context) throws JobExecutionException {System.out.println("hello");}
}

实例化Scheduler、Triggle和Job对象，并执行定时任务。

public class QuartzConsole {public static void main(String[] args) throws SchedulerException {SchedulerFactory factory=new org.quartz.impl.StdSchedulerFactory();Scheduler scheduler=factory.getScheduler();//通过SchedulerFactory实例化Scheduler对象scheduler.start();JobDetail job=newJob(HelloJob.class)//指定Job的运行类.withIdentity("myJob","group1").build();// name "myJob", group "group1"两个变量作为一个job的keyTrigger trigger=newTrigger().withIdentity("myTrigger","group1")// name "myTrigger", group "group1" 两个变量作为一个trigger的key.startNow().withSchedule(simpleSchedule().withIntervalInSeconds(5).repeatForever())//定义任务触发方式，每5秒执行一次，一直重复。.build();scheduler.scheduleJob(job,trigger);}
}

运行程序每5秒执行一次Job。 
  Quartz通过Job、Triggle和Schedule实现任务的调度。三者关系如图所示。

  Job定义：开发者实现Job接口，重写execute()方法定义具体Job实现。JobDetail接口定义一个job的相关配置细节。通过JobBuilder构建一个实现JobDetail接口的JobDetailImpl类，传入Scheduler对象。 
  **Triggle定义：**Triggle有两种触发器实现，SimpleTriggle按指定时间间隔进行触发，CronTriggle按指定日历时间进行触发。Triggle接口同Job类似定义了触发器的具体配置细节，由TriggleBuilder构建触发器实例。 
  **Scheduler定义：**Scheduler调度器由SchedulerFactory产生，start()方法定义schedule的执行，将实例化的Job和Triggle对象作为scheduleJob()的入参，由该方法执行具体任务的触发执行。

二、SimpleTriggle和CronTriggle触发器。

  SimTriggle触发器可以指定某一个任务在一个特定时刻执行一次，或者在某一时刻开始执行然后重复若干次。 
  SimpleTriggle的代码实现如下。

public class SimpleTriggerJob implements Job {@Overridepublic void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");System.out.println("Hello SimpleTriggerJob -- "+df.format(new Date()));}
}

//SimpleTrigger触发器按指定时间间隔调度任务
public class SimpleTriggerTester {public static void main(String[] args) throws SchedulerException {JobDetail jobDetail=newJob(SimpleTriggerJob.class).withIdentity("simpleTriggerJob","group1").build();//未来5秒后执行一次
//        SimpleTrigger trigger=(SimpleTrigger) newTrigger()
//                .withIdentity("simpleTrigger","group1")
//                .startAt(futureDate(5, DateBuilder.IntervalUnit.SECOND))
//                .forJob("simpleTriggerJob","group1")
//                .build();//从特定时间开始，然后每隔十秒执行1次，重复3次：
//        SimpleTrigger trigger=(SimpleTrigger) newTrigger()
//                .withIdentity("simpleTrigger","group1")
//                .startAt(dateOf(18,11,40))
//                .withSchedule(simpleSchedule()
//                .withIntervalInSeconds(10)
//                .withRepeatCount(3))
//                .forJob("simpleTriggerJob","group1")
//                .build();//在每分钟开始时执行，每分钟执行一次，永远重复，直到指定时间点停止SimpleTrigger trigger=(SimpleTrigger) newTrigger().withIdentity("simpleTrigger","group1").startAt(evenMinuteDate(null)).withSchedule(simpleSchedule().withIntervalInMinutes(1).repeatForever()).endAt(dateOf(18,22,0)).forJob("simpleTriggerJob","group1").build();SchedulerFactory factory=new StdSchedulerFactory();Scheduler scheduler=factory.getScheduler();scheduler.start();scheduler.scheduleJob(jobDetail,trigger);}
}

  CronTriggle触发器作用范围更广，它是基于日历的概念而不是像SimpleTriggle触发器基于较短的一段特定时间间隔。 
例如：可以使用CronTriggle触发器，指定任务在每个周五晚上7点执行一次；在每个月的倒数第二天早上7点执行三次；按照时区的变换对任务运行进行动态调整。 
通过向cronSchedule()构造方法传递特定格式字符串配置任务的执行。 
字符串格式如“Seconds Minutes Hours Day-of-Month Month Day-of-Week Year” 
例如： 
“0 30 10-12 ? * WED,FRI”表示每周三和周五的10:30,11:30,12:30各执行一次 
“0 0/30 8-9 5,20 * ?”表示每个月第五天和第二十天的8点、9点每半个小时执行一次。 
取值范围： 
Seconds：0-60 
Minutes ：0-60 
Hours：0-23 
Day-of-Month：1-31 
Month：1-12 
Day-of-Week：1-7或SUN, MON, TUE, WED, THU, FRI 和SAT. 
“-”可代表从A到B时间段 
“/”代表一个递增时间，A/B指在当前的时间域，从A开始每B个当前时间单位执行一次，等价于在该时间域的第A，A+B,A+2B…时刻各触发任务一次。 
“?”用于day-of-month和day-of-week时间域，表示没有特别的设置。 
“L”用于day-of-month和day-of-week时间域，指定每个月或每周的倒数第n天。day-of-month的“6L”或者“FRIL”代表每个月的最后一个周五。“L-3”代表从每个月的第三天到最后一天。 
“A#B”在day-of-week时间域代表每个月的第B周的星期A。 
  CronTriggle的代码实现如下。 
“*”在时间域上代表“每个”或者无限重复的意思。 
CronTrigger实例代码如下：

//CronTrigger按指定日历时间运行job
// cronSchedule("_ _ _ _ _ _")   方法的6个参数代表的含义
// Seconds
// Minutes
// Hours
// Day-of-Month
// Month
// Day-of-Week
// Year (optional field)
// 具体参数设置见http://www.quartz-scheduler.org/documentation/quartz-2.2.x/tutorials/tutorial-lesson-06.htmlpublic class CronTriggerTester {public static void main(String[] args) throws SchedulerException {JobDetail jobDetail=newJob(CronTriggerJob.class).withIdentity("CronTriggerJob","group1").build();//每天的指定小时分钟点执行一次
//        Trigger trigger=newTrigger()
//                .withIdentity("CronTrigger","group1")
//                .forJob("CronTriggerJob","group1")
//                .withSchedule(dailyAtHourAndMinute(19,7))
//                .build();//每周日每分钟的第五秒开始执行，每5秒执行一次
//        Trigger trigger=newTrigger()
//                .withIdentity("CronTrigger","group1")
//                .forJob("CronTriggerJob","group1")
//                .withSchedule(cronSchedule("0/5 * * ? * 1"))
//                .build();//按指定时区的时间执行Trigger trigger=newTrigger().withIdentity("CronTrigger","group1").forJob("CronTriggerJob","group1").withSchedule(dailyAtHourAndMinute(19,23).inTimeZone(TimeZone.getTimeZone("Asia/Shanghai"))).build();SchedulerFactory factory=new StdSchedulerFactory();Scheduler scheduler= factory.getScheduler();scheduler.scheduleJob(jobDetail,trigger);scheduler.start();}
}

三、Listeners ——TriggerListeners、JobListeners和SchedulerListeners

  监听器用来对Job、Trigger和Schedule运行过程中的所处的运行状态和运行行为进行监听。TriggerListeners、JobListeners和SchedulerListeners分别为一组接口。实现接口并重写接口方法，实现对监听器的定制化开发。 然后通过ListenerManager对监听器进行注册。 
关于监听器的实例代码如下： 
  定制化的JobListner类：

public class MyJobListener implements JobListener{@Overridepublic String getName() {return "jobListener name is MyJobListener";}@Overridepublic void jobToBeExecuted(JobExecutionContext context) {System.out.println("当前任务将要执行。");}@Override public void jobExecutionVetoed(JobExecutionContext context) {System.out.println("当前任务执行被否决。");}@Override public void jobWasExecuted(JobExecutionContext context,JobExecutionException jobException) {System.out.println("当前任务执行完毕。");}
}

  定制化的TriggerListener类：

public class MyTriggerListener implements TriggerListener {@Override public String getName() {return "TriggerListener name is MyTriggerListener";}@Override public void triggerFired(Trigger trigger, JobExecutionContext context) {System.out.println("触发器正在触发");}@Override public boolean vetoJobExecution(Trigger trigger, JobExecutionContext context) {return false;}@Override public void triggerMisfired(Trigger trigger) {System.out.println("触发器错过触发");}@Override public void triggerComplete(Trigger trigger, JobExecutionContext context,Trigger.CompletedExecutionInstruction triggerInstructionCode) {System.out.println("触发器触发完毕");}
}

  定制化的SchedulerListener类：

public class MySchedulerListener implements SchedulerListener {@Override public void jobScheduled(Trigger trigger) {System.out.println("jobScheduled");}@Override public void jobUnscheduled(TriggerKey triggerKey) {System.out.println("jobScheduled");}@Override public void triggerFinalized(Trigger trigger) {System.out.println("triggerFinalized");}@Override public void triggerPaused(TriggerKey triggerKey) {System.out.println("triggerPaused");}@Override public void triggersPaused(String triggerGroup) {System.out.println("triggersPaused");}@Override public void triggerResumed(TriggerKey triggerKey) {System.out.println("triggerResumed");}@Override public void triggersResumed(String triggerGroup) {System.out.println("triggersResumed");}@Override public void jobAdded(JobDetail jobDetail) {System.out.println("jobAdded");}@Override public void jobDeleted(JobKey jobKey) {System.out.println("jobDeleted");}@Override public void jobPaused(JobKey jobKey) {System.out.println("jobPaused");}@Override public void jobsPaused(String jobGroup) {System.out.println("jobsPaused");}@Override public void jobResumed(JobKey jobKey) {System.out.println("jobResumed");}@Override public void jobsResumed(String jobGroup) {System.out.println("jobsResumed");}@Override public void schedulerError(String msg, SchedulerException cause) {System.out.println("schedulerError");}@Override public void schedulerInStandbyMode() {System.out.println("schedulerInStandbyMode");}@Override public void schedulerStarted() {System.out.println("schedulerStarted");}@Override public void schedulerStarting() {System.out.println("schedulerStarting");}@Override public void schedulerShutdown() {System.out.println("schedulerShutdown");}@Override public void schedulerShuttingdown() {System.out.println("schedulerShuttingdown");}@Override public void schedulingDataCleared() {System.out.println("schedulingDataCleared");}
}

  监听器测试类，Job使用HelloQuartz一节中的HelloJob类：

public class ListenerTester {public static void main(String[] args) throws SchedulerException {//初始化调度器SchedulerFactory factory=new StdSchedulerFactory();Scheduler scheduler=factory.getScheduler();JobDetail jobDetail=newJob(HelloJob.class).withIdentity("printerJob","group2").build();Trigger trigger=newTrigger().withIdentity("jobListenerTrigger","group2").startNow().withSchedule(simpleSchedule().withIntervalInSeconds(5)).build();//实例化监听器对象MyJobListener listener=new MyJobListener();MyTriggerListener triggerListener=new MyTriggerListener();MySchedulerListener schedulerListener=new MySchedulerListener();//通过调度器的ListenerManager注册JobListener和TriggerListener//scheduler.getListenerManager().addJobListener(listener,and(jobGroupEquals("group2"),keyEquals(jobKey("printerJob","group2"))));scheduler.getListenerManager().addJobListener(listener,keyEquals(jobKey("printerJob","group2")));scheduler.getListenerManager().addTriggerListener(triggerListener,keyEquals(triggerKey("jobListenerTrigger","group2")));scheduler.getListenerManager().addSchedulerListener(schedulerListener);
//删除JobListener
//scheduler.getListenerManager().removeJobListener(listener.getName());
//删除TriggerListener
//scheduler.getListenerManager().removeTriggerListener(triggerListener.getName());
//删除SchedulerListener
//scheduler.getListenerManager().removeSchedulerListener(schedulerListener);scheduler.start();scheduler.scheduleJob(jobDetail,trigger);}

四、Quartz的持久化配置

  Quartz提供两种持久化方式，基于内存的RAMJobStore方式和基于磁盘介质的JDBCJobStore方式。上文实例使用的是Quartz的基于内存的持久化方式，优点是内存存储执行高效，缺点很明显，当操作系统崩溃或其他异常导致定时器终止将无法恢复之前状态。 
下面介绍Quartz的JDBCJobStore持久化配置，Quartz提供基于多种数据库的持久化配置形式。本文以mySql 5.6为例对Quartz进行配置。 
官网下载Quartz的压缩包。 
首先建立数据存储表，Quartz压缩包下的\docs\dbTables提供对多种数据库的sql建表语句支持。使用tables_mysql_innodb.sql在mysql数据库中建立相关数据表。注意Quartz默认数据表以QRTZ_开头，可以修改为自己的命名规则。 
一共建立11张表，根据名称可猜测大致 
QRTZ_FIRED_TRIGGERS; 
QRTZ_PAUSED_TRIGGER_GRPS; 
QRTZ_SCHEDULER_STATE; 
QRTZ_LOCKS; 
QRTZ_SIMPLE_TRIGGERS; 
QRTZ_SIMPROP_TRIGGERS; 
QRTZ_CRON_TRIGGERS; 
QRTZ_BLOB_TRIGGERS; 
QRTZ_TRIGGERS; 
QRTZ_JOB_DETAILS; 
QRTZ_CALENDARS;

  在项目中进行配置，Quartz使用JDBC进行数据库连接。导入最新的mysql jdbc connector数据源。因为使用的是较新的5.6版本mysql，建议使用最新的msql myconnector，不然有可能会报sql格式错误异常。

<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.31</version>
</dependency>

resources目录下建立quartz.properties进行配置，Quartz会自动加载。关键配置参数和相关解释如下：

#集群配置
org.quartz.scheduler.instanceName: DefaultQuartzScheduler
#如果运行在非集群环境中，自动产生值将会是 NON_CLUSTERED。假如是在集群环境下,将会是主机名加上当前的日期和时间。
org.quartz.scheduler.instanceId:AUTO
org.quartz.scheduler.rmi.export: false
org.quartz.scheduler.rmi.proxy: false
org.quartz.scheduler.wrapJobExecutionInUserTransaction: false  #Quartz 自带的线程池实现类是 org.quartz.smpl.SimpleThreadPool
org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
#根据任务的多少灵活配置线程池中线程的数量
org.quartz.threadPool.threadCount: 10
org.quartz.threadPool.threadPriority: 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true  org.quartz.jobStore.misfireThreshold: 60000  #============================================================================
# Configure JobStore
#============================================================================#默认配置，数据保存到内存
#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
#数据库表前缀
#org.quartz.jobStore.tablePrefix:qrtz_
#注意这里设定的数据源名称为dbqz
org.quartz.jobStore.dataSource:dbqz#============================================================================
# Configure Datasources
#============================================================================
#org.quartz.jobStore.selectWithLockSQL = SELECT * FROM {0}LOCKS WHERE LOCK_NAME = ? FOR UPDATE
#org.quartz.dataSource.dbqz.validationQuery=SELECT 1
#JDBC驱动
org.quartz.dataSource.dbqz.driver:com.mysql.jdbc.Driver
org.quartz.dataSource.dbqz.URL:jdbc:mysql://127.0.0.1:3306/quartz?useUnicode=true&characterEncoding=UTF-8
org.quartz.dataSource.dbqz.user:数据库用户名
org.quartz.dataSource.dbqz.password:密码
org.quartz.dataSource.dbqz.maxConnection:10

实例代码：

public class DBScheduleTest {private static String JOB_GROUP_NAME = "ddlib";private static String TRIGGER_GROUP_NAME = "ddlibTrigger";public static void main(String[] args) throws SchedulerException, ParseException {
//        startJob();resumeJob();}public static void startJob() throws SchedulerException {SchedulerFactory factory = new StdSchedulerFactory();Scheduler scheduler=factory.getScheduler();JobDetail jobDetail=newJob(PersistenceJob.class).withIdentity("job_1","jobGroup1").build();Trigger trigger=newTrigger().withIdentity("trigger_1","triggerGroup1").startNow().withSchedule(simpleSchedule().repeatSecondlyForTotalCount(100)).build();scheduler.scheduleJob(jobDetail,trigger);scheduler.start();try {Thread.sleep(10000);} catch (InterruptedException e) {e.printStackTrace();}scheduler.shutdown();}public static void resumeJob() throws SchedulerException {SchedulerFactory factory = new StdSchedulerFactory();Scheduler scheduler = factory.getScheduler();// 获取调度器中所有的触发器组List<String> triggerGroups = scheduler.getTriggerGroupNames();// 重新恢复在triggerGroup1组中，名为trigger_1触发器的运行for (int i = 0; i < triggerGroups.size(); i++) {List<String> triggers = scheduler.getTriggerGroupNames();for (int j = 0; j < triggers.size(); j++) {Trigger tg = scheduler.getTrigger(new TriggerKey(triggers.get(j), triggerGroups.get(i)));// 根据名称判断if (tg instanceof SimpleTrigger&& tg.getDescription().equals("triggerGroup1.trigger_1")) {// 恢复运行scheduler.resumeJob(new JobKey(triggers.get(j),triggerGroups.get(i)));}}}scheduler.start();}
}

自定义Job类PersistenceJob：

public class PersistenceJob implements Job {private static int i=0;@Overridepublic void execute(JobExecutionContext context) throws JobExecutionException {System.out.println("job执行--"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+"--"+i++);}
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7

startJob()执行一个job，并设置触发器，每隔一秒执行一次，一共执行100次，在10秒之后，线程终止并让schedule关闭。观察数据库表结构。该job以及job的执行情况已经更新进数据表。 
resumeJob()重新创建schedule，并从数据库中查找拥有相同key的触发器，schedule.resuemeJob()恢复任务的运行。当任务结束删除数据表中的Job相关注册信息。

五、Spring集成Quartz

  spring提供对quartz的集成。通过对quartz相关bean的配置实现对quartz的加载。以spring boot为例，首先在maven项目的pom.xml中导入相关包：

<parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>1.5.6.RELEASE</version><relativePath/> <!-- lookup parent from repository --></parent><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding><java.version>1.8</java.version></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build>

  然后同上文配置quartz的jdbc持久化存储。 
  在resources下添加quartz-context.xml，对quartz进行配置。 
其中对job的构建方式有两种，一种是通过org.springframework.scheduling.quartz.JobDetailFactoryBean进行job构建，要实现Job接口。另一种是通过org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean对job进行构建，不用实现job接口。 
  quartz-context.xml配置如下：

<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:task="http://www.springframework.org/schema/task"xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context"xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.0.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.0.xsdhttp://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-3.0.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-3.0.xsdhttp://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd"><!--job任务配置,有两种方式--><!--方式一：使用JobDetailFactoryBean，要求关联的类要实现Job接口--><bean id="jobDetailTester" class="org.springframework.scheduling.quartz.JobDetailFactoryBean"><property name="durability" value="true"></property><property name="requestsRecovery" value="true"></property><property name="jobClass" value="com.czx.job.HelloJob"></property><property name="jobDataAsMap"><map><entry key="size" value="10"></entry></map></property></bean><!--方式二：使用MethodInvokingJobDetailFactoryBean--><!--注意，MethodInvokingJobDetailFactoryBean的提示：NOTE: JobDetails created via this FactoryBean are notserializable and thus not suitable for persistent job stores.You need to implement your own Quartz Job as a thin wrapper for each casewhere you want a persistent job to delegate to a specific service method.因为使用的基于数据库的持久化存储，所以在使用这种方式构建job对象时会报java序列化异常：Java.io.NotSerializableException:Unable to serialize JobDataMap for insertion into database becausethe value of property 'methodInvoker' is not serializable:org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean--><!--此种方式不推荐--><bean id="methodInvokingJobDetailTester" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"><property name="concurrent" value="false"></property><property name="targetObject"><ref bean="springJobTester"></ref><!--要关联的job任务类--></property><property name="targetMethod"><value>service</value></property><!--要执行方法的名称--></bean><bean id="springJobTester" class="com.czx.job.SpringJobTester"></bean><!--quartz 2.x scheduler启动开始--><bean name="scheduleFactory" lazy-init="false" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"><property name="autoStartup" value="true"></property><property name="startupDelay" value="10"></property><property name="triggers"><list><ref bean="cronTriggerTester"></ref><!--<ref bean="simpleTriggerTester"></ref>  会报序列化异常，原因如上所述--></list></property><property name="applicationContextSchedulerContextKey" value="applicationContext"></property><property name="configLocation" value="classpath:quartz.properties"></property></bean><!--触发器Trigger配置--><!--基于CronTrigger的触发方式--><bean id="cronTriggerTester" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean"><property name="jobDetail" ref="jobDetailTester"></property><property name="cronExpression" value="0/5 * * ? * MON"></property></bean><!--基于SimpleTrigger的触发方式--><bean id="simpleTriggerTester" class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean"><property name="jobDetail" ref="methodInvokingJobDetailTester"></property><property name="repeatInterval" value="2000"></property><property name="startDelay" value="0"></property><property name="jobDataAsMap"><map><entry key="size" value="10"></entry></map></property><property name="repeatCount" value="10"></property></bean>
</beans>

六、基于Spring QuartzJobBean的Quartz Job配置方式

  在实际情况中，自定义的job往往需要调用service和dao层的方法，对相关操作进行持久化。为了避免各模块间的高耦合。引入Spring QuartzJobBean，然后通过反射机制对具体业务逻辑方法进行调用。Spring QuartzJobBean是一个实现Job接口的抽象类，阅读源码发现executeInternal()在重写excute()的同时，将JobDetail中定义的DataMap键值映射为继承其子类的成员变量。我们通过继承QuartzJobBean定义自己的JobBean，然后设置与xml中对应job dataMap键值对相同的配置项为成员变量。通过设置jobData的targetClass和targetMethod两个键值对，来传递需要调用的业务类中的具体方法信息，最后在自定义的JobBean中通过反射机制获取该方法。具体实例如下： 
  首先定义继承QuartzJobBean的JobBean，MyQuartzJobBean.java

public class MyQuartzJobBean extends QuartzJobBean{/**目标类*/private String targetObject;/**要执行的方法*/private String targetMethod;@Overrideprotected void executeInternal(JobExecutionContext context)//executeInternal方法会将配置的job Data 键-值 作为该类的成员变量throws JobExecutionException {try {ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");Object targetClass=ctx.getBean(targetObject);Method method=null;//反射机制调用method=targetClass.getClass().getMethod(targetMethod,new Class[]{JobExecutionContext.class});method.invoke(targetClass,new Object[]{context});} catch (NoSuchMethodException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();} catch (InvocationTargetException e) {e.printStackTrace();}catch (Exception e){e.printStackTrace();}}//不可删除，QuartzJobBean通过set的方法，将job data值赋值给成员变量public void setTargetObject(String targetObject) {this.targetObject = targetObject;}public void setTargetMethod(String targetMethod) {this.targetMethod = targetMethod;}
}

  定义具体业务类SpringJobTester.java，实现具体Job的业务逻辑。

public class SpringJobTester{//实现Job的具体业务方法public void someService(JobExecutionContext context){SimpleDateFormat df=new SimpleDateFormat("HH:mm:ss");System.out.println("Hello SpringJobTester！----"+df.format(new Date()));}
}

  quartz-context.xml配置如下：

    <bean id="proxyJobBeanTester" class="org.springframework.scheduling.quartz.JobDetailFactoryBean"><property name="durability" value="true"></property><property name="requestsRecovery" value="true"></property><property name="jobClass" value="com.czx.job.MyQuartzJobBean"></property><property name="jobDataAsMap">  <!--使用JobData进行传参指定具体job类和具体的执行方法，与MyQuartzJobBean成员变量对应--><map><entry key="targetObject" value="springJobTester"></entry><!--具体业务类的引用--><entry key="targetMethod" value="someService"></entry><!--具体业务方法名--></map></property></bean><bean id="myQuartzJobBean" class="com.czx.job.MyQuartzJobBean"></bean><!--通过spring applicationContext获得该bean--><bean id="springJobTester" class="com.czx.job.SpringJobTester"></bean><!--scheduler配置启动--><bean name="scheduleFactory" lazy-init="false" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"><property name="autoStartup" value="true"></property><property name="startupDelay" value="5"></property><property name="triggers"><list><ref bean="simpleTriggerForProxy"/></list></property><property name="applicationContextSchedulerContextKey" value="applicationContext"></property><property name="configLocation" value="classpath:quartz.properties"></property></bean><!--触发器Trigger配置-->
<!--基于SimpleTrigger的触发方式--><bean id="simpleTriggerForProxy" class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean"><property name="jobDetail" ref="proxyJobBeanTester"></property><property name="repeatInterval" value="2000"></property>  <!--触发间隔2秒--><property name="startDelay" value="1"></property><property name="repeatCount" value="10"></property></bean>