or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

calendar-management.mdcore-scheduling.mdenterprise-features.mdexception-handling.mdindex.mdjob-management.mdlisteners-events.mdmatcher-framework.mdpersistence-storage.mdschedule-builders.mdtrigger-management.mdutilities-helpers.md
tile.json

tessl/maven-org-quartz-scheduler--quartz

Quartz Enterprise Job Scheduler - A richly featured, open source job scheduling library that can be integrated within virtually any Java application

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/org.quartz-scheduler/quartz@2.5.x

To install, run

npx @tessl/cli install tessl/maven-org-quartz-scheduler--quartz@2.5.0

index.mddocs/

Quartz Job Scheduler

Quartz is a comprehensive enterprise job scheduling library for Java applications that provides robust scheduling capabilities including cron-like scheduling, trigger management, job persistence, clustering support, and transaction management. The library is designed for maximum flexibility and can be integrated into applications ranging from simple standalone programs to large-scale enterprise systems.

Package Information

  • Package Name: quartz
  • Package Type: maven
  • Language: Java
  • Group ID: org.quartz-scheduler
  • Artifact ID: quartz
  • Version: 2.5.0
  • Installation: 
    <dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.5.0</version>
</dependency>

Core Imports

import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

import static org.quartz.JobBuilder.*;
import static org.quartz.TriggerBuilder.*;
import static org.quartz.SimpleScheduleBuilder.*;

Basic Usage

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import java.util.Date;

import static org.quartz.JobBuilder.*;
import static org.quartz.TriggerBuilder.*;
import static org.quartz.SimpleScheduleBuilder.*;

// Define a job class
public class HelloJob implements Job {
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("Hello World! - " + new Date());
    }
}

// Create scheduler instance
SchedulerFactory schedFact = new StdSchedulerFactory();
Scheduler sched = schedFact.getScheduler();

// Define job instance
JobDetail job = newJob(HelloJob.class)
    .withIdentity("job1", "group1")
    .build();

// Define a trigger that runs every 40 seconds
Trigger trigger = newTrigger()
    .withIdentity("trigger1", "group1")
    .startNow()
    .withSchedule(simpleSchedule()
        .withIntervalInSeconds(40)
        .repeatForever())
    .build();

// Schedule the job with the trigger
sched.scheduleJob(job, trigger);

// Start the scheduler
sched.start();

Architecture

Quartz is built around several key components:

  • Scheduler: The main interface for scheduling and managing jobs, acting as the central control point
  • Job: Interface that defines the work to be executed, implemented by application developers
  • JobDetail: Metadata container that describes a job instance including identity, data, and execution properties
  • Trigger: Defines when and how often a job should be executed, with multiple trigger types available
  • Builder Pattern: Fluent API using JobBuilder, TriggerBuilder, and ScheduleBuilder for type-safe object creation
  • Listener Framework: Comprehensive event system for monitoring job executions, trigger firings, and scheduler events
  • JobStore: Persistence layer supporting in-memory (RAMJobStore) or database storage for job and trigger data
  • Thread Pool: Configurable thread management for concurrent job execution

Capabilities

Core Scheduling

Primary scheduler management functionality including creating schedulers, lifecycle control, and basic job scheduling operations.

interface SchedulerFactory {
    Scheduler getScheduler() throws SchedulerException;
    Scheduler getScheduler(String schedName) throws SchedulerException;
    Collection<Scheduler> getAllSchedulers() throws SchedulerException;
}

interface Scheduler {
    // Lifecycle
    void start() throws SchedulerException;
    void startDelayed(int seconds) throws SchedulerException;
    void standby() throws SchedulerException;
    void shutdown() throws SchedulerException;
    void shutdown(boolean waitForJobsToComplete) throws SchedulerException;
    boolean isStarted() throws SchedulerException;
    boolean isInStandbyMode() throws SchedulerException;
    boolean isShutdown() throws SchedulerException;
    
    // Basic Scheduling
    Date scheduleJob(JobDetail jobDetail, Trigger trigger) throws SchedulerException;
    Date scheduleJob(Trigger trigger) throws SchedulerException;
    void scheduleJobs(Map<JobDetail, Set<? extends Trigger>> triggersAndJobs, boolean replace) throws SchedulerException;
}

Core Scheduling

Job Management

Job creation, configuration, and lifecycle management including job builders, job data, and execution context.

interface Job {
    void execute(JobExecutionContext context) throws JobExecutionException;
}

interface JobDetail {
    JobKey getKey();
    String getDescription();
    Class<? extends Job> getJobClass();
    JobDataMap getJobDataMap();
    boolean isDurable();
    boolean isPersistJobDataAfterExecution();
    boolean isConcurrentExecutionDisallowed();
    boolean requestsRecovery();
}

