QuartzJob监听

Job类

package com.mucfc;  
import java.text.SimpleDateFormat;  
import java.util.Date;  
  
import org.quartz.Job;  
import org.quartz.JobExecutionContext;  
import org.quartz.JobExecutionException;  
import org.springframework.scheduling.annotation.Scheduled;  
import org.springframework.stereotype.Component;  

  
public class MyJob implements Job{  
    public MyJob(){  
        System.out.println("MyJob创建成功");  
    }  
  
        @Override  
        public void execute(JobExecutionContext arg0)  
                throws JobExecutionException {  
            System.out.println("Hello MyJob  "+  
                    new SimpleDateFormat("yyyy-MM-dd HH:mm:ss ").format(new Date()));  
              
        }  
  
}  

---

Job监听器类

import org.quartz.JobExecutionContext;  
import org.quartz.JobExecutionException;  
import org.quartz.JobListener;  
  
public class MyJobListener implements JobListener{  
  
    @Override  
    public String getName() {  
        return "MyJobListener";  
    }  
     /** 
     * Scheduler 在 JobDetail 即将被执行，但又被 TriggerListener 否决了时调用这个方法。 
     */  
    @Override  
    public void jobExecutionVetoed(JobExecutionContext arg0) {  
        System.out.println("Job监听器：MyJobListener.jobExecutionVetoed()");          
    }  
     /** 
     * Scheduler 在 JobDetail 将要被执行时调用这个方法。 
     */  
    @Override  
    public void jobToBeExecuted(JobExecutionContext arg0) {  
        System.out.println("Job监听器：MyJobListener.jobToBeExecuted()");     
          
    }  
     /** 
     * Scheduler 在 JobDetail 被执行之后调用这个方法。 
     */  
    @Override  
    public void jobWasExecuted(JobExecutionContext arg0,  
            JobExecutionException arg1) {  
        System.out.println("Job监听器：MyJobListener.jobWasExecuted()");      
          
    }  
  
}  

---

Trigger监听器类

import org.quartz.JobExecutionContext;  
import org.quartz.Trigger;  
import org.quartz.Trigger.CompletedExecutionInstruction;  
import org.quartz.TriggerListener;  
  
public class MyTriggerListener implements TriggerListener{  
  
    @Override  
    public String getName() {  
        return "MyTriggerListener";  
    }  
  
    /** 
     * (1) 
     * Trigger被激发 它关联的job即将被运行 
     * Called by the Scheduler when a Trigger has fired, and it's associated JobDetail is about to be executed. 
     */  
    @Override  
    public void triggerFired(Trigger trigger, JobExecutionContext context) {  
        System.out.println("Trigger监听器：MyTriggerListener.triggerFired()");  
    }  
  
    /** 
     * (2) 
     * Trigger被激发 它关联的job即将被运行,先执行(1)，在执行(2) 如果返回TRUE 那么任务job会被终止 
     * Called by the Scheduler when a Trigger has fired, and it's associated JobDetail is about to be executed 
     */  
    @Override  
    public boolean vetoJobExecution(Trigger trigger, JobExecutionContext context) {  
        System.out.println("Trigger监听器：MyTriggerListener.vetoJobExecution()");  
        return false;  
    }  
  
    /** 
     * (3) 当Trigger错过被激发时执行,比如当前时间有很多触发器都需要执行，但是线程池中的有效线程都在工作， 
     *  那么有的触发器就有可能超时，错过这一轮的触发。 
     * Called by the Scheduler when a Trigger has misfired. 
     */  
    @Override  
    public void triggerMisfired(Trigger trigger) {  
        System.out.println("Trigger监听器：MyTriggerListener.triggerMisfired()");  
    }  
  
    /** 
     * (4) 任务完成时触发 
     * Called by the Scheduler when a Trigger has fired, it's associated JobDetail has been executed 
     * and it's triggered(xx) method has been called. 
     */  
    @Override  
    public void triggerComplete(Trigger trigger, JobExecutionContext context,  
            CompletedExecutionInstruction triggerInstructionCode) {  
        System.out.println("Trigger监听器：MyTriggerListener.triggerComplete()");  
    }  
  
}  

---

Scheduler监听器类

import org.quartz.JobDetail;  
import org.quartz.JobKey;  
import org.quartz.SchedulerException;  
import org.quartz.SchedulerListener;  
import org.quartz.Trigger;  
import org.quartz.TriggerKey;  
  
public class MySchedulerListener implements SchedulerListener{  
  
    @Override  
    public void jobAdded(JobDetail arg0) {  
    System.out.println("SchedulerListener监听器：MySchedulerListener.jobAdded()");    
    }  
  
    @Override  
    public void jobDeleted(JobKey arg0) {  
        System.out.println("SchedulerListener监听器：MySchedulerListener.jobDeleted()");      
    }  
  
    @Override  
    public void jobPaused(JobKey arg0) {  
        System.out.println("SchedulerListener监听器：MySchedulerListener.jobPaused()");   
    }  
  
    @Override  
    public void jobResumed(JobKey arg0) {  
        System.out.println("SchedulerListener监听器：MySchedulerListener.jobResumed()");      
    }  
  
    @Override  
    public void jobScheduled(Trigger arg0) {  
        System.out.println("SchedulerListener监听器：MySchedulerListener.jobScheduled()");    
    }  
  
    @Override  
    public void jobUnscheduled(TriggerKey arg0) {  
        System.out.println("SchedulerListener监听器：MySchedulerListener.jobUnscheduled()");      
    }  
  
    @Override  
    public void jobsPaused(String arg0) {  
        System.out.println("SchedulerListener监听器：MySchedulerListener.jobsPaused()");      
    }  
  
