Quartz 用法简介

示例学习地址：http://www.quartz-scheduler.org/documentation/quartz-2.2.x/cookbook/

Quartz 的用途可网上查找，本文的目的是使读者能快速的搭建出自己的Quartz 应用。

Quartz 任务调度框架有三个重要的模块，1：调度器Scheduler，2：触发器Trigger，3：任务Job。就是调度器在被触发器触发后，调度任务，使得任务被执行。

一：创建Scheduler。

有三种方式可以创建Scheduler对象。

1：创建默认Scheduler对象

SchedulerFactory schedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getScheduler();

2：创建带有制定属性值的Scheduler对象。属性值是 Properties 对象

Properties props = new Properties();
StdSchedulerFactory schedulerFactory = new StdSchedulerFactory();
schedulerFactory.initialize(props);
Scheduler scheduler = schedulerFactory.getScheduler();

3：创建加载指定文件的Scheduler对象

StdSchedulerFactory schedulerFactory = new StdSchedulerFactory();
schedulerFactory.initialize(fileName);
Scheduler scheduler = schedulerFactory.getScheduler();

Scheduler对象的启动和关闭：

scheduler.start();
scheduler.shutdown();

二：创建Job对象。

要创建我们自己的Job，也就是所谓的作业，我们需要自定义一个类并实现Job接口。代码如下：

public class HelloJob implements Job {

    @Override
    public void execute(JobExecutionContext context)
            throws JobExecutionException {
        System.out.println("hello job, i'm executing: ");
    }
}

下面我们再创建JobDetail，JobDetail 对象中存放了所有关于Job的信息。这里通过JobBuilder 创建JobDetail对象，代码如下：

JobDetail jobDetail = JobBuilder.newJob(HelloJob.class).withIdentity("helloJobIdentity", "helloJobGroup").build();

三：创建Trigger对象：

Trigger trigger = TriggerBuilder.newTrigger().withIdentity("helloTriggerId", "helloTriggerGroup").startNow().build();

简单实例：

