org.springframework.scheduling.quartz
Class SchedulerFactoryBean

java.lang.Object
  org.springframework.scheduling.quartz.SchedulerFactoryBean

All Implemented Interfaces:

ApplicationContextAware, DisposableBean, FactoryBean, InitializingBean

public class SchedulerFactoryBean

extends java.lang.Object

implements FactoryBean, ApplicationContextAware, InitializingBean, DisposableBean

FactoryBean that sets up a Quartz Scheduler and exposes it for bean references.

Allows registration of JobDetails, Calendars and Triggers, automatically starting the scheduler on initialization and shutting it down on destruction. In typical scenarios, there is no need to access the Scheduler instance itself in application code.

Note that Quartz instantiates a new Job for each execution, in contrast to Timer which uses a TimerTask instance that is shared between repeated executions. Just JobDetail descriptors are shared.

Spring's Quartz support was developed against Quartz 1.3.

Since:

18.02.2004

Author:

Juergen Hoeller

See Also:

Scheduler, StdSchedulerFactory

Nested Class Summary

static class

SchedulerFactoryBean.DelayedSchedulerStartException Exception to be thrown if the Quartz scheduler cannot be started after the specified delay has passed.

Field Summary

static int	DEFAULT_THREAD_COUNT
protected org.apache.commons.logging.Log	logger
static java.lang.String	PROP_THREAD_COUNT

Constructor Summary

SchedulerFactoryBean()

Method Summary

void	afterPropertiesSet() Invoked by a BeanFactory after it has set all bean properties supplied (and satisfied BeanFactoryAware and ApplicationContextAware).
protected org.quartz.Scheduler	createScheduler(org.quartz.SchedulerFactory schedulerFactory, java.lang.String schedulerName) Create the Scheduler instance for the given factory and scheduler name.
void	destroy() This implementation shuts down the Quartz scheduler, stopping all scheduled jobs.
java.lang.Object	getObject() Return an instance (possibly shared or independent) of the object managed by this factory.
java.lang.Class	getObjectType() Return the type of object that this FactoryBean creates, or null if not known in advance.
boolean	isSingleton() Is the bean managed by this factory a singleton or a prototype?
void	setApplicationContext(ApplicationContext applicationContext) Set the ApplicationContext that this object runs in.
void	setApplicationContextSchedulerContextKey(java.lang.String applicationContextSchedulerContextKey) Set the key of an ApplicationContext reference to expose in the SchedulerContext, for example "applicationContext".
void	setAutoStartup(boolean autoStartup) Set whether to automatically start the scheduler after initialization.
void	setCalendars(java.util.Map calendars) Register a list of Quartz Calendar objects with the Scheduler that this FactoryBean creates, to be referenced by Triggers.
void	setConfigLocation(Resource configLocation) Set the location of the Quartz properties config file, for example as classpath resource "classpath:quartz.properties".
void	setDataSource(javax.sql.DataSource dataSource) Set the DataSource to be used by the Scheduler.
void	setJobDetails(org.quartz.JobDetail[] jobDetails) Register a list of JobDetail objects with the Scheduler that this FactoryBean creates, to be referenced by Triggers.
void	setJobSchedulingDataLocation(java.lang.String jobSchedulingDataLocation) Set the location of a Quartz job definition XML file that follows the "job_scheduling_data_1_0" DTD.
void	setJobSchedulingDataLocations(java.lang.String[] jobSchedulingDataLocations) Set the locations of Quartz job definition XML files that follow the "job_scheduling_data_1_0" DTD.
void	setOverwriteExistingJobs(boolean overwriteExistingJobs) Set whether any jobs defined on this SchedulerFactoryBean should overwrite existing job definitions.
void	setQuartzProperties(java.util.Properties quartzProperties) Set Quartz properties, like "org.quartz.threadPool.class".
void	setSchedulerContextAsMap(java.util.Map schedulerContextAsMap) Register objects in the Scheduler context via a given Map.
void	setSchedulerFactoryClass(java.lang.Class schedulerFactoryClass) Set the Quartz SchedulerFactory implementation to use.
void	setSchedulerName(java.lang.String schedulerName) Set the name of the Scheduler to fetch from the SchedulerFactory.
void	setStartupDelay(int startupDelay) Set the number of seconds to wait after initialization before starting the scheduler asynchronously.
void	setTransactionManager(PlatformTransactionManager transactionManager) Set the transaction manager to be used for registering jobs and triggers that are defined by this SchedulerFactoryBean.
void	setTriggers(org.quartz.Trigger[] triggers) Register a list of Trigger objects with the Scheduler that this FactoryBean creates.
void	setWaitForJobsToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown) Set whether to wait for running jobs to complete on shutdown.
protected void	startScheduler(org.quartz.Scheduler scheduler, int startupDelay) Start the Quartz Scheduler, respecting the "startupDelay" setting.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

