/*
* Copyright 2002-2024
the original au
thor or au
thors
.
*
* Licensed under
the Apache License,
Version 2
.0 (
the "License");
* you may
not use
this file except in compliance wi
th the License
.
* You may obtain a copy of
the License at
*
* https://www
.apache
.org/licenses/LICENSE-2
.0
*
* Unless required
by applicable law or agreed
to in writing, software
* d
istributed under
the License
is d
istributed on an "AS
IS" BAS
IS,
* WI
THOUT WARRANTIES OR CONDITIONS OF ANY KIND, ei
ther express or implied
.
* See
the License for
the specific
language governing perm
issions and
* limitations under
the License
.
*/
package org
.springframework
.scheduling
.quartz;
import
java.io
.IOException;
import
java.util
.Map;
import
java.util
.Properties;
import
java.util
.con
current.Execu
tor;
import
java.util
.con
current.TimeUnit;
import
javax
.sql
.DataSource;
import org
.quartz
.Scheduler;
import org
.quartz
.SchedulerException;
import org
.quartz
.SchedulerFac
tory;
import org
.quartz
.impl
.RemoteScheduler;
import org
.quartz
.impl
.SchedulerReposi
tory;
import org
.quartz
.impl
.StdSchedulerFac
tory;
import org
.quartz
.simpl
.Simple
ThreadPool;
import org
.quartz
.spi
.JobFac
tory;
import org
.springframework
.beans
.BeanUtils;
import org
.springframework
.beans
.fac
tory
.BeanNameAware;
import org
.springframework
.beans
.fac
tory
.D
isposableBean;
import org
.springframework
.beans
.fac
tory
.Fac
toryBean;
import org
.springframework
.beans
.fac
tory
.InitializingBean;
import org
.springframework
.context
.ApplicationContext;
import org
.springframework
.context
.ApplicationContextAware;
import org
.springframework
.context
.SmartLifecycle;
import org
.springframework
.core
.io
.Resource;
import org
.springframework
.core
.io
.ResourceLoader;
import org
.springframework
.core
.io
.support
.PropertiesLoaderUtils;
import org
.springframework
.lang
.Nullable;
import org
.springframework
.scheduling
.SchedulingException;
import org
.springframework
.util
.Assert;
import org
.springframework
.util
.CollectionUtils;
/**
* {@link Fac
toryBean}
that creates and configures a Quartz {@link org
.quartz
.Scheduler},
* manages its lifecycle as part of
the Spring application context, and exposes
the
* Scheduler as bean reference for dependency injection
.
*
* <p>Allows reg
istration of JobDetails, Calendars and Triggers, au
tomatically
* starting
the scheduler on initialization and shutting it down on destruction
.
* In scenarios
that just require static reg
istration of jobs at startup,
there
*
is no need
to access
the Scheduler instance itself in application code
.
*
* <p>For dynamic reg
istration of jobs at runtime, use a bean reference
to
*
this SchedulerFac
toryBean
to get direct access
to the Quartz Scheduler
* ({@code org
.quartz
.Scheduler})
. This allows you
to create new jobs
* and triggers, and also
to control and moni
tor
the entire Scheduler
.
*
* <p>
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 descrip
tors are shared
.
*
* <p>When using pers
istent jobs, it
is strongly recommended
to perform all
* operations on
the Scheduler wi
thin Spring-managed (or plain JTA) transactions
.
* Else, database locking will
not properly work and might even break
.
* (See {@link #
setDataSource
setDataSource}
javadoc for details
.)
*
* <p>
The preferred way
to achieve transactional execution
is to demarcate
* declarative transactions at
the business facade
level,
which will
* au
tomatically apply
to Scheduler operations performed wi
thin
those scopes
.
* Alternatively, you may add transactional advice for
the Scheduler itself
.
*
* <p>Compatible wi
th Quartz 2
.1
.4 and higher, as of Spring 4
.1
.
*
* @au
thor Juergen Hoeller
* @since 18
.02
.2004
* @see #
setDataSource
* @see org
.quartz
.Scheduler
* @see org
.quartz
.SchedulerFac
tory
* @see org
.quartz
.impl
.StdSchedulerFac
tory
* @see org
.springframework
.transaction
.intercep
tor
.TransactionProxyFac
toryBean
*/
public class SchedulerFac
toryBean extends SchedulerAccessor implements Fac
toryBean<Scheduler>,
BeanNameAware, ApplicationContextAware, InitializingBean, D
isposableBean, SmartLifecycle {
/**
*
The thread count property
.
*/
public static final String PROP_
THREAD_COUNT = "org
.quartz
.threadPool
.threadCount";
/**
*
The default thread count
.
*/
public static final int
DEFAULT_
THREAD_COUNT = 10;
private static final
ThreadLocal<ResourceLoader> configTimeResourceLoaderHolder = new
ThreadLocal<>();
private static final
ThreadLocal<Execu
tor> configTimeTaskExecu
torHolder = new
ThreadLocal<>();
private static final
ThreadLocal<DataSource> configTimeDataSourceHolder = new
ThreadLocal<>();
private static final
ThreadLocal<DataSource> configTimeNonTransactionalDataSourceHolder = new
ThreadLocal<>();
/**
* Return
the {@link ResourceLoader} for
the currently configured Quartz Scheduler,
*
to be used
by {@link ResourceLoaderClassLoadHelper}
.
* <p>
This instance will be
set before initialization of
the corresponding Scheduler,
* and re
set immediately afterwards
. It
is thus only available during configuration
.
* @see #
setApplicationContext
* @see ResourceLoaderClassLoadHelper
*/
@Nullable
public static ResourceLoader getConfigTimeResourceLoader() {
return configTimeResourceLoaderHolder
.get();
}
/**
* Return
the {@link Execu
tor} for
the currently configured Quartz Scheduler,
*
to be used
by {@link LocalTaskExecu
tor
ThreadPool}
.
* <p>
This instance will be
set before initialization of
the corresponding Scheduler,
* and re
set immediately afterwards
. It
is thus only available during configuration
.
* @since 2
.0
* @see #
setTaskExecu
tor
* @see LocalTaskExecu
tor
ThreadPool
*/
@Nullable
public static Execu
tor getConfigTimeTaskExecu
tor() {
return configTimeTaskExecu
torHolder
.get();
}
/**
* Return
the {@link DataSource} for
the currently configured Quartz Scheduler,
*
to be used
by {@link LocalDataSourceJobS
tore}
.
* <p>
This instance will be
set before initialization of
the corresponding Scheduler,
* and re
set immediately afterwards
. It
is thus only available during configuration
.
* @since 1
.1
* @see #
setDataSource
* @see LocalDataSourceJobS
tore
*/
@Nullable
public static DataSource getConfigTimeDataSource() {
return configTimeDataSourceHolder
.get();
}
/**
* Return
the non-transactional {@link DataSource} for
the currently configured
* Quartz Scheduler,
to be used
by {@link LocalDataSourceJobS
tore}
.
* <p>
This instance will be
set before initialization of
the corresponding Scheduler,
* and re
set immediately afterwards
. It
is thus only available during configuration
.
* @since 1
.1
* @see #
setNonTransactionalDataSource
* @see LocalDataSourceJobS
tore
*/
@Nullable
public static DataSource getConfigTimeNonTransactionalDataSource() {
return configTimeNonTransactionalDataSourceHolder
.get();
}
@Nullable
private SchedulerFac
tory schedulerFac
tory;
private Class<? extends SchedulerFac
tory> schedulerFac
toryClass = StdSchedulerFac
tory
.class;
@Nullable
private String schedulerName;
@Nullable
private Resource configLocation;
@Nullable
private Properties quartzProperties;
@Nullable
private Execu
tor taskExecu
tor;
@Nullable
private DataSource dataSource;
@Nullable
private DataSource nonTransactionalDataSource;
@Nullable
private Map<String, ?> schedulerContextMap;
@Nullable
private String applicationContextSchedulerContextKey;
@Nullable
private JobFac
tory jobFac
tory;
private boolean jobFac
tory
Set = false;
private boolean au
toStartup = true;
private int startupDelay = 0;
private int phase =
DEFAULT_PHASE;
private boolean exposeSchedulerInReposi
tory = false;
private boolean waitForJobs
ToCompleteOnShutdown = false;
@Nullable
private String beanName;
@Nullable
private ApplicationContext applicationContext;
@Nullable
private Scheduler scheduler;
/**
*
Set an external Quartz {@link SchedulerFac
tory} instance
to use
.
* <p>
Default is an internal {@link StdSchedulerFac
tory} instance
. If
this me
thod
is
* called, it overrides any class specified
through {@link #
setSchedulerFac
toryClass}
* as well as any
settings specified
through {@link #
setConfigLocation},
* {@link #
setQuartzProperties}, {@link #
setTaskExecu
tor} or {@link #
setDataSource}
.
* <p><b>
NOTE:</b> Wi
th an externally provided {@code SchedulerFac
tory} instance,
* local
settings such as {@link #
setConfigLocation} or {@link #
setQuartzProperties}
* will be ignored here in {@code SchedulerFac
toryBean}, expecting
the external
* {@code SchedulerFac
tory} instance
to get initialized on its own
.
* @since 4
.3
.1
5
* @see #
setSchedulerFac
toryClass
*/
public void
setSchedulerFac
tory(SchedulerFac
tory schedulerFac
tory) {
this.schedulerFac
tory = schedulerFac
tory;
}
/**
*
Set the Quartz {@link SchedulerFac
tory} implementation
to use
.
* <p>
Default is the {@link StdSchedulerFac
tory} class, reading in
the standard
* {@code quartz
.properties} from {@code quartz
.jar}
. For applying cus
tom Quartz
* properties, specify {@link #
setConfigLocation "configLocation"} and/or
* {@link #
setQuartzProperties "quartzProperties"} etc on
this local
* {@code SchedulerFac
toryBean} instance
.
* @see org
.quartz
.impl
.StdSchedulerFac
tory
* @see #
setConfigLocation
* @see #
setQuartzProperties
* @see #
setTaskExecu
tor
* @see #
setDataSource
*/
public void
setSchedulerFac
toryClass(Class<? extends SchedulerFac
tory> schedulerFac
toryClass) {
this.schedulerFac
toryClass = schedulerFac
toryClass;
}
/**
*
Set the name of
the Scheduler
to create via
the SchedulerFac
tory, as an
* alternative
to the {@code org
.quartz
.scheduler
.instanceName} property
.
* <p>If
not specified,
the name will be taken from Quartz properties
* ({@code org
.quartz
.scheduler
.instanceName}), or from
the declared
* {@code SchedulerFac
toryBean} bean name as a fallback
.
* @see #
setBeanName
* @see StdSchedulerFac
tory#PROP_SCHED_INSTANCE_NAME
* @see org
.quartz
.SchedulerFac
tory#getScheduler()
* @see org
.quartz
.SchedulerFac
tory#getScheduler(String)
*/
public void
setSchedulerName(String schedulerName) {
this.schedulerName = schedulerName;
}
/**
*
Set the location of
the Quartz properties config file, for example
* as classpa
th resource "classpa
th:quartz
.properties"
.
* <p>
Note: Can be omitted when all necessary properties are specified
* locally via
this bean, or when relying on Quartz'
default configuration
.
* @see #
setQuartzProperties
*/
public void
setConfigLocation(Resource configLocation) {
this.configLocation = configLocation;
}
/**
*
Set Quartz properties, like "org
.quartz
.threadPool
.class"
.
* <p>Can be used
to override values in a Quartz properties config file,
* or
to specify all necessary properties locally
.
* @see #
setConfigLocation
*/
public void
setQuartzProperties(Properties quartzProperties) {
this.quartzProperties = quartzProperties;
}
/**
*
Set a Spring-managed {@link Execu
tor}
to use as Quartz backend
.
* Exposed as
thread pool
through
the Quartz SPI
.
* <p>Can be used
to assign a local JDK
ThreadPoolExecu
tor or a CommonJ
* WorkManager as Quartz backend,
to avoid Quartz's manual
thread creation
.
* <p>
By default, a Quartz Simple
ThreadPool will be used, configured
through
*
the corresponding Quartz properties
.
* @since 2
.0
* @see #
setQuartzProperties
* @see LocalTaskExecu
tor
ThreadPool
* @see org
.springframework
.scheduling
.con
current.ThreadPoolTaskExecu
tor
* @see org
.springframework
.scheduling
.con
current.DefaultManagedTaskExecu
tor
*/
public void
setTaskExecu
tor(Execu
tor taskExecu
tor) {
this.taskExecu
tor = taskExecu
tor;
}
/**
*
Set the default {@link DataSource}
to be used
by the Scheduler
.
* <p>
Note: If
this is set,
the Quartz
settings should
not define
* a job s
tore "dataSource"
to avoid meaningless double configuration
.
* Also, do
not define a "org
.quartz
.jobS
tore
.class" property at all
.
* (You may explicitly define Spring's {@link LocalDataSourceJobS
tore}
* but
that's
the default when using
this me
thod anyway
.)
* <p>A Spring-specific subclass of Quartz' JobS
toreCMT will be used
.
* It
is therefore strongly recommended
to perform all operations on
*
the Scheduler wi
thin Spring-managed (or plain JTA) transactions
.
* Else, database locking will
not properly work and might even break
* (for example, if trying
to obtain a lock on Oracle wi
thout a transaction)
.
* <p>Supports bo
th transactional and non-transactional DataSource access
.
* Wi
th a non-XA DataSource and local Spring transactions, a single DataSource
* argument
is sufficient
. In case of an XA DataSource and global JTA transactions,
* SchedulerFac
toryBean's "nonTransactionalDataSource" property should be
set,
* passing in a non-XA DataSource
that will
not participate in global transactions
.
* @since 1
.1
* @see #
setNonTransactionalDataSource
* @see #
setQuartzProperties
* @see #
setTransactionManager
* @see LocalDataSourceJobS
tore
*/
public void
setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
/**
*
Set the {@link DataSource}
to be used <i>for non-transactional access</i>
.
* <p>
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
.
* <p>
This is not relevant wi
th a local DataSource instance and Spring transactions
.
* Specifying a single
default DataSource as "dataSource"
is sufficient
there
.
* @since 1
.1
* @see #
setDataSource
* @see LocalDataSourceJobS
tore
*/
public void
setNonTransactionalDataSource(DataSource nonTransactionalDataSource) {
this.nonTransactionalDataSource = nonTransactionalDataSource;
}
/**
* Reg
ister objects in
the Scheduler context via a given Map
.
*
These objects will be available
to any Job
that runs in
this Scheduler
.
* <p>
Note: When using pers
istent Jobs whose JobDetail will be kept in
the
* database, do
not put Spring-managed beans or an ApplicationContext
* reference in
to the JobDataMap but ra
ther in
to the SchedulerContext
.
* @param schedulerContextAsMap a Map wi
th String keys and any objects as
* values (for example Spring-managed beans)
* @see JobDetailFac
toryBean#
setJobDataAsMap
*/
public void
setSchedulerContextAsMap(Map<String, ?> schedulerContextAsMap) {
this.schedulerContextMap = schedulerContextAsMap;
}
/**
*
Set the key of an {@link ApplicationContext} reference
to expose in
the
* SchedulerContext, for example "applicationContext"
. Default is none
.
* Only applicable when running in a Spring ApplicationContext
.
* <p>
Note: When using pers
istent Jobs whose JobDetail will be kept in
the
* database, do
not put an ApplicationContext reference in
to the JobDataMap
* but ra
ther in
to the SchedulerContext
.
* <p>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" me
thod in
that scenario
.
* <p>
Note
that BeanFac
tory callback interfaces like ApplicationContextAware
* are
not au
tomatically applied
to Quartz Job instances, because Quartz
* itself
is responsible for
the lifecycle of its Jobs
.
* @see JobDetailFac
toryBean#
setApplicationContextJobDataKey
* @see org
.springframework
.context
.ApplicationContext
*/
public void
setApplicationContextSchedulerContextKey(String applicationContextSchedulerContextKey) {
this.applicationContextSchedulerContextKey = applicationContextSchedulerContextKey;
}
/**
*
Set the Quartz {@link JobFac
tory}
to use for
this Scheduler
.
* <p>
Default is Spring's {@link AdaptableJobFac
tory},
which supports
* {@link
java.lang
.Runnable} objects as well as standard Quartz
* {@link org
.quartz
.Job} instances
. Note
that
this default only applies
*
to a <i>local</i> Scheduler,
not to a RemoteScheduler (where
setting
* a cus
tom JobFac
tory
is not supported by Quartz)
.
* <p>Specify an instance of Spring's {@link SpringBeanJobFac
tory} here
* (typically as an inner bean definition)
to au
tomatically populate a job's
* bean properties from
the specified job data map and scheduler context
.
* @since 2
.0
* @see AdaptableJobFac
tory
* @see SpringBeanJobFac
tory
*/
public void
setJobFac
tory(JobFac
tory jobFac
tory) {
this.jobFac
tory = jobFac
tory;
this.jobFac
tory
Set = true;
}
/**
*
Set whe
ther
to au
tomatically start
the scheduler after initialization
.
* <p>
Default is "true";
set this to "false"
to allow for manual startup
.
*/
public void
setAu
toStartup(boolean au
toStartup) {
this.au
toStartup = au
toStartup;
}
/**
* Return whe
ther
this scheduler
is configured for au
to-startup
. If "true",
*
the scheduler will start after
the context
is refreshed and after
the
* start delay, if any
.
*/
@Override
public boolean
isAu
toStartup() {
return
this.au
toStartup;
}
/**
* Specify
the phase in
which this scheduler should be started and s
topped
.
*
The startup order proceeds from lowest
to highest, and
the shutdown order
*
is the reverse of
that
. By default this value
is {@code Integer
.MAX_VALUE}
* meaning
that
this scheduler starts as late as possible and s
tops as soon
* as possible
.
* @since 3
.0
*/
public void
setPhase(int phase) {
this.phase = phase;
}
/**
* Return
the phase in
which this scheduler will be started and s
topped
.
*/
@Override
public int getPhase() {
return
this.phase;
}
/**
*
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
.
* <p>
Setting
this to 10 or 20 seconds makes sense if no jobs
* should be run before
the entire application has started up
.
*/
public void
setStartupDelay(int startupDelay) {
this.startupDelay = startupDelay;
}
/**
*
Set whe
ther
to expose
the Spring-managed {@link Scheduler} instance in
the
* Quartz {@link SchedulerReposi
tory}
. Default is "false", since
the Spring-managed
* Scheduler
is usually exclusively intended for access wi
thin
the Spring context
.
* <p>Switch
this flag
to "true" in order
to expose
the Scheduler globally
.
*
This is not recommended unless you have an ex
isting 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
setExposeSchedulerInReposi
tory(boolean exposeSchedulerInReposi
tory) {
this.exposeSchedulerInReposi
tory = exposeSchedulerInReposi
tory;
}
/**
*
Set whe
ther
to wait for running jobs
to complete on shutdown
.
* <p>
Default is "false"
. Switch
this to "true" if you prefer
* fully completed jobs at
the expense of a longer shutdown phase
.
* @see org
.quartz
.Scheduler#shutdown(boolean)
*/
public void
setWaitForJobs
ToCompleteOnShutdown(boolean waitForJobs
ToCompleteOnShutdown) {
this.waitForJobs
ToCompleteOnShutdown = waitForJobs
ToCompleteOnShutdown;
}
@Override
public void
setBeanName(String name) {
this.beanName = name;
}
@Override
public void
setApplicationContext(ApplicationContext applicationContext) {
this.applicationContext = applicationContext;
}
//---------------------------------------------------------------------
// Implementation of InitializingBean interface
//---------------------------------------------------------------------
@Override
public void afterProperties
Set()
throws Exception {
if (
this.dataSource == null &&
this.nonTransactionalDataSource != null) {
this.dataSource =
this.nonTransactionalDataSource;
}
if (
this.applicationContext != null &&
this.resourceLoader == null) {
this.resourceLoader =
this.applicationContext;
}
// Initialize
the Scheduler instance
...
this.scheduler = prepareScheduler(prepareSchedulerFac
tory());
try {
reg
isterL
isteners();
reg
isterJobsAndTriggers();
}
catch (Exception ex) {
try {
this.scheduler
.shutdown(true);
}
catch (Exception ex2) {
logger
.debug("Scheduler shutdown exception after reg
istration failure", ex2);
}
throw ex;
}
}
/**
* Create a SchedulerFac
tory if necessary and apply locally defined Quartz properties
to it
.
* @return
the initialized SchedulerFac
tory
*/
private SchedulerFac
tory prepareSchedulerFac
tory()
throws SchedulerException, IOException {
SchedulerFac
tory schedulerFac
tory =
this.schedulerFac
tory;
if (schedulerFac
tory == null) {
// Create local SchedulerFac
tory instance (typically a StdSchedulerFac
tory)
schedulerFac
tory = BeanUtils
.instantiateClass(
this.schedulerFac
toryClass);
if (schedulerFac
tory instanceof StdSchedulerFac
tory stdSchedulerFac
tory) {
initSchedulerFac
tory(stdSchedulerFac
tory);
}
else if (
this.configLocation != null ||
this.quartzProperties != null ||
this.taskExecu
tor != null ||
this.dataSource != null) {
throw new IllegalArgumentException(
"StdSchedulerFac
tory required for applying Quartz properties: " + schedulerFac
tory);
}
// O
therw
ise, no local
settings
to be applied via StdSchedulerFac
tory
.initialize(Properties)
}
// O
therw
ise, assume
that externally provided fac
tory has been initialized wi
th appropriate
settings
return schedulerFac
tory;
}
/**
* Initialize
the given SchedulerFac
tory, applying locally defined Quartz properties
to it
.
* @param schedulerFac
tory
the SchedulerFac
tory
to initialize
*/
private void initSchedulerFac
tory(StdSchedulerFac
tory schedulerFac
tory)
throws SchedulerException, IOException {
Properties mergedProps = new Properties();
if (
this.resourceLoader != null) {
mergedProps
.setProperty(StdSchedulerFac
tory
.PROP_SCHED_CLASS_LOAD_HELPER_CLASS,
ResourceLoaderClassLoadHelper
.class
.getName());
}
if (
this.taskExecu
tor != null) {
mergedProps
.setProperty(StdSchedulerFac
tory
.PROP_
THREAD_POOL_CLASS,
LocalTaskExecu
tor
ThreadPool
.class
.getName());
}
else {
//
Set necessary
default properties here, as Quartz will
not apply
// its
default configuration when explicitly given properties
.
mergedProps
.setProperty(StdSchedulerFac
tory
.PROP_
THREAD_POOL_CLASS, Simple
ThreadPool
.class
.getName());
mergedProps
.setProperty(PROP_
THREAD_COUNT, Integer
.toString(
DEFAULT_
THREAD_COUNT));
}
if (
this.configLocation != null) {
if (logger
.isDebugEnabled()) {
logger
.debug("Loading Quartz config from [" +
this.configLocation + "]");
}
PropertiesLoaderUtils
.fillProperties(mergedProps,
this.configLocation);
}
CollectionUtils
.mergePropertiesIn
toMap(
this.quartzProperties, mergedProps);
if (
this.dataSource != null) {
mergedProps
.putIfAbsent(StdSchedulerFac
tory
.PROP_JOB_S
TORE_CLASS, LocalDataSourceJobS
tore
.class
.getName());
}
// Determine scheduler name across local
settings and Quartz properties
...
if (
this.schedulerName != null) {
mergedProps
.setProperty(StdSchedulerFac
tory
.PROP_SCHED_INSTANCE_NAME,
this.schedulerName);
}
else {
String nameProp = mergedProps
.getProperty(StdSchedulerFac
tory
.PROP_SCHED_INSTANCE_NAME);
if (nameProp != null) {
this.schedulerName = nameProp;
}
else if (
this.beanName != null) {
mergedProps
.setProperty(StdSchedulerFac
tory
.PROP_SCHED_INSTANCE_NAME,
this.beanName);
this.schedulerName =
this.beanName;
}
}
schedulerFac
tory
.initialize(mergedProps);
}
private Scheduler prepareScheduler(SchedulerFac
tory schedulerFac
tory)
throws SchedulerException {
if (
this.resourceLoader != null) {
// Make given ResourceLoader available for SchedulerFac
tory configuration
.
configTimeResourceLoaderHolder
.set(
this.resourceLoader);
}
if (
this.taskExecu
tor != null) {
// Make given TaskExecu
tor available for SchedulerFac
tory configuration
.
configTimeTaskExecu
torHolder
.set(
this.taskExecu
tor);
}
if (
this.dataSource != null) {
// Make given DataSource available for SchedulerFac
tory configuration
.
configTimeDataSourceHolder
.set(
this.dataSource);
}
if (
this.nonTransactionalDataSource != null) {
// Make given non-transactional DataSource available for SchedulerFac
tory configuration
.
configTimeNonTransactionalDataSourceHolder
.set(
this.nonTransactionalDataSource);
}
// Get Scheduler instance from SchedulerFac
tory
.
try {
Scheduler scheduler = createScheduler(schedulerFac
tory,
this.schedulerName);
populateSchedulerContext(scheduler);
if (!
this.jobFac
tory
Set && !(scheduler instanceof RemoteScheduler)) {
// Use AdaptableJobFac
tory as
default for a local Scheduler, unless when
// explicitly given a null value
through
the "jobFac
tory" bean property
.
this.jobFac
tory = new AdaptableJobFac
tory();
}
if (
this.jobFac
tory != null) {
if (
this.applicationContext != null &&
this.jobFac
tory instanceof ApplicationContextAware applicationContextAware) {
applicationContextAware
.setApplicationContext(
this.applicationContext);
}
if (
this.jobFac
tory instanceof SchedulerContextAware schedulerContextAware) {
schedulerContextAware
.setSchedulerContext(scheduler
.getContext());
}
scheduler
.setJobFac
tory(
this.jobFac
tory);
}
return scheduler;
}
finally {
if (
this.resourceLoader != null) {
configTimeResourceLoaderHolder
.remove();
}
if (
this.taskExecu
tor != null) {
configTimeTaskExecu
torHolder
.remove();
}
if (
this.dataSource != null) {
configTimeDataSourceHolder
.remove();
}
if (
this.nonTransactionalDataSource != null) {
configTimeNonTransactionalDataSourceHolder
.remove();
}
}
}
/**
* Create
the Scheduler instance for
the given fac
tory and scheduler name
.
* Called
by {@link #afterProperties
Set}
.
* <p>
The default implementation invokes SchedulerFac
tory's {@code getScheduler}
* me
thod
. Can be overridden for cus
tom Scheduler creation
.
* @param schedulerFac
tory
the fac
tory
to create
the Scheduler wi
th
* @param schedulerName
the name of
the scheduler
to create
* @return
the Scheduler instance
* @
throws SchedulerException if
thrown
by Quartz me
thods
* @see #afterProperties
Set
* @see org
.quartz
.SchedulerFac
tory#getScheduler
*/
@SuppressWarnings("NullAway")
protected Scheduler createScheduler(SchedulerFac
tory schedulerFac
tory, @Nullable String schedulerName)
throws SchedulerException {
// Override
thread context ClassLoader
to work around naive Quartz ClassLoadHelper loading
.
Thread
currentThread =
Thread
.currentThread();
ClassLoader
threadContextClassLoader =
currentThread
.getContextClassLoader();
boolean overrideClassLoader = (
this.resourceLoader != null &&
this.resourceLoader
.getClassLoader() !=
threadContextClassLoader);
if (overrideClassLoader) {
currentThread
.setContextClassLoader(
this.resourceLoader
.getClassLoader());
}
try {
SchedulerReposi
tory reposi
tory = SchedulerReposi
tory
.getInstance();
synchronized (reposi
tory) {
Scheduler ex
istingScheduler = (schedulerName != null ? reposi
tory
.lookup(schedulerName) : null);
Scheduler newScheduler = schedulerFac
tory
.getScheduler();
if (newScheduler == ex
istingScheduler) {
throw new IllegalStateException("Active Scheduler of name '" + schedulerName + "' already reg
istered " +
"in Quartz SchedulerReposi
tory
. Can
not create a new Spring-managed Scheduler of
the same name!");
}
if (!
this.exposeSchedulerInReposi
tory) {
// Need
to remove it in
this case, since Quartz shares
the Scheduler instance
by default!
SchedulerReposi
tory
.getInstance()
.remove(newScheduler
.getSchedulerName());
}
return newScheduler;
}
}
finally {
if (overrideClassLoader) {
// Re
set original
thread context ClassLoader
.
currentThread
.setContextClassLoader(
threadContextClassLoader);
}
}
}
/**
* Expose
the specified context attributes and/or
the current
* ApplicationContext in
the Quartz SchedulerContext
.
*/
private void populateSchedulerContext(Scheduler scheduler)
throws SchedulerException {
// Put specified objects in
to Scheduler context
.
if (
this.schedulerContextMap != null) {
scheduler
.getContext()
.putAll(
this.schedulerContextMap);
}
// Reg
ister ApplicationContext in Scheduler context
.
if (
this.applicationContextSchedulerContextKey != null) {
if (
this.applicationContext == null) {
throw new IllegalStateException(
"SchedulerFac
toryBean needs
to be
set up in an ApplicationContext " +
"
to be able
to handle an 'applicationContextSchedulerContextKey'");
}
scheduler
.getContext()
.put(
this.applicationContextSchedulerContextKey,
this.applicationContext);
}
}
/**
* Start
the Quartz Scheduler, respecting
the "startupDelay"
setting
.
* @param scheduler
the Scheduler
to start
* @param startupDelay
the number of seconds
to wait before starting
*
the Scheduler asynchronously
*/
protected void startScheduler(final Scheduler scheduler, final int startupDelay)
throws SchedulerException {
if (startupDelay <= 0) {
logger
.info("Starting Quartz Scheduler now");
scheduler
.start();
}
else {
if (logger
.isInfoEnabled()) {
logger
.info("Will start Quartz Scheduler [" + scheduler
.getSchedulerName() +
"] in " + startupDelay + " seconds");
}
//
Not using
the Quartz startDelayed me
thod since we explicitly want a daemon
//
thread here,
not keeping
the JVM alive in case of all o
ther
threads ending
.
Thread scheduler
Thread = new
Thread(() -> {
try {
TimeUnit
.SECONDS
.sleep(startupDelay);
}
catch (InterruptedException ex) {
Thread
.currentThread()
.interrupt();
// simply proceed
}
if (logger
.isInfoEnabled()) {
logger
.info("Starting Quartz Scheduler now, after delay of " + startupDelay + " seconds");
}
try {
scheduler
.start();
}
catch (SchedulerException ex) {
throw new SchedulingException("Could
not start Quartz Scheduler after delay", ex);
}
});
scheduler
Thread
.setName("Quartz Scheduler [" + scheduler
.getSchedulerName() + "]");
scheduler
Thread
.setDaemon(true);
scheduler
Thread
.start();
}
}
//---------------------------------------------------------------------
// Implementation of Fac
toryBean interface
//---------------------------------------------------------------------
@Override
public Scheduler getScheduler() {
Assert
.state(
this.scheduler != null, "No Scheduler
set");
return
this.scheduler;
}
@Override
@Nullable
public Scheduler ge
tObject() {
return
this.scheduler;
}
@Override
public Class<? extends Scheduler> ge
tObjectType() {
return (
this.scheduler != null ?
this.scheduler
.getClass() : Scheduler
.class);
}
@Override
public boolean
isSingle
ton() {
return true;
}
//---------------------------------------------------------------------
// Implementation of SmartLifecycle interface
//---------------------------------------------------------------------
@Override
public void start()
throws SchedulingException {
if (
this.scheduler != null) {
try {
startScheduler(
this.scheduler,
this.startupDelay);
}
catch (SchedulerException ex) {
throw new SchedulingException("Could
not start Quartz Scheduler", ex);
}
}
}
@Override
public void s
top()
throws SchedulingException {
if (
this.scheduler != null) {
try {
this.scheduler
.stand
by();
}
catch (SchedulerException ex) {
throw new SchedulingException("Could
not s
top Quartz Scheduler", ex);
}
}
}
@Override
public boolean
isRunning()
throws SchedulingException {
if (
this.scheduler != null) {
try {
return !
this.scheduler
.isInStand
byMode();
}
catch (SchedulerException ex) {
return false;
}
}
return false;
}
//---------------------------------------------------------------------
// Implementation of D
isposableBean interface
//---------------------------------------------------------------------
/**
* Shut down
the Quartz scheduler on bean fac
tory shutdown,
* s
topping all scheduled jobs
.
*/
@Override
public void destroy()
throws SchedulerException {
if (
this.scheduler != null) {
logger
.info("Shutting down Quartz Scheduler");
this.scheduler
.shutdown(
this.waitForJobs
ToCompleteOnShutdown);
}
}
}
我看到的start和你的不一样
在将IntelliJ从Java12更新到Java16后，遇到编译错误，提示默认的语言级别不被当前Java版本支持。尝试直接升级未成功。解决办法是在pom.xml中添加maven-compiler-plugin配置，设定source和target为1.8，从而解决了编译问题。
扫一扫
2121
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