class JobBuilder {
    static JobBuilder newJob();
    static JobBuilder newJob(Class<? extends Job> jobClass);
    JobBuilder withIdentity(String name);
    JobBuilder withIdentity(String name, String group);
    JobBuilder withIdentity(JobKey key);
    JobBuilder withDescription(String jobDescription);
    JobBuilder ofType(Class<? extends Job> jobClazz);
    JobBuilder requestRecovery();
    JobBuilder requestRecovery(boolean jobShouldRecover);
    JobBuilder storeDurably();
    JobBuilder storeDurably(boolean jobDurability);
    JobBuilder usingJobData(String key, String value);
    JobBuilder usingJobData(JobDataMap newJobDataMap);
    JobDetail build();
}

Job Management

Trigger Management

Trigger creation, scheduling control, and various trigger types including simple, cron, and calendar-based triggers.

interface Trigger {
    TriggerKey getKey();
    JobKey getJobKey();
    String getDescription();
    String getCalendarName();
    JobDataMap getJobDataMap();
    int getPriority();
    Date getStartTime();
    Date getEndTime();
    Date getNextFireTime();
    Date getPreviousFireTime();
    Date getFireTimeAfter(Date afterTime);
    Date getFinalFireTime();
    int getMisfireInstruction();
    boolean mayFireAgain();
    TriggerBuilder<? extends Trigger> getTriggerBuilder();
}

class TriggerBuilder<T extends Trigger> {
    static TriggerBuilder<Trigger> newTrigger();
    TriggerBuilder<T> withIdentity(String name);
    TriggerBuilder<T> withIdentity(String name, String group);
    TriggerBuilder<T> withIdentity(TriggerKey key);
    TriggerBuilder<T> withDescription(String triggerDescription);
    TriggerBuilder<T> withPriority(int triggerPriority);
    TriggerBuilder<T> modifiedByCalendar(String calName);
    TriggerBuilder<T> startAt(Date triggerStartTime);
    TriggerBuilder<T> startNow();
    TriggerBuilder<T> endAt(Date triggerEndTime);
    <SBT extends T> TriggerBuilder<SBT> withSchedule(ScheduleBuilder<SBT> schedBuilder);
    TriggerBuilder<T> forJob(JobKey keyOfJobToFire);
    TriggerBuilder<T> forJob(String jobName);
    TriggerBuilder<T> forJob(String jobName, String jobGroup);
    TriggerBuilder<T> forJob(JobDetail jobDetail);
    TriggerBuilder<T> usingJobData(String key, String value);
    TriggerBuilder<T> usingJobData(JobDataMap newJobDataMap);
    T build();
}

Trigger Management

Schedule Builders

Fluent builders for creating different types of schedules including simple intervals, cron expressions, and calendar-based intervals.

class SimpleScheduleBuilder extends ScheduleBuilder<SimpleTrigger> {
    static SimpleScheduleBuilder simpleSchedule();
    static SimpleScheduleBuilder repeatMinutelyForever();
    static SimpleScheduleBuilder repeatMinutelyForever(int minutes);
    static SimpleScheduleBuilder repeatSecondlyForever();
    static SimpleScheduleBuilder repeatSecondlyForever(int seconds);
    static SimpleScheduleBuilder repeatHourlyForever();
    static SimpleScheduleBuilder repeatHourlyForever(int hours);
    
    SimpleScheduleBuilder withIntervalInMilliseconds(long intervalInMillis);
    SimpleScheduleBuilder withIntervalInSeconds(int intervalInSeconds);
    SimpleScheduleBuilder withIntervalInMinutes(int intervalInMinutes);
    SimpleScheduleBuilder withIntervalInHours(int intervalInHours);
    SimpleScheduleBuilder withRepeatCount(int triggerRepeatCount);
    SimpleScheduleBuilder repeatForever();
}

class CronScheduleBuilder extends ScheduleBuilder<CronTrigger> {
    static CronScheduleBuilder cronSchedule(String cronExpression);
    static CronScheduleBuilder cronSchedule(CronExpression cronExpression);
    static CronScheduleBuilder dailyAtHourAndMinute(int hour, int minute);
    static CronScheduleBuilder weeklyOnDayAndHourAndMinute(int dayOfWeek, int hour, int minute);
    static CronScheduleBuilder monthlyOnDayAndHourAndMinute(int dayOfMonth, int hour, int minute);
    
    CronScheduleBuilder inTimeZone(TimeZone timezone);
}

Schedule Builders

Exception Handling

