public class SchedulerFactoryBean extends SchedulerAccessor implements org.springframework.beans.factory.FactoryBean<Scheduler>, org.springframework.beans.factory.BeanNameAware, org.springframework.context.ApplicationContextAware, org.springframework.beans.factory.InitializingBean, org.springframework.beans.factory.DisposableBean, org.springframework.context.SmartLifecycle
FactoryBean
that creates and configures a Quartz Scheduler
,
manages its lifecycle as part of the Spring application context, and exposes the
Scheduler as bean reference for dependency injection.
Allows registration of JobDetails, Calendars and Triggers, automatically starting the scheduler on initialization and shutting it down on destruction. In scenarios that just require static registration of jobs at startup, there is no need to access the Scheduler instance itself in application code.
For dynamic registration of jobs at runtime, use a bean reference to
this SchedulerFactoryBean to get direct access to the Quartz Scheduler
(org.quartz.Scheduler
). This allows you to create new jobs
and triggers, and also to control and monitor the entire Scheduler.
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.
When using persistent jobs, it is strongly recommended to perform all
operations on the Scheduler within Spring-managed (or plain JTA) transactions.
Else, database locking will not properly work and might even break.
(See setDataSource
javadoc for details.)
The preferred way to achieve transactional execution is to demarcate declarative transactions at the business facade level, which will automatically apply to Scheduler operations performed within those scopes. Alternatively, you may add transactional advice for the Scheduler itself.
Compatible with Quartz 2.1.4 and higher, as of Spring 4.1.
setDataSource(javax.sql.DataSource)
,
Scheduler
,
SchedulerFactory
,
StdSchedulerFactory
,
org.springframework.transaction.interceptor.TransactionProxyFactoryBean
Modifier and Type | Field and Description |
---|---|
static int |
DEFAULT_THREAD_COUNT
The default thread count.
|
static String |
PROP_THREAD_COUNT
The thread count property.
|
logger, resourceLoader
Constructor and Description |
---|
SchedulerFactoryBean() |
Modifier and Type | Method and Description |
---|---|
void |
afterPropertiesSet() |
protected Scheduler |
createScheduler(SchedulerFactory schedulerFactory,
String schedulerName)
Create the Scheduler instance for the given factory and scheduler name.
|
void |
destroy()
Shut down the Quartz scheduler on bean factory shutdown,
stopping all scheduled jobs.
|
static DataSource |
getConfigTimeDataSource()
Return the
DataSource for the currently configured Quartz Scheduler,
to be used by LocalDataSourceJobStore . |
static DataSource |
getConfigTimeNonTransactionalDataSource()
Return the non-transactional
DataSource for the currently configured
Quartz Scheduler, to be used by LocalDataSourceJobStore . |
static org.springframework.core.io.ResourceLoader |
getConfigTimeResourceLoader()
Return the
ResourceLoader for the currently configured Quartz Scheduler,
to be used by ResourceLoaderClassLoadHelper . |
static Executor |
getConfigTimeTaskExecutor()
Return the
Executor for the currently configured Quartz Scheduler,
to be used by LocalTaskExecutorThreadPool . |
Scheduler |
getObject() |
Class<? extends Scheduler> |
getObjectType() |
int |
getPhase()
Return the phase in which this scheduler will be started and stopped.
|
Scheduler |
getScheduler()
Template method that determines the Scheduler to operate on.
|
boolean |
isAutoStartup()
Return whether this scheduler is configured for auto-startup.
|
boolean |
isRunning() |
boolean |
isSingleton() |
void |
setApplicationContext(org.springframework.context.ApplicationContext applicationContext) |
void |
setApplicationContextSchedulerContextKey(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 |
setBeanName(String name) |
void |
setConfigLocation(org.springframework.core.io.Resource configLocation)
Set the location of the Quartz properties config file, for example
as classpath resource "classpath:quartz.properties".
|
void |
setDataSource(DataSource dataSource)
Set the default
DataSource to be used by the Scheduler. |
void |
setExposeSchedulerInRepository(boolean exposeSchedulerInRepository)
Set whether to expose the Spring-managed
Scheduler instance in the
Quartz SchedulerRepository . |
void |
setJobFactory(JobFactory jobFactory)
Set the Quartz
JobFactory to use for this Scheduler. |
void |
setNonTransactionalDataSource(DataSource nonTransactionalDataSource)
Set the
DataSource to be used for non-transactional access. |
void |
setPhase(int phase)
Specify the phase in which this scheduler should be started and stopped.
|
void |
setQuartzProperties(Properties quartzProperties)
Set Quartz properties, like "org.quartz.threadPool.class".
|
void |
setSchedulerContextAsMap(Map<String,?> schedulerContextAsMap)
Register objects in the Scheduler context via a given Map.
|
void |
setSchedulerFactory(SchedulerFactory schedulerFactory)
Set an external Quartz
SchedulerFactory instance to use. |
void |
setSchedulerFactoryClass(Class<? extends SchedulerFactory> schedulerFactoryClass)
Set the Quartz
SchedulerFactory implementation to use. |
void |
setSchedulerName(String schedulerName)
Set the name of the Scheduler to create via the SchedulerFactory.
|
void |
setStartupDelay(int startupDelay)
Set the number of seconds to wait after initialization before
starting the scheduler asynchronously.
|
void |
setTaskExecutor(Executor taskExecutor)
Set a Spring-managed
Executor to use as Quartz backend. |
void |
setWaitForJobsToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown)
Set whether to wait for running jobs to complete on shutdown.
|
void |
start() |
protected void |
startScheduler(Scheduler scheduler,
int startupDelay)
Start the Quartz Scheduler, respecting the "startupDelay" setting.
|
void |
stop() |
void |
stop(Runnable callback) |
registerJobsAndTriggers, registerListeners, setCalendars, setGlobalJobListeners, setGlobalTriggerListeners, setJobDetails, setJobSchedulingDataLocation, setJobSchedulingDataLocations, setOverwriteExistingJobs, setResourceLoader, setSchedulerListeners, setTransactionManager, setTriggers
public static final String PROP_THREAD_COUNT
public static final int DEFAULT_THREAD_COUNT
@Nullable public static org.springframework.core.io.ResourceLoader getConfigTimeResourceLoader()
ResourceLoader
for the currently configured Quartz Scheduler,
to be used by ResourceLoaderClassLoadHelper
.
This instance will be set before initialization of the corresponding Scheduler, and reset immediately afterwards. It is thus only available during configuration.
@Nullable public static Executor getConfigTimeTaskExecutor()
Executor
for the currently configured Quartz Scheduler,
to be used by LocalTaskExecutorThreadPool
.
This instance will be set before initialization of the corresponding Scheduler, and reset immediately afterwards. It is thus only available during configuration.
setTaskExecutor(java.util.concurrent.Executor)
,
LocalTaskExecutorThreadPool
@Nullable public static DataSource getConfigTimeDataSource()
DataSource
for the currently configured Quartz Scheduler,
to be used by LocalDataSourceJobStore
.
This instance will be set before initialization of the corresponding Scheduler, and reset immediately afterwards. It is thus only available during configuration.
setDataSource(javax.sql.DataSource)
,
LocalDataSourceJobStore
@Nullable public static DataSource getConfigTimeNonTransactionalDataSource()
DataSource
for the currently configured
Quartz Scheduler, to be used by LocalDataSourceJobStore
.
This instance will be set before initialization of the corresponding Scheduler, and reset immediately afterwards. It is thus only available during configuration.
setNonTransactionalDataSource(javax.sql.DataSource)
,
LocalDataSourceJobStore
public void setSchedulerFactory(SchedulerFactory schedulerFactory)
SchedulerFactory
instance to use.
Default is an internal StdSchedulerFactory
instance. If this method is
called, it overrides any class specified through setSchedulerFactoryClass(java.lang.Class<? extends org.quartz.SchedulerFactory>)
as well as any settings specified through setConfigLocation(org.springframework.core.io.Resource)
,
setQuartzProperties(java.util.Properties)
, setTaskExecutor(java.util.concurrent.Executor)
or setDataSource(javax.sql.DataSource)
.
NOTE: With an externally provided SchedulerFactory
instance,
local settings such as setConfigLocation(org.springframework.core.io.Resource)
or setQuartzProperties(java.util.Properties)
will be ignored here in SchedulerFactoryBean
, expecting the external
SchedulerFactory
instance to get initialized on its own.
setSchedulerFactoryClass(java.lang.Class<? extends org.quartz.SchedulerFactory>)
public void setSchedulerFactoryClass(Class<? extends SchedulerFactory> schedulerFactoryClass)
SchedulerFactory
implementation to use.
Default is the StdSchedulerFactory
class, reading in the standard
quartz.properties
from quartz.jar
. For applying custom Quartz
properties, specify "configLocation"
and/or
"quartzProperties"
etc on this local
SchedulerFactoryBean
instance.
public void setSchedulerName(String schedulerName)
If not specified, the bean name will be used as default scheduler name.
public void setConfigLocation(org.springframework.core.io.Resource configLocation)
Note: Can be omitted when all necessary properties are specified locally via this bean, or when relying on Quartz' default configuration.
public void setQuartzProperties(Properties quartzProperties)
Can be used to override values in a Quartz properties config file, or to specify all necessary properties locally.
public void setTaskExecutor(Executor taskExecutor)
Executor
to use as Quartz backend.
Exposed as thread pool through the Quartz SPI.
Can be used to assign a local JDK ThreadPoolExecutor or a CommonJ WorkManager as Quartz backend, to avoid Quartz's manual thread creation.
By default, a Quartz SimpleThreadPool will be used, configured through the corresponding Quartz properties.
setQuartzProperties(java.util.Properties)
,
LocalTaskExecutorThreadPool
,
org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor
,
org.springframework.scheduling.concurrent.DefaultManagedTaskExecutor
public void setDataSource(DataSource dataSource)
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.
A Spring-specific subclass of Quartz' JobStoreCMT will be used. It is therefore strongly recommended to perform all operations on the Scheduler within Spring-managed (or plain JTA) transactions. Else, database locking will not properly work and might even break (e.g. if trying to obtain a lock on Oracle without a transaction).
Supports both transactional and non-transactional DataSource access. With a non-XA DataSource and local Spring transactions, a single DataSource argument is sufficient. In case of an XA DataSource and global JTA transactions, SchedulerFactoryBean's "nonTransactionalDataSource" property should be set, passing in a non-XA DataSource that will not participate in global transactions.
public void setNonTransactionalDataSource(DataSource nonTransactionalDataSource)
DataSource
to be used for non-transactional access.
This is only necessary if the default DataSource is an XA DataSource that will always participate in transactions: A non-XA version of that DataSource should be specified as "nonTransactionalDataSource" in such a scenario.
This is not relevant with a local DataSource instance and Spring transactions. Specifying a single default DataSource as "dataSource" is sufficient there.
setDataSource(javax.sql.DataSource)
,
LocalDataSourceJobStore
public void setSchedulerContextAsMap(Map<String,?> schedulerContextAsMap)
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.
schedulerContextAsMap
- a Map with String keys and any objects as
values (for example Spring-managed beans)JobDetailFactoryBean.setJobDataAsMap(java.util.Map<java.lang.String, ?>)
public void setApplicationContextSchedulerContextKey(String applicationContextSchedulerContextKey)
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 responsible for the lifecycle of its Jobs.
JobDetailFactoryBean.setApplicationContextJobDataKey(java.lang.String)
,
ApplicationContext
public void setJobFactory(JobFactory jobFactory)
JobFactory
to use for this Scheduler.
Default is Spring's AdaptableJobFactory
, which supports
Runnable
objects as well as standard Quartz
Job
instances. Note that this default only applies
to a local Scheduler, not to a RemoteScheduler (where setting
a custom JobFactory is not supported by Quartz).
Specify an instance of Spring's SpringBeanJobFactory
here
(typically as an inner bean definition) to automatically populate a job's
bean properties from the specified job data map and scheduler context.
AdaptableJobFactory
,
SpringBeanJobFactory
public void setAutoStartup(boolean autoStartup)
Default is "true"; set this to "false" to allow for manual startup.
public boolean isAutoStartup()
isAutoStartup
in interface org.springframework.context.SmartLifecycle
public void setPhase(int phase)
Integer.MAX_VALUE
meaning that this scheduler starts as late as possible and stops as soon
as possible.public int getPhase()
getPhase
in interface org.springframework.context.Phased
public void setStartupDelay(int startupDelay)
Setting this to 10 or 20 seconds makes sense if no jobs should be run before the entire application has started up.
public void setExposeSchedulerInRepository(boolean exposeSchedulerInRepository)
Scheduler
instance in the
Quartz SchedulerRepository
. Default is "false", since the Spring-managed
Scheduler is usually exclusively intended for access within the Spring context.
Switch this flag to "true" in order to expose the Scheduler globally. This is not recommended unless you have an existing Spring application that relies on this behavior. Note that such global exposure was the accidental default in earlier Spring versions; this has been fixed as of Spring 2.5.6.
public void setWaitForJobsToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown)
Default is "false". Switch this to "true" if you prefer fully completed jobs at the expense of a longer shutdown phase.
Scheduler.shutdown(boolean)
public void setBeanName(String name)
setBeanName
in interface org.springframework.beans.factory.BeanNameAware
public void setApplicationContext(org.springframework.context.ApplicationContext applicationContext)
setApplicationContext
in interface org.springframework.context.ApplicationContextAware
public void afterPropertiesSet() throws Exception
afterPropertiesSet
in interface org.springframework.beans.factory.InitializingBean
Exception
protected Scheduler createScheduler(SchedulerFactory schedulerFactory, @Nullable String schedulerName) throws SchedulerException
afterPropertiesSet()
.
The default implementation invokes SchedulerFactory's getScheduler
method. Can be overridden for custom Scheduler creation.
schedulerFactory
- the factory to create the Scheduler withschedulerName
- the name of the scheduler to createSchedulerException
- if thrown by Quartz methodsafterPropertiesSet()
,
SchedulerFactory.getScheduler()
protected void startScheduler(Scheduler scheduler, int startupDelay) throws SchedulerException
scheduler
- the Scheduler to startstartupDelay
- the number of seconds to wait before starting
the Scheduler asynchronouslySchedulerException
public Scheduler getScheduler()
SchedulerAccessor
getScheduler
in class SchedulerAccessor
@Nullable public Scheduler getObject()
getObject
in interface org.springframework.beans.factory.FactoryBean<Scheduler>
public Class<? extends Scheduler> getObjectType()
getObjectType
in interface org.springframework.beans.factory.FactoryBean<Scheduler>
public boolean isSingleton()
isSingleton
in interface org.springframework.beans.factory.FactoryBean<Scheduler>
public void start() throws org.springframework.scheduling.SchedulingException
start
in interface org.springframework.context.Lifecycle
org.springframework.scheduling.SchedulingException
public void stop() throws org.springframework.scheduling.SchedulingException
stop
in interface org.springframework.context.Lifecycle
org.springframework.scheduling.SchedulingException
public void stop(Runnable callback) throws org.springframework.scheduling.SchedulingException
stop
in interface org.springframework.context.SmartLifecycle
org.springframework.scheduling.SchedulingException
public boolean isRunning() throws org.springframework.scheduling.SchedulingException
isRunning
in interface org.springframework.context.Lifecycle
org.springframework.scheduling.SchedulingException
public void destroy() throws SchedulerException
destroy
in interface org.springframework.beans.factory.DisposableBean
SchedulerException