PROP_THREAD_COUNT

public static final java.lang.String PROP_THREAD_COUNT

See Also:

Constant Field Values

DEFAULT_THREAD_COUNT

public static final int DEFAULT_THREAD_COUNT

See Also:

Constant Field Values

logger

protected final org.apache.commons.logging.Log logger

Constructor Detail

SchedulerFactoryBean

public SchedulerFactoryBean()

Method Detail

setSchedulerFactoryClass

public void setSchedulerFactoryClass(java.lang.Class schedulerFactoryClass)

Set the Quartz SchedulerFactory implementation to use.

Default is StdSchedulerFactory, reading in the standard quartz.properties from quartz.jar. To use custom Quartz properties, specify "configLocation" or "quartzProperties".

See Also:

StdSchedulerFactory, setConfigLocation(org.springframework.core.io.Resource), setQuartzProperties(java.util.Properties)

setSchedulerName

public void setSchedulerName(java.lang.String schedulerName)

Set the name of the Scheduler to fetch from the SchedulerFactory. If not specified, the default Scheduler will be used.

See Also:

SchedulerFactory.getScheduler(String), SchedulerFactory.getScheduler()

setConfigLocation

public void setConfigLocation(Resource configLocation)

Set the location of the Quartz properties config file, for example as classpath resource "classpath:quartz.properties".

Note: Can be omitted when all necessary properties are specified locally via this bean, or when relying on Quartz' default configuration.

See Also:

setQuartzProperties(java.util.Properties)

setQuartzProperties

public void setQuartzProperties(java.util.Properties quartzProperties)

Set Quartz properties, like "org.quartz.threadPool.class".

Can be used to override values in a Quartz properties config file, or to specify all necessary properties locally.

See Also:

setConfigLocation(org.springframework.core.io.Resource)

setDataSource

public void setDataSource(javax.sql.DataSource dataSource)

Set the DataSource to be used by the Scheduler. If set, this will override corresponding settings in Quartz properties.

Note: If this is set, the Quartz settings should not define a job store "dataSource" to avoid meaningless double configuration.

See Also:

setQuartzProperties(java.util.Properties), setTransactionManager(org.springframework.transaction.PlatformTransactionManager), LocalDataSourceJobStore

setTransactionManager

public void setTransactionManager(PlatformTransactionManager transactionManager)

Set the transaction manager to be used for registering jobs and triggers that are defined by this SchedulerFactoryBean. Default is none; setting this only makes sense when specifying a DataSource for the Scheduler.

See Also:

setDataSource(javax.sql.DataSource)

setSchedulerContextAsMap

public void setSchedulerContextAsMap(java.util.Map schedulerContextAsMap)

Register objects in the Scheduler context via a given Map. These objects will be available to any Job that runs in this Scheduler.

Note: When using persistent Jobs whose JobDetail will be kept in the database, do not put Spring-managed beans or an ApplicationContext reference into the JobDataMap but rather into the SchedulerContext.

Parameters:

schedulerContextAsMap - Map with String keys and any objects as values (for example Spring-managed beans)

See Also:

