Quartzs的job，trriger监听器源码分析

最新推荐文章于 2024-04-26 08:15:00 发布
原创 最新推荐文章于 2024-04-26 08:15:00 发布 · 1.1k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#freemaker #springmvc #mybatis #bootstrap #SSM

本文深入剖析了QuartzScheduler的源码，重点讲解了如何调度Job和Trigger，包括scheduleJob方法的实现、触发器的校验和存储，以及调度监听器的使用。在调度过程中，Quartz会确保Job和Trigger的正确关联，并通过监听器通知调度状态的变化，如Job的添加和调度。此外，还介绍了内部调度器、监听管理器和信号器的重要角色。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

在job存储之后，之后做了job添加通知，通知调度器下一刻执行时间，并唤醒正在等在执行的job，然后添加trriger通知。
Java代码   
  1. public class QuartzScheduler  
  2.     implements RemotableQuartzScheduler  
  3. {  
  4.  public Date scheduleJob(JobDetail jobDetail, Trigger trigger)  
  5.         throws SchedulerException  
  6.     {  
  7.         validateState();  
  8.         if(jobDetail == null)  
  9.             throw new SchedulerException("JobDetail cannot be null");  
  10.         if(trigger == null)  
  11.             throw new SchedulerException("Trigger cannot be null");  
  12.         if(jobDetail.getKey() == null)  
  13.             throw new SchedulerException("Job's key cannot be null");  
  14.         if(jobDetail.getJobClass() == null)  
  15.             throw new SchedulerException("Job's class cannot be null");  
  16.     //包装触发器  
  17.         OperableTrigger trig = (OperableTrigger)trigger;  
  18.         if(trigger.getJobKey() == null)  
  19.         //设置触发器jobKey  
  20.             trig.setJobKey(jobDetail.getKey());  
  21.         else  
  22.         if(!trigger.getJobKey().equals(jobDetail.getKey()))  
  23.             throw new SchedulerException("Trigger does not reference given job!");  
  24.         trig.validate();  
  25.         Calendar cal = null;  
  26.         if(trigger.getCalendarName() != null)  
  27.             cal = resources.getJobStore().retrieveCalendar(trigger.getCalendarName());  
  28.         Date ft = trig.computeFirstFireTime(cal);  
  29.         if(ft == null)  
  30.         {  
  31.             throw new SchedulerException((new StringBuilder()).append("Based on configured schedule, the given trigger '").append(trigger.getKey()).append("' will never fire.").toString());  
  32.         } else  
  33.         {  
  34.         //存储job and trriger到jobStrore  
  35.             resources.getJobStore().storeJobAndTrigger(jobDetail, trig);  
  36.         //添加jobDetail到调度监听器  
  37.             notifySchedulerListenersJobAdded(jobDetail);  
  38.             //通知调度器下一刻调度时间  
  39.             notifySchedulerThread(trigger.getNextFireTime().getTime());  
  40.              //添加trigger到调度监听器  
  41.             notifySchedulerListenersSchduled(trigger);  
  42.             return ft;  
  43.         }  
  44.      //添加jobDetail  
  45.      public void notifySchedulerListenersJobAdded(JobDetail jobDetail)  
  46.     {  
  47.         List schedListeners = buildSchedulerListenerList();  
  48.         for(Iterator i$ = schedListeners.iterator(); i$.hasNext();)  
  49.         {  
  50.             SchedulerListener sl = (SchedulerListener)i$.next();  
  51.             try  
  52.             {  
  53.                 sl.jobAdded(jobDetail);  
  54.             }  
  55.             catch(Exception e)  
  56.             {  
  57.                 getLog().error("Error while notifying SchedulerListener of JobAdded.", e);  
  58.             }  
  59.         }  
  60.   
  61.     }  
  62.     //获取调度监听器  
  63.      private List buildSchedulerListenerList()  
  64.     {  
  65.         List allListeners = new LinkedList();  
  66.         allListeners.addAll(getListenerManager().getSchedulerListeners());  
  67.         allListeners.addAll(getInternalSchedulerListeners());  
  68.         return allListeners;  
  69.     }  
  70.     //获取内部调度器  
  71.       public List getInternalSchedulerListeners()  
  72.     {  
  73.         ArrayList arraylist = internalSchedulerListeners;  
  74.         JVM INSTR monitorenter ;  
  75.         return Collections.unmodifiableList(new ArrayList(internalSchedulerListeners));  
  76.         Exception exception;  
  77.         exception;  
  78.         throw exception;  
  79.     }  
  80.      //通知调度器下一刻调度时间  
  81.     protected void notifySchedulerThread(long candidateNewNextFireTime)  
  82.     {  
  83.         if(isSignalOnSchedulingChange())  
  84.             signaler.signalSchedulingChange(candidateNewNextFireTime);  
  85.     }  
  86.     //添加trigger到调度监听器  
  87.     public void notifySchedulerListenersSchduled(Trigger trigger)  
  88.     {  
  89.         List schedListeners = buildSchedulerListenerList();  
  90.         for(Iterator i$ = schedListeners.iterator(); i$.hasNext();)  
  91.         {  
  92.             SchedulerListener sl = (SchedulerListener)i$.next();  
  93.             try  
  94.             {  
  95.                 sl.jobScheduled(trigger);  
  96.             }  
  97.             catch(Exception e)  
  98.             {  
  99.                 getLog().error((new StringBuilder()).append("Error while notifying SchedulerListener of scheduled job.  Triger=").append(trigger.getKey()).toString(), e);  
  100.             }  
  101.         }  
  102.   
  103.     }  
  104.     private static String VERSION_MAJOR;  
  105.     private static String VERSION_MINOR;  
  106.     private static String VERSION_ITERATION;  
  107.     private QuartzSchedulerResources resources;  
  108.     private QuartzSchedulerThread schedThread;  
  109.     private ThreadGroup threadGroup;  
  110.     private SchedulerContext context;  
  111.     private ListenerManager listenerManager;//监听管理器  
  112.     private HashMap internalJobListeners;  
  113.     private HashMap internalTriggerListeners;  
  114.     private ArrayList internalSchedulerListeners;  
  115.     private JobFactory jobFactory;  
  116.     ExecutingJobsManager jobMgr;  
  117.     ErrorLogger errLogger;  
  118.     private SchedulerSignaler signaler;  
  119.     private Random random;  
  120.     private ArrayList holdToPreventGC;  
  121.     private boolean signalOnSchedulingChange;  
  122.     private volatile boolean closed;  
  123.     private volatile boolean shuttingDown;  
  124.     private boolean boundRemotely;  
  125.     private QuartzSchedulerMBean jmxBean;  
  126.     private Date initialStart;  
  127.     private final Timer updateTimer;  
  128. }  

//调度监听器 下载

Java代码   
  1.  public class ListenerManagerImpl  
  2.     implements ListenerManager  
  3. {  
  4. public ListenerManagerImpl()  
  5.     {  
  6.         globalJobListeners = new LinkedHashMap(10);  
  7.         globalTriggerListeners = new LinkedHashMap(10);  
  8.         globalJobListenersMatchers = new LinkedHashMap(10);  
  9.         globalTriggerListenersMatchers = new LinkedHashMap(10);  
  10.         schedulerListeners = new ArrayList(10);  
  11.     }  
  12.     //添加调度监听器  
  13.      public void addSchedulerListener(SchedulerListener schedulerListener)  
  14.     {  
  15.         synchronized(schedulerListeners)  
  16.         {  
  17.             schedulerListeners.add(schedulerListener);  
  18.         }  
  19.     }  
  20.     //添加job监听器  
  21.     public void addJobListener(JobListener jobListener, List matchers)  
  22.     {  
  23.         if(jobListener.getName() == null || jobListener.getName().length() == 0)  
  24.             throw new IllegalArgumentException("JobListener name cannot be empty.");  
  25.         synchronized(globalJobListeners)  
  26.         {  
  27.             globalJobListeners.put(jobListener.getName(), jobListener);  
  28.             LinkedList matchersL = new LinkedList();  
  29.             if(matchers != null && matchers.size() > 0)  
  30.                 matchersL.addAll(matchers);  
  31.             else  
  32.                 matchersL.add(EverythingMatcher.allJobs());  
  33.             globalJobListenersMatchers.put(jobListener.getName(), matchersL);  
  34.         }  
  35.     }  
  36.      //添加Trigger监听器  
  37.       public void addTriggerListener(TriggerListener triggerListener, List matchers)  
  38.     {  
  39.         if(triggerListener.getName() == null || triggerListener.getName().length() == 0)  
  40.             throw new IllegalArgumentException("TriggerListener name cannot be empty.");  
  41.         synchronized(globalTriggerListeners)  
  42.         {  
  43.             globalTriggerListeners.put(triggerListener.getName(), triggerListener);  
  44.             LinkedList matchersL = new LinkedList();  
  45.             if(matchers != null && matchers.size() > 0)  
  46.                 matchersL.addAll(matchers);  
  47.             else  
  48.                 matchersL.add(EverythingMatcher.allTriggers());  
  49.             globalTriggerListenersMatchers.put(triggerListener.getName(), matchersL);  
  50.         }  
  51.     }  
  52.      public List getSchedulerListeners()  
  53.     {  
  54.         ArrayList arraylist = schedulerListeners;  
  55.         JVM INSTR monitorenter ;  
  56.         return Collections.unmodifiableList(new ArrayList(schedulerListeners));  
  57.         Exception exception;  
  58.         exception;  
  59.         throw exception;  
  60.     }  
  61.   
  62.     private Map globalJobListeners;//LinkedHashMap<String,JobListener>,key为JobListener.getName()，全局job监听器  
  63.     private Map globalTriggerListeners;//LinkedHashMap<String,TriggerListener>,key为TriggerListener.getName()，全局Trriger监听器  
  64.     private Map globalJobListenersMatchers;  
  65.     private Map globalTriggerListenersMatchers;  
  66.     private ArrayList schedulerListeners;//List<SchedulerListener>调度监听器  
  67. }  

//QuartzSchedulerMBean 下载
Java代码   
  1. public class QuartzSchedulerMBeanImpl extends StandardMBean  
  2.     implements NotificationEmitter, QuartzSchedulerMBean, JobListener, SchedulerListener  
  3. {  
  4.   //添加jobDetail通知到JMX  
  5.   public void jobAdded(JobDetail jobDetail)  
  6.     {  
  7.         sendNotification("jobAdded", JobDetailSupport.toCompositeData(jobDetail));  
  8.     }  
  9.  //添加trigger通知到JMX  
  10.   public void jobScheduled(Trigger trigger)  
  11.     {  
  12.         sendNotification("jobScheduled", TriggerSupport.toCompositeData(trigger));  
  13.     }  
  14.   public void sendNotification(String eventType, Object data)  
  15.     {  
  16.         sendNotification(eventType, data, null);  
  17.     }  
  18.   
  19.  public void sendNotification(String eventType, Object data, String msg)  
  20.     {  
  21.         Notification notif = new Notification(eventType, this, sequenceNumber.incrementAndGet(), System.currentTimeMillis(), msg);  
  22.         if(data != null)  
  23.             notif.setUserData(data);  
  24.         emitter.sendNotification(notif);  
  25.     }  
  26. }  

//调度通知器 下载
Java代码   
  1. public class SchedulerSignalerImpl  
  2.     implements SchedulerSignaler  
  3. {  
  4.   
  5.     public SchedulerSignalerImpl(QuartzScheduler sched, QuartzSchedulerThread schedThread)  
  6.     {  
  7.         log = LoggerFactory.getLogger(org/quartz/core/SchedulerSignalerImpl);  
  8.         this.sched = sched;  
  9.         this.schedThread = schedThread;  
  10.         log.info((new StringBuilder()).append("Initialized Scheduler Signaller of type: ").append(getClass()).toString());  
  11.     }  
  12.   
  13.     public void signalSchedulingChange(long candidateNewNextFireTime)  
  14.     {  
  15.         schedThread.signalSchedulingChange(candidateNewNextFireTime);  
  16.     }  
  17.   
  18.     Logger log;  
  19.     protected QuartzScheduler sched;  
  20.     protected QuartzSchedulerThread schedThread;  
  21. }  

//调度器线程 下载
Java代码   
  1. public class QuartzSchedulerThread extends Thread  
  2. {  
  3. QuartzSchedulerThread(QuartzScheduler qs, QuartzSchedulerResources qsRsrcs)  
  4.     {  
  5.         this(qs, qsRsrcs, qsRsrcs.getMakeSchedulerThreadDaemon(), 5);  
  6.     }  
  7.     //唤醒所有等待sigLock的调度器  
  8.      public void signalSchedulingChange(long candidateNewNextFireTime)  
  9.     {  
  10.         synchronized(sigLock)  
  11.         {  
  12.             signaled = true;  
  13.             signaledNextFireTime = candidateNewNextFireTime;  
  14.             sigLock.notifyAll();  
  15.         }  
  16.     }  
  17.  private QuartzScheduler qs;  
  18.     private QuartzSchedulerResources qsRsrcs;  
  19.     private final Object sigLock;  
  20.     private boolean signaled;  
  21.     private long signaledNextFireTime;  
  22.     private boolean paused;  
  23.     private AtomicBoolean halted;  
  24.     private Random random;  
  25.     private static long DEFAULT_IDLE_WAIT_TIME = 30000L;  
  26.     private long idleWaitTime;  
  27.     private int idleWaitVariablness;  
  28.     private final Logger log;  
  29.   
  30. }  

//SchedulerListener 下载
Java代码   
  1. public interface SchedulerListener  
  2. {  
  3.     public abstract void jobScheduled(Trigger trigger);  
  4.     public abstract void jobUnscheduled(TriggerKey triggerkey);  
  5.     public abstract void triggerFinalized(Trigger trigger);  
  6.     public abstract void triggerPaused(TriggerKey triggerkey);  
  7.     public abstract void triggersPaused(String s);  
  8.     public abstract void triggerResumed(TriggerKey triggerkey);  
  9.     public abstract void triggersResumed(String s);  
  10.     public abstract void jobAdded(JobDetail jobdetail);  
  11.     public abstract void jobDeleted(JobKey jobkey);  
  12.     public abstract void jobPaused(JobKey jobkey);  
  13.     public abstract void jobsPaused(String s);  
  14.     public abstract void jobResumed(JobKey jobkey);  
  15.     public abstract void jobsResumed(String s);  
  16.     public abstract void schedulerError(String s, SchedulerException schedulerexception);  
  17.     public abstract void schedulerInStandbyMode();  
  18.     public abstract void schedulerStarted();  
  19.     public abstract void schedulerStarting();  
  20.     public abstract void schedulerShutdown();  
  21.     public abstract void schedulerShuttingdown();  
  22.     public abstract void schedulingDataCleared();  
  23. }  

//job监听器 下载
Java代码   
  1. public interface JobListener  
  2. {  
  3.     public abstract String getName();  
  4.     public abstract void jobToBeExecuted(JobExecutionContext jobexecutioncontext);  
  5.     public abstract void jobExecutionVetoed(JobExecutionContext jobexecutioncontext);  
  6.     public abstract void jobWasExecuted(JobExecutionContext jobexecutioncontext, JobExecutionException jobexecutionexception);  
  7. }  

//Trigger监听器 
Java代码   
  1. public interface TriggerListener  
  2. {  
  3.     public abstract String getName();  
  4.     public abstract void triggerFired(Trigger trigger, JobExecutionContext jobexecutioncontext);  
  5.     public abstract boolean vetoJobExecution(Trigger trigger, JobExecutionContext jobexecutioncontext);  
  6.     public abstract void triggerMisfired(Trigger trigger);  
  7.     public abstract void triggerComplete(Trigger trigger, JobExecutionContext jobexecutioncontext, Trigger.CompletedExecutionInstruction completedexecutioninstruction);  
  8. }  

sgkbkega
关注
Quartz任务调度
悟空、的博客园
04-12 745
Quartz任务调度 初始化 1.Quartz提供了任务调度工厂StdSchedulerFactory获取默认的工厂类，通过调用getScheduler可以获取任务调度程序，此时已经可以直接开启start执行任务调度，结束任务调度为shutdown 2.默认的quartz有默认的配置，时在org/quartz.properties，默认的线程数为10，存储器为内存方式RAMJobStore
Quartz定时任务框架API详尽指南
最新发布
weixin_32687875的博客
05-25 834
Quartz是一个开源的作业调度库，允许开发者通过预定义的时间表来执行复杂的计划任务。它在Java世界中广受欢迎，主要用于企业级应用中，以处理诸如定时报告、数据导入导出等任务。Quartz框架中的Job接口是定义任务的核心接口，它包含一个单一的方法，即execute。Job接口允许开发者定义一个具体的工作单元，这个工作单元被称为Job实例。当通过Scheduler调度后，Job实例会在指定的时间点或按照设定的频率执行。
结合源码分析在 Quartz 的集群模式中，调度器添加新的作业的流程
qq_22193961的博客
04-26 451
结合源码分析在 Quartz 的集群模式中，调度器添加新的作业的流程
java-jmx动态配置
bhwqq的博客
12-10 247
MBeanServer mbs = ManagementFactory.getPlatformMBeanServer(); jmxBean = new QuartzSchedulerMBeanImpl(this); //该实例必须实现StandardBean或者其他 mbs.registerMBean(jmxBean, new ObjectName(jmxObjectName)); jconsole命令可以管理mbean
java jobdetail_Java JobDetail.getJobClass方法代码示例
weixin_39994949的博客
02-16 203
import org.quartz.JobDetail; //导入方法依赖的package包/类/*** * Add the {@link org.quartz.Job} identified by the given* {@link org.quartz.JobDetail} to the Scheduler, and* associate the given {@link org.quartz...
基于Java核心技术的XXL-JOB分布式任务调度平台源码分析
02-12
XXL-JOB是由许雪里开发的一款轻量级分布式任务调度框架，其源码分析项目基于Java核心技术。XXL-JOB框架的设计初衷是为了提供一个高效、可靠且易于使用的分布式任务调度系统。框架的核心特点包括了分布式任务调度和...
xxl-job源码分析之--执行器（客户端)
zhmi_1015的专栏
03-02 834
xxl-job执行器（客户端的源码还是比较简单的），大致步骤如下声明XxlJobSpringExecutor在XxlJobSpringExecutor调用自身initJobHandlerMethodRepository方法，通过反射将xxljob的类、方法信息放在本地map中在XxlJobSpringExecutor调用父类start方法，该方法重要调用自身的initEmbedServer()
基于selenium+python实现的51job招聘数据可视化分析系统源码+项目说明.tar
11-16
基于selenium+python实现的51job招聘数据可视化分析系统源码+项目说明.tar基于selenium+python实现的51job招聘数据可视化分析系统源码+项目说明.tar基于selenium+python实现的51job招聘数据可视化分析系统源码+项目...
基于Java核心技术的xxl-job分布式任务调度平台源码解析
10-03
本项目通过深入分析xxl-job的源码，旨在帮助开发者更好地理解其内部工作原理，以及如何利用Java核心技术去实现一个稳定可靠的分布式任务调度平台。 xxl-job的源码主要包含以下几个部分：Java源文件、配置文件、图片...
基于Python的51job数分岗位招聘信息爬取分析设计源码
04-15
基于Python的51job数分岗位招聘信息爬取分析设计源码，该项目包含23个文件，主要文件类型有8个python源文件，以及6个xml配置文件。此外，还包括4个json配置文件，1个gitignore文件用于版本控制，以及1个iml文件。该...
quartz2.x源码分析——启动过程
dianziyuan8553的博客
06-09 224
title: quartz2.x源码分析——启动过程 date: 2017-04-13 14:59:01 categories: quartz tags: [quartz, 源码分析] --- 先简单介绍一下quartz，Quartz是一个功能丰富的开源作业调度库，可以集成到几乎任何Java应用程序中 - 从最小的独立应用程序到最大的电子商务系统。quartz可用于创建执行数十，数百甚...
ORACLE的Job Classes设置管理job日志
u010719917的专栏
03-08 4897
转自：https://www.linuxidc.com/Linux/2014-11/109596.htm          http://www.blogjava.net/javaex/articles/303634.html          http://blog.sina.com.cn/s/blog_c0be477d0102vicm.html一、查看job调用的class     --&gt...
Quartz任务调度(4)JobListener分版本超详细解析
热门推荐
总结沉淀
03-27 1万+
在《spring学习笔记(15)趣谈spring 事件：实现业务逻辑解耦，异步调用提升用户体验》我们通过实例分析讲解了spring的事件机制，或许你会觉得其中的配置略显繁琐，而在Quartz框架中，它为我们集成了强大的事件机制，轻松地帮助我们在任务调度中完成各类辅佐操作，高内聚而耦合。 相对spring的事件实现，quartz这边简化了许多，我们只需： 1. 自定义监听器接口实现类 2. 向
在Spring配置中使用Quartz的Listeners
ndzl
10-22 354
最近在做后台运行Jobs的统计和监控。原本想写一个Job的基类，在基类中使用listener的方式解耦Jobs和监听的操作。 翻了翻Quartz的源码，发现Quartz本身已经有一整套完整的Listeners机制。分别在Job、Trigger、Scheduler三层都有Listener。 Quartz的Tutorial的Lesson 7 & 8提到了这些Listener接口：http:...
SimpleTrigger、CronTrigger、SchedulerListener、TriggerListener、JobListener区别
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
05-21 1232
SimpleTrigger的属性包括：开始时间、结束时间、重复次数以及重复的间隔    CronTrigger是基于日历表示法的调度，而不是基于指定间隔的简单调度 listener是一个对象，用于监听scheduler中发生的事件，然后执行相应的操作，TriggerListeners接受与trigger相关的事件，JobListeners接受与jobs相关的事件。 trigger相关的事
Quartz任务调度(1)概念例析快速入门
weixin_34104341的博客
03-27 193
Quartz框架需求引入 在现实开发中，我们常常会遇到需要系统在特定时刻完成特定任务的需求，在《spring学习笔记(14)引介增强详解：定时器实例：无侵入式动态增强类功能》，我们通过引介增强来简单地模拟实现了一个定时器。它可能只需要我们自己维护一条线程就足以实现定时监控。但在实际开发中，我们遇到的需求会复杂很多，可能涉及多点任务调度...
Quartz因不同版本导致的异常
07-06 7122
学习Quartz,因为使用了quartz-all-1.8.5.jar的jar，但是文档是1.6版本的，导致出现几次莫名奇妙的错，都是因为不同版本中使用到都类不一样 当我使用下面配置都时候： <bean id="jobtask" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值