    @Override  
    public void jobsResumed(String arg0) {  
        System.out.println("SchedulerListener监听器：MySchedulerListener.jobsResumed()");     
    }  
  
    @Override  
    public void schedulerError(String arg0, SchedulerException arg1) {  
        System.out.println("SchedulerListener监听器：MySchedulerListener.schedulerError()");      
    }  
  
    @Override  
    public void schedulerInStandbyMode() {  
        System.out.println("SchedulerListener监听器：MySchedulerListener.schedulerInStandbyMode()");      
    }  
  
    @Override  
    public void schedulerShutdown() {  
        System.out.println("SchedulerListener监听器：MySchedulerListener.schedulerShutdown()");   
    }  
  
    @Override  
    public void schedulerShuttingdown() {  
        System.out.println("SchedulerListener监听器：MySchedulerListener.schedulerShuttingdown()");   
    }  
  
    @Override  
    public void schedulerStarted() {  
        System.out.println("SchedulerListener监听器：MySchedulerListener.schedulerStarted()");    
    }  
  
    @Override  
    public void schedulerStarting() {  
        System.out.println("SchedulerListener监听器：MySchedulerListener.schedulerStarting()");   
    }  
  
    @Override  
    public void schedulingDataCleared() {  
        System.out.println("SchedulerListener监听器：MySchedulerListener.schedulingDataCleared()");   
    }  
  
    @Override  
    public void triggerFinalized(Trigger arg0) {  
        System.out.println("SchedulerListener监听器：MySchedulerListener.triggerFinalized()");    
    }  
  
    @Override  
    public void triggerPaused(TriggerKey arg0) {  
        System.out.println("SchedulerListener监听器：MySchedulerListener.triggerPaused()");   
    }  
  
  
  
    @Override  
    public void triggersPaused(String arg0) {  
        System.out.println("SchedulerListener监听器：MySchedulerListener.triggersPaused()");      
    }  
  
    @Override  
    public void triggersResumed(String arg0) {  
        System.out.println("SchedulerListener监听器：MySchedulerListener.triggersResumed()");     
    }  
  
    @Override  
    public void triggerResumed(TriggerKey arg0) {  
        System.out.println("SchedulerListener监听器：MySchedulerListener.triggerResumed()");      
          
    }  
  
}  

---

注册使用

import java.util.List;  
  
import org.quartz.JobBuilder;  
import org.quartz.JobDetail;  
import org.quartz.Matcher;  
import org.quartz.Scheduler;  
import org.quartz.SchedulerException;  
import org.quartz.SimpleScheduleBuilder;  
import org.quartz.Trigger;  
import org.quartz.TriggerBuilder;  
import org.quartz.TriggerKey;  
import org.quartz.impl.StdSchedulerFactory;  
import org.quartz.impl.matchers.KeyMatcher;  
  
import static org.quartz.JobKey.*;   
import static org.quartz.impl.matchers.KeyMatcher.*;   
import static org.quartz.impl.matchers.GroupMatcher.*;   
import static org.quartz.impl.matchers.AndMatcher.*;   
import static org.quartz.impl.matchers.OrMatcher.*;   
import static org.quartz.impl.matchers.EverythingMatcher.*;  
public class MyTest {  
    public static void main(String[] args) {  
          
        try {  
            // 1、创建一个JobDetail实例，指定Quartz  
            JobDetail jobDetail = JobBuilder.newJob(MyJob.class)  
            // 任务执行类  
            .withIdentity("job1_1", "jGroup1")  
            // 任务名，任务组  
            .build();     
            //2、创建Trigger  
            SimpleScheduleBuilder builder=SimpleScheduleBuilder.simpleSchedule()  
            //设置间隔执行时间  
            .withIntervalInSeconds(5)  
            //设置执行次数  
            .repeatForever();  
            Trigger trigger=TriggerBuilder.newTrigger().withIdentity(  
                    "trigger1_1","tGroup1").startNow().withSchedule(builder).build();  
            //3、创建Scheduler  
            Scheduler scheduler=StdSchedulerFactory.getDefaultScheduler();  
            scheduler.start();    
              
              
            //添加TriggerListener监听器  
            MyTriggerListener myTriggerListener=new MyTriggerListener();  
            //  监听器所有的job  
            //scheduler.getListenerManager().addTriggerListener(myTriggerListener, allTriggers());  
            //  监听部分的job  
            scheduler.getListenerManager().addTriggerListener(myTriggerListener, keyEquals(new TriggerKey("trigger1_1","tGroup1")));  
            //  监听特定组的job  
            //scheduler.getListenerManager().addTriggerListener(myTriggerListener, triggerGroupEquals("tGroup1"));  
              
              
          
            // 添加JobListener监听器  
            MyJobListener myJobListener=new MyJobListener();  
            scheduler.getListenerManager()  
            .addJobListener(myJobListener, allJobs());  
            // 监听部分的job  
            //scheduler.getListenerManager()  
            //.addJobListener(myJobListener, keyEquals(jobKey("myJobName", "myJobGroup")));  
            //监听特定组的job  
            //scheduler.getListenerManager()  
            //.addJobListener(myJobListener, groupEquals("myJobGroup"));  
              
            //添加监听  
            MySchedulerListener schedulerListener = new MySchedulerListener();           
            scheduler.getListenerManager().addSchedulerListener(schedulerListener);      
              
              
              
            //4、调度执行  
            scheduler.scheduleJob(jobDetail, trigger);                
            try {  
                Thread.sleep(60000);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
   
            scheduler.shutdown();  
              
        } catch (SchedulerException e) {  
            e.printStackTrace();  
        }  
  
}  
}  

---

原文地址:点击进入