JobDetailBean.setJobDataAsMap(java.util.Map)

setApplicationContext

public void setApplicationContext(ApplicationContext applicationContext)

Description copied from interface: ApplicationContextAware

Set the ApplicationContext that this object runs in. Normally this call will be used to initialize the object.

Invoked after population of normal bean properties but before an init callback like InitializingBean's afterPropertiesSet or a custom init-method. Invoked after ResourceLoaderAware's setResourceLoader.

Specified by:

setApplicationContext in interface ApplicationContextAware

Parameters:

applicationContext - ApplicationContext object to be used by this object

See Also:

BeanInitializationException

setApplicationContextSchedulerContextKey

public void setApplicationContextSchedulerContextKey(java.lang.String applicationContextSchedulerContextKey)

Set the key of an ApplicationContext reference to expose in the SchedulerContext, for example "applicationContext". Default is none. Only applicable when running in a Spring ApplicationContext.

Note: When using persistent Jobs whose JobDetail will be kept in the database, do not put an ApplicationContext reference into the JobDataMap but rather into the SchedulerContext.

In case of a QuartzJobBean, the reference will be applied to the Job instance as bean property. An "applicationContext" attribute will correspond to a "setApplicationContext" method in that scenario.

Note that BeanFactory callback interfaces like ApplicationContextAware are not automatically applied to Quartz Job instances, because Quartz itself is reponsible for the lifecycle of its Jobs.

See Also:

JobDetailBean.setApplicationContextJobDataKey(java.lang.String), ApplicationContext

setOverwriteExistingJobs

public void setOverwriteExistingJobs(boolean overwriteExistingJobs)

Set whether any jobs defined on this SchedulerFactoryBean should overwrite existing job definitions. Default is "false", to not overwrite already registered jobs that have been read in from a persistent job store.

setJobSchedulingDataLocation

public void setJobSchedulingDataLocation(java.lang.String jobSchedulingDataLocation)

Set the location of a Quartz job definition XML file that follows the "job_scheduling_data_1_0" DTD. Can be specified to automatically register jobs that are defined in such a file, possibly in addition to jobs defined directly on this SchedulerFactoryBean.

See Also:

ResourceJobSchedulingDataProcessor, JobSchedulingDataProcessor

setJobSchedulingDataLocations

public void setJobSchedulingDataLocations(java.lang.String[] jobSchedulingDataLocations)

Set the locations of Quartz job definition XML files that follow the "job_scheduling_data_1_0" DTD. Can be specified to automatically register jobs that are defined in such files, possibly in addition to jobs defined directly on this SchedulerFactoryBean.

See Also:

ResourceJobSchedulingDataProcessor, JobSchedulingDataProcessor

setJobDetails

public void setJobDetails(org.quartz.JobDetail[] jobDetails)

Register a list of JobDetail objects with the Scheduler that this FactoryBean creates, to be referenced by Triggers.

This is not necessary when a Trigger determines the JobDetail itself: In this case, the JobDetail will be implicitly registered in combination with the Trigger.

See Also:

setTriggers(org.quartz.Trigger[]), JobDetail, JobDetailBean, JobDetailAwareTrigger, Trigger.setJobName(java.lang.String)

setCalendars

public void setCalendars(java.util.Map calendars)

Register a list of Quartz Calendar objects with the Scheduler that this FactoryBean creates, to be referenced by Triggers.

Parameters:

calendars - Map with calendar names as keys as Calendar objects as values

See Also:

Calendar, Trigger.setCalendarName(java.lang.String)

setTriggers

public void setTriggers(org.quartz.Trigger[] triggers)

Register a list of Trigger objects with the Scheduler that this FactoryBean creates.

If the Trigger determines the corresponding JobDetail itself, the job will be automatically registered with the Scheduler. Else, the respective JobDetail needs to be registered via the "jobDetails" property of this FactoryBean.

See Also:

setJobDetails(org.quartz.JobDetail[]), JobDetail, JobDetailAwareTrigger, CronTriggerBean, SimpleTriggerBean

