org.opensingular.app.commons.mail.schedule

Class SingularSchedulerBean

java.lang.Object

org.opensingular.schedule.quartz.SingularSchedulerAccessor

org.opensingular.app.commons.mail.schedule.SingularSchedulerBean

All Implemented Interfaces:

org.opensingular.lib.commons.util.Loggable, org.opensingular.schedule.quartz.SingularQuartzSchedulerAcessor, org.springframework.beans.factory.Aware, org.springframework.beans.factory.BeanNameAware, org.springframework.beans.factory.DisposableBean, org.springframework.beans.factory.FactoryBean<org.quartz.Scheduler>, org.springframework.beans.factory.InitializingBean, org.springframework.context.ApplicationContextAware, org.springframework.context.Lifecycle, org.springframework.context.Phased, org.springframework.context.SmartLifecycle

public class SingularSchedulerBean
extends org.opensingular.schedule.quartz.SingularSchedulerAccessor
implements org.springframework.beans.factory.FactoryBean<org.quartz.Scheduler>, org.springframework.beans.factory.BeanNameAware, org.springframework.context.ApplicationContextAware, org.springframework.beans.factory.InitializingBean, org.springframework.beans.factory.DisposableBean, org.springframework.context.SmartLifecycle, org.opensingular.lib.commons.util.Loggable

Field Summary

Fields

Modifier and Type	Field and Description
static int	DEFAULT_THREAD_COUNT
static String	PROP_THREAD_COUNT

Fields inherited from class org.opensingular.schedule.quartz.SingularSchedulerAccessor

logger, SINGULAR_JOB_DETAIL_KEY

Fields inherited from interface org.opensingular.schedule.quartz.SingularQuartzSchedulerAcessor

SINGULAR_DEFAULT_THREAD_COUNT, SINGULAR_PROP_THREAD_COUNT

Constructor Summary

Constructors

Constructor and Description
SingularSchedulerBean(DataSource dataSource)

Method Summary

Modifier and Type	Method and Description
void	addJob(org.quartz.JobDetail jobDetail)
void	addTrigger(org.quartz.Trigger trigger) Add trigger and the trigger's job detail.
void	addTrigger(org.quartz.Trigger trigger, org.quartz.JobDetail jobDetail)
void	afterPropertiesSet()
protected org.quartz.Scheduler	createScheduler(org.quartz.SchedulerFactory schedulerFactory, String schedulerName) Create the Scheduler instance for the given factory and scheduler name.
boolean	deleteJob(org.quartz.JobKey jobKey)
void	destroy() Shut down the Quartz scheduler on bean factory shutdown, stopping all scheduled jobs.
Set<org.quartz.JobKey>	getAllJobKeys()
static DataSource	getConfigTimeDataSource() Return the DataSource for the currently configured Quartz Scheduler, to be used by SingularLocalDataSourceJobStore.
static DataSource	getConfigTimeNonTransactionalDataSource() Return the non-transactional DataSource for the currently configured Quartz Scheduler, to be used by SingularLocalDataSourceJobStore.
static Executor	getConfigTimeTaskExecutor() Return the TaskExecutor for the currently configured Quartz Scheduler, to be used by LocalTaskExecutorThreadPool.
org.quartz.Scheduler	getObject()
Class<?>	getObjectType()
int	getPhase()
org.quartz.Scheduler	getScheduler()
void	initialize()
boolean	isAutoStartup()
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	setConfigLocation(ResourceBundle configLocation)
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(org.quartz.spi.JobFactory jobFactory) Set the Quartz JobFactory to use for this Scheduler.
void	setNonTransactionalDataSource(DataSource nonTransactionalDataSource) Set the DataSource to be used by the Scheduler 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	setSchedulerFactoryClass(Class<? extends org.quartz.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 the Spring TaskExecutor to use as Quartz backend.
void	setWaitForJobsToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown) Set whether to wait for running jobs to complete on shutdown.
void	start()
void	start(int startupDelay)
protected void	startScheduler(org.quartz.Scheduler scheduler, int startupDelay) Start the Quartz Scheduler, respecting the "startupDelay" setting.
void	stop()
void	stop(Runnable callback)
void	triggerJob(org.quartz.JobKey jobKey) Trigger the identified JobDetail (execute it now).