Comprehensive exception hierarchy for handling scheduling errors, job execution problems, and configuration issues.

class SchedulerException extends Exception {
    SchedulerException();
    SchedulerException(String msg);
    SchedulerException(Throwable cause);
    SchedulerException(String msg, Throwable cause);
    Throwable getUnderlyingException();
}

class JobExecutionException extends SchedulerException {
    JobExecutionException();
    JobExecutionException(Throwable cause);
    JobExecutionException(String msg);
    JobExecutionException(boolean refireImmediately);
    JobExecutionException(Throwable cause, boolean refireImmediately);
    
    void setRefireImmediately(boolean refire);
    boolean refireImmediately();
    void setUnscheduleFiringTrigger(boolean unscheduleTriggger);
    boolean unscheduleFiringTrigger();
    void setUnscheduleAllTriggers(boolean unscheduleAllTriggers);
    boolean unscheduleAllTriggers();
}

Exception Handling

Listeners and Events

Event-driven architecture for monitoring job executions, trigger firings, and scheduler lifecycle events.

interface JobListener {
    String getName();
    void jobToBeExecuted(JobExecutionContext context);
    void jobExecutionVetoed(JobExecutionContext context);
    void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException);
}

interface TriggerListener {
    String getName();
    void triggerFired(Trigger trigger, JobExecutionContext context);
    boolean vetoJobExecution(Trigger trigger, JobExecutionContext context);
    void triggerMisfired(Trigger trigger);
    void triggerComplete(Trigger trigger, JobExecutionContext context, CompletedExecutionInstruction triggerInstructionCode);
}

interface SchedulerListener {
    void jobScheduled(Trigger trigger);
    void jobUnscheduled(TriggerKey triggerKey);
    void triggerFinalized(Trigger trigger);
    void triggerPaused(TriggerKey triggerKey);
    void triggersPaused(String triggerGroup);
    void triggerResumed(TriggerKey triggerKey);
    void triggersResumed(String triggerGroup);
    void jobAdded(JobDetail jobDetail);
    void jobDeleted(JobKey jobKey);
    void jobPaused(JobKey jobKey);
    void jobsPaused(String jobGroup);
    void jobResumed(JobKey jobKey);
    void jobsResumed(String jobGroup);
    void schedulerError(String msg, SchedulerException cause);
    void schedulerInStandbyMode();
    void schedulerStarted();
    void schedulerStarting();
    void schedulerShutdown();
    void schedulerShuttingdown();
    void schedulingDataCleared();
}

Listeners and Events

Utilities and Helpers

Utility classes for date manipulation, cron expression parsing, and other common scheduling operations.

class DateBuilder {
    enum IntervalUnit {
        MILLISECOND, SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, YEAR
    }
    
    static DateBuilder newDate();
    static DateBuilder newDateInTimezone(TimeZone tz);
    static Date todayAt(int hour, int minute, int second);
    static Date tomorrowAt(int hour, int minute, int second);
    static Date futureDate(int interval, IntervalUnit unit);
    static Date nextGivenMinuteDate(Date date, int minuteBase);
    static Date evenSecondDate(Date date);
    static Date evenMinuteDate(Date date);
    static Date evenHourDate(Date date);
}

class CronExpression implements Serializable, Cloneable {
    CronExpression(String cronExpression) throws ParseException;
    static boolean isValidExpression(String cronExpression);
    boolean isSatisfiedBy(Date date);
    Date getNextValidTimeAfter(Date date);
    Date getNextInvalidTimeAfter(Date date);
    TimeZone getTimeZone();
    void setTimeZone(TimeZone timeZone);
    String getCronExpression();
}

Utilities and Helpers

Calendar Management

Sophisticated time exclusion system for excluding specific dates, times, and periods from trigger schedules using various calendar implementations.

interface Calendar {
    boolean isTimeIncluded(long timeStamp);
    long getNextIncludedTime(long timeStamp);
    String getDescription();
    void setDescription(String description);
    Calendar getBaseCalendar();
    void setBaseCalendar(Calendar baseCalendar);
}

class HolidayCalendar extends BaseCalendar {
    void addExcludedDate(Date excludedDate);
    void removeExcludedDate(Date dateToRemove);
    SortedSet<Date> getExcludedDates();
    boolean isDateExcluded(Date dateToCheck);
}

class WeeklyCalendar extends BaseCalendar {
    void setDayExcluded(int wday, boolean exclude);
    boolean isDayExcluded(int wday);
}

Calendar Management

Matcher Framework

Advanced pattern matching system for selecting jobs and triggers based on various criteria, enabling powerful bulk operations and complex filtering.

