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

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

一、Hello Quartz

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

	org.quartz-scheduler
	quartz
	2.2.1

定义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压缩包下的**\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格式错误异常。

			mysql
			mysql-connector-java
			5.1.31

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 triggerGroups = scheduler.getTriggerGroupNames();
        // 重新恢复在triggerGroup1组中，名为trigger_1触发器的运行
        for (int i = 0; i < triggerGroups.size(); i++) {
            List 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中导入相关包：

		org.springframework.boot
		spring-boot-starter-parent
		1.5.6.RELEASE
		 
	

	
		UTF-8
		UTF-8
		1.8
	

	
		
			org.springframework.boot
			spring-boot-starter
		

		
			org.springframework.boot
			spring-boot-starter-test
			test
		
	

	
		
			
				org.springframework.boot
				spring-boot-maven-plugin
			
		
	

  然后同上文配置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配置如下：

    
    
    
        
        
        
        
            
        
    

    
    
    
    
        
        
            
        
        
            service
        
    
    

    
    
        
        
        
            
                
                
            
        
        
        
    

    
    
    
        
        
    
    
    
        
        
        
        
            
        
        
    

六、基于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配置如下：