public class Test {
    public static void main(String[] args) throws InterruptedException {
        try {
            StdSchedulerFactory schedulerFactory = new StdSchedulerFactory();
            Scheduler scheduler = schedulerFactory.getScheduler();
            JobDetail jobDetail = JobBuilder.newJob(HelloJob.class).withIdentity("helloJobIdentity", "helloJobGroup").build();
            Trigger trigger = TriggerBuilder.newTrigger().withIdentity("helloTriggerId", "helloTriggerGroup").startNow().build();
            scheduler.scheduleJob(jobDetail, trigger);
            scheduler.start();
            Thread.sleep(4000);
            scheduler.shutdown();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
}

输入结果为：hello job, i'm executing: 

一个Job可以对应多个Trigger，一个Trigger只能对应一个Job。如果想去除Scheduler中某一个Trigger对象，代码如下：

cheduler.unscheduleJob(TriggerKey.triggerKey("helloTriggerId", "helloTriggerGroup"));

如果想删除某个Job，代码如下：

scheduler.deleteJob(JobKey.jobKey("helloJobIdentity", "helloJobGroup"));

定义一个没有Trigger的Job

<span style="white-space:pre">	</span>try {
            StdSchedulerFactory schedulerFactory = new StdSchedulerFactory();
            Scheduler scheduler = schedulerFactory.getScheduler();
            JobDetail jobDetail = JobBuilder.newJob(HelloJob.class).withIdentity("helloJobIdentity", "helloJobGroup").storeDurably().build();
            //Trigger trigger = TriggerBuilder.newTrigger().withIdentity("helloTriggerId", "helloTriggerGroup").startNow().build();
            //scheduler.scheduleJob(jobDetail, trigger);
            scheduler.addJob(jobDetail, false);
            //scheduler.unscheduleJob(TriggerKey.triggerKey("helloTriggerId", "helloTriggerGroup"));
            //scheduler.deleteJob(JobKey.jobKey("helloJobIdentity", "helloJobGroup"));
            scheduler.start();
            scheduler.triggerJob(JobKey.jobKey("helloJobIdentity", "helloJobGroup"));
            Thread.sleep(4000);
            scheduler.shutdown();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }

定义一个已经存储Store的Job，这里所谓已被存储的Job 就是定义JobDetail时，调用了 storeDurably();

Trigger trigger = TriggerBuilder.newTrigger().startNow().forJob("helloJobId", "helloJobGroup").build();
scheduler.scheduleJob(trigger);

更新Job   Updating an existing Job。更新Job 就是定义一个与已有Job同名同组的Job，然后添加到scheduler中，代码如下：

// Add the new job to the scheduler, instructing it to "replace"
//  the existing job with the given name and group (if any)
JobDetail job1 = newJob(MyJobClass.class)
    .withIdentity("job1", "group1")
    .build();

// store, and set overwrite flag to 'true'     
scheduler.addJob(job1, true);

更新Trigger ，代码如下：

replace trigger

// Define a new Trigger 
Trigger trigger = newTrigger()
    .withIdentity("newTrigger", "group1")
    .startNow()
    .build();

// tell the scheduler to remove the old trigger with the given key, and put the new one in its place
sched.rescheduleJob(triggerKey("oldTrigger", "group1"), trigger);

update trigger

// Define a new Trigger 
Trigger trigger = newTrigger()
    .withIdentity("newTrigger", "group1")
    .startNow()
    .build();

// tell the scheduler to remove the old trigger with the given key, and put the new one in its place
sched.rescheduleJob(triggerKey("oldTrigger", "group1"), trigger);

// retrieve the trigger
Trigger oldTrigger = sched.getTrigger(triggerKey("oldTrigger", "group1");

// obtain a builder that would produce the trigger
TriggerBuilder tb = oldTrigger.getTriggerBuilder();

// update the schedule associated with the builder, and build the new trigger
// (other builder methods could be called, to change the trigger in any desired way)
Trigger newTrigger = tb.withSchedule(simpleSchedule()
    .withIntervalInSeconds(10)
    .withRepeatCount(10)
    .build();

sched.rescheduleJob(oldTrigger.getKey(), newTrigger);

Job 监听器，自定义监听器类并实现JobListener 接口。

public class HelloJobListener implements JobListener {
    String name;
    
    public HelloJobListener(String name) {
        this.name = name;
    }
    
    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public void jobToBeExecuted(JobExecutionContext context) {
        System.out.println("job to be executed.");
        
    }

    @Override
    public void jobExecutionVetoed(JobExecutionContext context) {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void jobWasExecuted(JobExecutionContext context,
            JobExecutionException jobException) {
        System.out.println("job has been executed.");
        
    }

}

public static void main(String[] args) throws InterruptedException {
        try {
            StdSchedulerFactory stdSchedulerFactory = new StdSchedulerFactory();
            JobDetail jobDetail = JobBuilder.newJob(HelloJob.class).withIdentity("helloJobId", "helloJobGroup").storeDurably().build();
            Scheduler scheduler = stdSchedulerFactory.getScheduler();
            Trigger trigger = TriggerBuilder.newTrigger().startNow().forJob("helloJobId", "helloJobGroup").startNow().build();
            scheduler.scheduleJob(jobDetail, trigger);
            scheduler.getListenerManager().addJobListener(new HelloJobListener("helloJobListener"));
            scheduler.start();
            scheduler.shutdown();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

输出结果为：

job to be executed.
hello job, i'm executing: 
job has been executed.

// Define a new Trigger 
Trigger trigger = newTrigger()
    .withIdentity("newTrigger", "group1")
    .startNow()
    .build();

// tell the scheduler to remove the old trigger with the given key, and put the new one in its place
sched.rescheduleJob(triggerKey("oldTrigger", "group1"), trigger);

Registering A JobListener With The Scheduler To Listen To All Jobs

scheduler.getListenerManager().addJobListener(myJobListener, allJobs());

Registering A JobListener With The Scheduler To Listen To A Specific Job

scheduler.getListenerManager().addJobListener(myJobListener, jobKeyEquals(jobKey("myJobName", "myJobGroup")));

Registering A JobListener With The Scheduler To Listen To All Jobs In a Group

scheduler.getListenerManager().addJobListener(myJobListener, jobGroupEquals("myJobGroup"));

// Define a new Trigger 
Trigger trigger = newTrigger()
    .withIdentity("newTrigger", "group1")
    .startNow()
    .build();

// tell the scheduler to remove the old trigger with the given key, and put the new one in its place
sched.rescheduleJob(triggerKey("oldTrigger", "group1"), trigger);

Creating a TriggerListener

Implement the TriggerListener interface.

package foo;

import org.quartz.JobExecutionContext;
import org.quartz.Trigger;
import org.quartz.TriggerListener;
import org.quartz.Trigger.CompletedExecutionInstruction;

public class MyTriggerListener implements TriggerListener {

    private String name;

    public MyTriggerListener(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }

    public void triggerComplete(Trigger trigger, JobExecutionContext context,
            CompletedExecutionInstruction triggerInstructionCode) {
        // do something with the event
        
    }

    public void triggerFired(Trigger trigger, JobExecutionContext context) {
        // do something with the event
    }

    public void triggerMisfired(Trigger trigger) {
        // do something with the event
    }

    public boolean vetoJobExecution(Trigger trigger, JobExecutionContext context) {
        // do something with the event
        return false;
    }

}

OR -

Extend TriggerListenerSupport.

package foo;

import org.quartz.JobExecutionContext;
import org.quartz.Trigger;
import org.quartz.listeners.TriggerListenerSupport;

public class MyOtherTriggerListener extends TriggerListenerSupport {

    private String name;

    public MyOtherTriggerListener(String name) {
        this.name = name;
    }
   
    public String getName() {
        return name;
    }

    @Override
    public void triggerFired(Trigger trigger, JobExecutionContext context) {
        // do something with the event
    }
}

Registering A TriggerListener With The Scheduler To Listen To All Triggers

scheduler.getListenerManager().addTriggerListener(myTriggerListener, allTriggers());

Registering A TriggerListener With The Scheduler To Listen To A Specific Trigger

scheduler.getListenerManager().addTriggerListener(myTriggerListener, triggerKeyEquals(triggerKey("myTriggerName", "myTriggerGroup")));

Registering A TriggerListener With The Scheduler To Listen To All Triggers In a Group

scheduler.getListenerManager().addTriggerListener(myTriggerListener, triggerGroupEquals("myTriggerGroup"));

// Define a new Trigger 
Trigger trigger = newTrigger()
    .withIdentity("newTrigger", "group1")
    .startNow()
    .build();

// tell the scheduler to remove the old trigger with the given key, and put the new one in its place
sched.rescheduleJob(triggerKey("oldTrigger", "group1"), trigger);

Creating a SchedulerListener

Extend TriggerListenerSupport and override methods for events you're interested in.

package foo;

import org.quartz.Trigger;
import org.quartz.listeners.SchedulerListenerSupport;

public class MyOtherSchedulerListener extends SchedulerListenerSupport {

    @Override
    public void schedulerStarted() {
        // do something with the event
    }

    @Override
    public void schedulerShutdown() {
        // do something with the event
    }
    
    @Override
    public void jobScheduled(Trigger trigger) {
        // do something with the event
    }
    
}

Registering A SchedulerListener With The Scheduler

scheduler.getListenerManager().addSchedulerListener(mySchedListener);

// Define a new Trigger 
Trigger trigger = newTrigger()
    .withIdentity("newTrigger", "group1")
    .startNow()
    .build();

// tell the scheduler to remove the old trigger with the given key, and put the new one in its place
sched.rescheduleJob(triggerKey("oldTrigger", "group1"), trigger);

Trigger That Executes Every Ten Seconds

Using SimpleTrigger

trigger = newTrigger()
    .withIdentity("trigger3", "group1")
    .startNow()
    .withSchedule(simpleSchedule()
            .withIntervalInSeconds(10)
            .repeatForever())
    .build();

// Define a new Trigger 
Trigger trigger = newTrigger()
    .withIdentity("newTrigger", "group1")
    .startNow()
    .build();

// tell the scheduler to remove the old trigger with the given key, and put the new one in its place
sched.rescheduleJob(triggerKey("oldTrigger", "group1"), trigger);