interface Matcher<T extends Key<T>> {
    boolean isMatch(T key);
}

class GroupMatcher<T extends Key<T>> implements Matcher<T> {
    static <T extends Key<T>> GroupMatcher<T> groupEquals(String group);
    static <T extends Key<T>> GroupMatcher<T> groupStartsWith(String groupPrefix);
    static <T extends Key<T>> GroupMatcher<T> groupEndsWith(String groupSuffix);
    static <T extends Key<T>> GroupMatcher<T> groupContains(String groupContains);
    static GroupMatcher<JobKey> jobGroupEquals(String group);
    static GroupMatcher<TriggerKey> triggerGroupEquals(String group);
}

class AndMatcher<T extends Key<T>> implements Matcher<T> {
    static <T extends Key<T>> AndMatcher<T> and(Matcher<T>... matchers);
}

class OrMatcher<T extends Key<T>> implements Matcher<T> {
    static <T extends Key<T>> OrMatcher<T> or(Matcher<T>... matchers);
}

Matcher Framework

Persistence and Storage

Comprehensive data persistence system supporting both in-memory and database storage with connection pooling, clustering, and database-specific optimizations.

interface JobStore {
    void initialize(ClassLoadHelper loadHelper, SchedulerSignaler signaler) throws SchedulerConfigException;
    void storeJob(JobDetail newJob, boolean replaceExisting) throws SchedulerException;
    void storeTrigger(OperableTrigger newTrigger, boolean replaceExisting) throws SchedulerException;
    JobDetail retrieveJob(JobKey jobKey) throws SchedulerException;
    OperableTrigger retrieveTrigger(TriggerKey triggerKey) throws SchedulerException;
    boolean supportsPersistence();
    boolean isClustered();
}

class JobStoreTX extends JobStoreSupport {
    // JDBC job store with transaction management
}

class RAMJobStore implements JobStore {
    // In-memory job store - volatile storage
}

interface PoolingConnectionProvider extends ConnectionProvider {
    int getPoolSize();
    int getMaxPoolSize();
    int getConnectionsInUse();
}

Persistence and Storage

Enterprise Features

Enterprise-grade capabilities including JTA transaction support, clustering, JMX monitoring, servlet integration, and specialized job implementations.

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface ExecuteInJTATransaction {
}

class QuartzInitializerServlet extends HttpServlet {
    String SHUTDOWN_ON_UNLOAD = "shutdown-on-unload";
    String START_SCHEDULER_ON_LOAD = "start-scheduler-on-load";
    void init(ServletConfig cfg) throws ServletException;
    void destroy();
}

interface SchedulerPlugin {
    void initialize(String name, Scheduler scheduler) throws SchedulerConfigException;
    void start();
    void shutdown();
}

class SendMailJob implements Job {
    String PROP_SMTP_HOST = "smtp_host";
    String PROP_RECIPIENT = "recipient";
    String PROP_SENDER = "sender";
    String PROP_SUBJECT = "subject";
    String PROP_MESSAGE = "message";
}

Enterprise Features

Types and Annotations

Key Types

class JobKey extends Key<JobKey> {
    JobKey(String name);
    JobKey(String name, String group);
    static JobKey jobKey(String name);
    static JobKey jobKey(String name, String group);
}

class TriggerKey extends Key<TriggerKey> {
    TriggerKey(String name);
    TriggerKey(String name, String group);
    static TriggerKey triggerKey(String name);
    static TriggerKey triggerKey(String name, String group);
}

class JobDataMap extends StringKeyDirtyFlagMap {
    JobDataMap();
    JobDataMap(Map<?, ?> map);
}

Behavioral Annotations

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface DisallowConcurrentExecution {
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface PersistJobDataAfterExecution {
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface ExecuteInJTATransaction {
}

Enums and Constants

enum TriggerState {
    NONE, NORMAL, PAUSED, COMPLETE, ERROR, BLOCKED
}

enum CompletedExecutionInstruction {
    NOOP, RE_EXECUTE_JOB, SET_TRIGGER_COMPLETE, DELETE_TRIGGER,
    SET_ALL_JOB_TRIGGERS_COMPLETE, SET_TRIGGER_ERROR, SET_ALL_JOB_TRIGGERS_ERROR
}

interface Scheduler {
    String DEFAULT_GROUP = "DEFAULT";
    String DEFAULT_RECOVERY_GROUP = "RECOVERING_JOBS";
    String DEFAULT_FAIL_OVER_GROUP = "FAILED_OVER_JOBS";
    int DEFAULT_PRIORITY = 5;
    int MISFIRE_INSTRUCTION_SMART_POLICY = 0;
    int MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY = -1;
}