调度器Quartz的简述与使用总结

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 {
    @Override
    public 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的key
        Trigger 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 {
    @Override
    public 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.html

public 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{

    @Override
    public String getName() {
        return "jobListener name is MyJobListener";
    }

    @Override
    public 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压缩包下的docsdbTables提供对多种数据库的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;
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("job执行--"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+"--"+i++);
    }
}

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/beans
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-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/aop
       http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
       http://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 not
  serializable and thus not suitable for persistent job stores.
  You need to implement your own Quartz Job as a thin wrapper for each case
  where 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 because
    the 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;

    @Override
    protected 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>