Methods inherited from class org.opensingular.schedule.quartz.SingularSchedulerAccessor

addJobToScheduler, addTriggerToScheduler, registerJobsAndTriggers, registerListeners, setCalendars, setGlobalJobListeners, setGlobalTriggerListeners, setJobDetails, setJobSchedulingDataLocation, setJobSchedulingDataLocations, setOverwriteExistingJobs, setSchedulerListeners, setTriggers

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.opensingular.lib.commons.util.Loggable

getLogger

Field Detail

PROP_THREAD_COUNT

public static final String PROP_THREAD_COUNT

See Also:

Constant Field Values

DEFAULT_THREAD_COUNT

public static final int DEFAULT_THREAD_COUNT

See Also:

Constant Field Values

Constructor Detail

SingularSchedulerBean

public SingularSchedulerBean(DataSource dataSource)

Method Detail

getConfigTimeTaskExecutor

public static Executor getConfigTimeTaskExecutor()

Return the TaskExecutor 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.

See Also:

setTaskExecutor(java.util.concurrent.Executor), LocalTaskExecutorThreadPool

getConfigTimeDataSource

public static DataSource getConfigTimeDataSource()

Return the DataSource for the currently configured Quartz Scheduler, to be used by SingularLocalDataSourceJobStore.

This instance will be set before initialization of the corresponding Scheduler, and reset immediately afterwards. It is thus only available during configuration.

See Also:

setDataSource(javax.sql.DataSource), SingularLocalDataSourceJobStore

getConfigTimeNonTransactionalDataSource

public static DataSource getConfigTimeNonTransactionalDataSource()

Return the non-transactional DataSource for the currently configured Quartz Scheduler, to be used by SingularLocalDataSourceJobStore.

This instance will be set before initialization of the corresponding Scheduler, and reset immediately afterwards. It is thus only available during configuration.

See Also:

setNonTransactionalDataSource(javax.sql.DataSource), SingularLocalDataSourceJobStore

setSchedulerFactoryClass