setAutoStartup

public void setAutoStartup(boolean autoStartup)

Set whether to automatically start the scheduler after initialization. Default is true; set this to false to allow for manual startup.

setStartupDelay

public void setStartupDelay(int startupDelay)

Set the number of seconds to wait after initialization before starting the scheduler asynchronously. Default is 0, meaning immediate synchronous startup on initialization of this bean.

Setting this to 10 or 20 seconds makes sense if no jobs should be run before the entire application has started up.

setWaitForJobsToCompleteOnShutdown

public void setWaitForJobsToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown)

Set whether to wait for running jobs to complete on shutdown. Default is false.

See Also:

Scheduler.shutdown(boolean)

afterPropertiesSet

public void afterPropertiesSet()
                        throws java.lang.Exception

Description copied from interface: InitializingBean

Invoked by a BeanFactory after it has set all bean properties supplied (and satisfied BeanFactoryAware and ApplicationContextAware).

This method allows the bean instance to perform initialization only possible when all bean properties have been set and to throw an exception in the event of misconfiguration.

Specified by:

afterPropertiesSet in interface InitializingBean

Throws:

java.lang.Exception - in the event of misconfiguration (such as failure to set an essential property) or if initialization fails.

createScheduler

protected org.quartz.Scheduler createScheduler(org.quartz.SchedulerFactory schedulerFactory,
                                               java.lang.String schedulerName)
                                        throws org.quartz.SchedulerException

Create the Scheduler instance for the given factory and scheduler name. Called by afterPropertiesSet.

Default implementation invokes the corresponding getScheduler methods of SchedulerFactory. Can be overridden for custom Scheduler creation.

Parameters:

schedulerFactory - the factory to create the Scheduler with

schedulerName - the name of the scheduler to create

Returns:

the Scheduler instance

Throws:

org.quartz.SchedulerException - if thrown by Quartz methods

See Also:

afterPropertiesSet(), SchedulerFactory.getScheduler(), SchedulerFactory.getScheduler(String)

startScheduler

protected void startScheduler(org.quartz.Scheduler scheduler,
                              int startupDelay)
                       throws org.quartz.SchedulerException

Start the Quartz Scheduler, respecting the "startupDelay" setting.

Parameters:

scheduler - the Scheduler to start

startupDelay - the number of seconds to wait before starting the Scheduler asynchronously

Throws:

org.quartz.SchedulerException

getObject

public java.lang.Object getObject()

Description copied from interface: FactoryBean

Return an instance (possibly shared or independent) of the object managed by this factory. As with a BeanFactory, this allows support for both the Singleton and Prototype design pattern.

Specified by:

getObject in interface FactoryBean

Returns:

an instance of the bean (should never be null)

getObjectType

public java.lang.Class getObjectType()

Description copied from interface: FactoryBean

Return the type of object that this FactoryBean creates, or null if not known in advance. This allows to check for specific types of beans without instantiating objects, e.g. on autowiring.

For a singleton, this can simply return getObject().getClass(), or even null, as autowiring will always check the actual objects for singletons. For prototypes, returning a meaningful type here is highly advisable, as autowiring will simply ignore them else.

Specified by:

getObjectType in interface FactoryBean

Returns:

the type of object that this FactoryBean creates, or null

See Also:

ListableBeanFactory.getBeansOfType(java.lang.Class, boolean, boolean)

isSingleton

public boolean isSingleton()

Description copied from interface: FactoryBean

Is the bean managed by this factory a singleton or a prototype? That is, will getObject() always return the same object?

The singleton status of the FactoryBean itself will generally be provided by the owning BeanFactory.

Specified by:

isSingleton in interface FactoryBean

Returns:

if this bean is a singleton

destroy

public void destroy()
             throws org.quartz.SchedulerException

This implementation shuts down the Quartz scheduler, stopping all scheduled jobs.

Specified by:

destroy in interface DisposableBean

Throws:

org.quartz.SchedulerException