public void setSchedulerFactoryClass(Class<? extends org.quartz.SchedulerFactory> 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 the "configLocation" or "quartzProperties" bean property on this FactoryBean.

See Also:

StdSchedulerFactory, setConfigLocation(java.util.ResourceBundle), setQuartzProperties(java.util.Properties)

setSchedulerName

public void setSchedulerName(String schedulerName)

Set the name of the Scheduler to create via the SchedulerFactory.

If not specified, the bean name will be used as default scheduler name.

Specified by:

setSchedulerName in interface org.opensingular.schedule.quartz.SingularQuartzSchedulerAcessor

See Also:

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

setConfigLocation

public void setConfigLocation(ResourceBundle configLocation)

Specified by:

setConfigLocation in interface org.opensingular.schedule.quartz.SingularQuartzSchedulerAcessor

setConfigLocation

public 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".

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(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.

Specified by:

setQuartzProperties in interface org.opensingular.schedule.quartz.SingularQuartzSchedulerAcessor

See Also:

setConfigLocation(java.util.ResourceBundle)

setTaskExecutor

public void setTaskExecutor(Executor taskExecutor)

Set the Spring TaskExecutor to use as Quartz backend. Exposed as thread pool through the Quartz SPI.

Can be used to assign a JDK 1.5 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.

See Also:

setQuartzProperties(java.util.Properties), LocalTaskExecutorThreadPool, org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor, org.springframework.scheduling.commonj.WorkManagerTaskExecutor

setDataSource

public void setDataSource(DataSource dataSource)

Set the default 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.

See Also:

setNonTransactionalDataSource(javax.sql.DataSource), setQuartzProperties(java.util.Properties), SingularLocalDataSourceJobStore

setNonTransactionalDataSource

public void setNonTransactionalDataSource(DataSource nonTransactionalDataSource)

Set the DataSource to be used by the Scheduler 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.

See Also:

setDataSource(javax.sql.DataSource), SingularLocalDataSourceJobStore

setSchedulerContextAsMap

public void setSchedulerContextAsMap(Map<String,?> 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:

JobDetailFactoryBean.setJobDataAsMap(java.util.Map<java.lang.String, ?>)

setApplicationContextSchedulerContextKey

public void setApplicationContextSchedulerContextKey(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 responsible for the lifecycle of its Jobs.

See Also:

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

setJobFactory

public void setJobFactory(org.quartz.spi.JobFactory jobFactory)

Set the Quartz 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.

Specified by:

setJobFactory in interface org.opensingular.schedule.quartz.SingularQuartzSchedulerAcessor

See Also:

AdaptableJobFactory, SpringBeanJobFactory

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.

setPhase

public void setPhase(int phase)

Specify the phase in which this scheduler should be started and stopped. The startup order proceeds from lowest to highest, and the shutdown order is the reverse of that. By default this value is Integer.MAX_VALUE meaning that this scheduler starts as late as possible and stops as soon as possible.

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.

setExposeSchedulerInRepository

public void setExposeSchedulerInRepository(boolean exposeSchedulerInRepository)

Set whether to expose the Spring-managed 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.

Specified by:

setExposeSchedulerInRepository in interface org.opensingular.schedule.quartz.SingularQuartzSchedulerAcessor

setWaitForJobsToCompleteOnShutdown

public void setWaitForJobsToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown)

Set whether to wait for running jobs to complete on shutdown.

Default is "false". Switch this to "true" if you prefer fully completed jobs at the expense of a longer shutdown phase.

Specified by:

setWaitForJobsToCompleteOnShutdown in interface org.opensingular.schedule.quartz.SingularQuartzSchedulerAcessor

See Also:

Scheduler.shutdown(boolean)

initialize

public void initialize()
                throws org.opensingular.lib.commons.base.SingularException

Specified by:

initialize in interface org.opensingular.schedule.quartz.SingularQuartzSchedulerAcessor

Throws:

org.opensingular.lib.commons.base.SingularException

setApplicationContext

public void setApplicationContext(org.springframework.context.ApplicationContext applicationContext)

Specified by:

setApplicationContext in interface org.springframework.context.ApplicationContextAware

afterPropertiesSet

public void afterPropertiesSet()
                        throws Exception

Specified by:

afterPropertiesSet in interface org.springframework.beans.factory.InitializingBean

Throws:

Exception

createScheduler

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

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

The default implementation invokes SchedulerFactory's getScheduler method. 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()

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

getScheduler

public org.quartz.Scheduler getScheduler()

Specified by:

getScheduler in interface org.opensingular.schedule.quartz.SingularQuartzSchedulerAcessor

Specified by:

getScheduler in class org.opensingular.schedule.quartz.SingularSchedulerAccessor

start

public void start()
           throws org.springframework.scheduling.SchedulingException

Specified by:

start in interface org.opensingular.schedule.quartz.SingularQuartzSchedulerAcessor

Specified by:

start in interface org.springframework.context.Lifecycle

Throws:

org.springframework.scheduling.SchedulingException

start

public void start(int startupDelay)
           throws org.quartz.SchedulerException

Specified by:

start in interface org.opensingular.schedule.quartz.SingularQuartzSchedulerAcessor

Throws:

org.quartz.SchedulerException

stop

public void stop()
          throws org.springframework.scheduling.SchedulingException

Specified by:

stop in interface org.opensingular.schedule.quartz.SingularQuartzSchedulerAcessor

Specified by:

stop in interface org.springframework.context.Lifecycle

Throws:

org.springframework.scheduling.SchedulingException

isAutoStartup

public boolean isAutoStartup()

Specified by:

isAutoStartup in interface org.springframework.context.SmartLifecycle

stop

public void stop(Runnable callback)
          throws org.springframework.scheduling.SchedulingException

Specified by:

stop in interface org.opensingular.schedule.quartz.SingularQuartzSchedulerAcessor

Specified by:

stop in interface org.springframework.context.SmartLifecycle

Throws:

org.springframework.scheduling.SchedulingException

isRunning

public boolean isRunning()
                  throws org.springframework.scheduling.SchedulingException

Specified by:

isRunning in interface org.opensingular.schedule.quartz.SingularQuartzSchedulerAcessor

Specified by:

isRunning in interface org.springframework.context.Lifecycle

Throws:

org.springframework.scheduling.SchedulingException

destroy

public void destroy()
             throws org.quartz.SchedulerException

Shut down the Quartz scheduler on bean factory shutdown, stopping all scheduled jobs.

Specified by:

destroy in interface org.opensingular.schedule.quartz.SingularQuartzSchedulerAcessor

Specified by:

destroy in interface org.springframework.beans.factory.DisposableBean

Throws:

org.quartz.SchedulerException

setBeanName

public void setBeanName(String name)

Specified by:

setBeanName in interface org.springframework.beans.factory.BeanNameAware

getObject

public org.quartz.Scheduler getObject()
                               throws Exception

Specified by:

getObject in interface org.springframework.beans.factory.FactoryBean<org.quartz.Scheduler>

Throws:

Exception

getObjectType

public Class<?> getObjectType()

Specified by:

getObjectType in interface org.springframework.beans.factory.FactoryBean<org.quartz.Scheduler>

isSingleton

public boolean isSingleton()

Specified by:

isSingleton in interface org.springframework.beans.factory.FactoryBean<org.quartz.Scheduler>

getPhase

public int getPhase()

Specified by:

getPhase in interface org.springframework.context.Phased

addJob

public void addJob(org.quartz.JobDetail jobDetail)
            throws org.quartz.SchedulerException

Specified by:

addJob in interface org.opensingular.schedule.quartz.SingularQuartzSchedulerAcessor

Throws:

org.quartz.SchedulerException

addTrigger

public void addTrigger(org.quartz.Trigger trigger,
                       org.quartz.JobDetail jobDetail)
                throws org.quartz.SchedulerException

Specified by:

addTrigger in interface org.opensingular.schedule.quartz.SingularQuartzSchedulerAcessor

Throws:

org.quartz.SchedulerException

addTrigger

public void addTrigger(org.quartz.Trigger trigger)
                throws org.quartz.SchedulerException

Add trigger and the trigger's job detail.

Specified by:

addTrigger in interface org.opensingular.schedule.quartz.SingularQuartzSchedulerAcessor

Parameters:

trigger - the trigger.

Throws:

org.quartz.SchedulerException - if could not start Quartz Scheduler.

triggerJob

public void triggerJob(org.quartz.JobKey jobKey)
                throws org.quartz.SchedulerException

Trigger the identified JobDetail (execute it now).

Specified by:

triggerJob in interface org.opensingular.schedule.quartz.SingularQuartzSchedulerAcessor

Parameters:

jobKey -

Throws:

org.quartz.SchedulerException

getAllJobKeys

public Set<org.quartz.JobKey> getAllJobKeys()
                                     throws org.quartz.SchedulerException

Specified by:

getAllJobKeys in interface org.opensingular.schedule.quartz.SingularQuartzSchedulerAcessor

Overrides:

getAllJobKeys in class org.opensingular.schedule.quartz.SingularSchedulerAccessor

Throws:

org.quartz.SchedulerException

deleteJob

public boolean deleteJob(org.quartz.JobKey jobKey)
                  throws org.quartz.SchedulerException

Specified by:

deleteJob in interface org.opensingular.schedule.quartz.SingularQuartzSchedulerAcessor

Throws:

org.quartz.SchedulerException