example_quartz.properties

Quartz 是个开源的作业调度框架

# Properties file for use by StdSchedulerFactory
# to create a Quartz Scheduler Instance.
#
# Instances of the specified JobStore, ThreadPool and Logger classes will
# be created by name, and then any additional properties specified for them
# in this file will be set on the instance by calling an equivalent 'set'
# method. (see below for more examples)
#

# ===========================================================================
# Configure Main Scheduler Properties  ======================================
# ===========================================================================
#
# The general pattern for defining the scheduler's main properties is:
#
#     org.quartz.scheduler.instanceName = SCHED_NAME
#     org.quartz.scheduler.instanceId = INSTANCE_ID
#     org.quartz.scheduler.threadName = THREAD_NAME
#     org.quartz.scheduler.rmi.export = false
#     org.quartz.scheduler.rmi.proxy = false
#     org.quartz.scheduler.rmi.registryHost = localhost
#     org.quartz.scheduler.rmi.registryPort = 1099
#     org.quartz.scheduler.rmi.createRegistry = never
#     org.quartz.scheduler.userTransactionURL = USER_TX_LOCATION
#     org.quartz.scheduler.wrapJobExecutionInUserTransaction = JOBS_IN_USER_TX
#     org.quartz.scheduler.idleWaitTime = IDLE_WAIT_TIME
#     org.quartz.scheduler.dbFailureRetryInterval = DB_FAILURE_RETRY_INTERVAL
#     org.quartz.scheduler.classLoadHelper.class = CLASS_LOAD_HELPER_CLASS
#     org.quartz.context.key.SOME_KEY = SOME_VALUE
#
#
# "SCHED_NAME" can be any string, and has no meaning to the scheduler itself -
# but rather serves as a mechanism for client code to distinguish schedulers
# when multiple instances are used within the same program.  If you are using
# the clustering features, you must use the same name for every instance in 
# the cluster that is 'logically' the same Scheduler.
#
# "INSTANCE_ID" can be any string, and but must be unique for all schedulers
# working as if they are the same 'logical' Scheduler within a cluster.
# you may use the value "AUTO" as the instanceId if you wish the Id to be 
# generated for you.
#
# "THREAD_NAME" can be any String that is a valid name for a java thread. If
# this property is not specified, the thread will receive the scheduler's 
# name ("org.quartz.scheduler.instanceName").
#
# "USER_TX_LOCATION" should be set to the JNDI URL at which Quartz can locate
# the Application Server's UserTransaction manager.  The default value (if not
# specified) is "java:comp/UserTransaction" - which works for almost all 
# Application Servers.  Websphere users may need to set this property to 
# "jta/usertransaction".  This is only used if Quartz is configured to use
# JobStoreCMT, and "JOBS_IN_USER_TX" is set to true.
# 
# "JOBS_IN_USER_TX" should be set to "true" if you want Quartz to start a 
# UserTransaction before calling execute on your job.  The Tx will commit after
# the job's execute method completes, and the JobDataMap is updated (if it is
# a StatefulJob).  The default value is "false".
#
# "IDLE_WAIT_TIME" is the amount of time in milliseconds that the scheduler 
# will wait before re-queries for available triggers when the scheduler is otherwise
# idle.  Normally you should not have to 'tune' this parameter, unless you're using
# XA transactions, and are having problems with delayed firings of triggers that
# should fire immediately.
#
# "DB_FAILURE_RETRY_INTERVAL" is the amount of time in milliseconds that the
# scheduler will wait between re-tries when it has detected a loss of 
# connectivity to the database (obviously not meaningful with RamJobStore)
#
# "CLASS_LOAD_HELPER_CLASS" defaults to the most robust approach, which is to 
# use the "org.quartz.simpl.CascadingClassLoadHelper" class - which in turn
# uses every other ClassLoadHelper class until one works.  You should probably
# not find the need to specify any other class for this property, though strange
# things seem to happen within application servers.  All of the current 
# ClassLoadHelper implementation can be found in the "org.quartz.simpl" package.
#
# "SOME_KEY" and "SOME_VALUE" represent a name-value pair that will be placed
# into the "scheduler context" as strings. (see Scheduler.getContext()).  
# So for example, the setting "org.quartz.context.key.MyKey = MyValue" would 
# perform the equivalent of scheduler.getContext().put("MyKey", "MyValue").
#
#
# RMI notes:
#
# If you want the Quartz Scheduler exported via RMI as a server then set
# the 'rmi.export' flag to true.  You must also then specify a  host and
# port for the rmiregistry process - which is typically 'localhost' port 1099.
#
# Set the 'rmi.createRegistry' flag according to how you want Quartz to cause 
# the creation of an RMI Registry.  Use "false" or "never" if you don't want
# Quartz to create a registry.  Use "true" or "as_needed" if you want Quartz
# to first attempt to use an existing registry, and then fall back to creating 
# one.  Use "always" if you want Quartz to attempt creating a Registry, and
# then fall back to using an existing one.
#   If a registry is created, it will be bound to port number in the given 
# the 'rmi.registryPort' property, and 'rmi.registryHost' should be "localhost".
#
# If you want to connect (use) a remotely served scheduler, then set the
# 'rmi.proxy' flag to true.  You must also then specify a  host and port
# for the rmiregistry process - which is typically 'localhost' port 1099.
#
# You cannot specify a 'true' value for both 'export' and 'proxy' - if you
# do, the 'export' option will be ignored.  A value of 'false' for both
# 'export' and 'proxy' properties is of course valid.
#
org.quartz.scheduler.instanceName = Sched1
org.quartz.scheduler.instanceId = 1
org.quartz.scheduler.rmi.export = false
org.quartz.scheduler.rmi.proxy = false


# ===========================================================================
# Configure ThreadPool  =====================================================
# ===========================================================================
#
# The general pattern for defining a thread pool is the following:
#
#     org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
#     org.quartz.threadPool.threadCount = THREAD_COUNT
#     org.quartz.threadPool.threadPriority = THREAD_PRIO
#
#       optional parameters for SimpleThreadPool are:
#
#         org.quartz.threadPool.makeThreadsDaemons = DAEMON_THREADS
#         org.quartz.threadPool.threadsInheritGroupOfInitializingThread = INHERIT_GRP
#         org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = INHERIT_LDR
#
#  or
#
#     org.quartz.threadPool.class = com.mycompany.goo.FooThreadPool
#     org.quartz.threadPool.somePropOfFooThreadPool = someValue
#
# "THREAD_COUNT" can be any positive integer, although you should realize that
# only numbers between 1 and 100 are very practical.  This is the number of
# threads that are available for concurrent execution of jobs.  If you only
# have a few jobs that fire a few times a day, then 1 thread is plenty! If you
# have tens of thousands of jobs, with many firing every minute, then you
# probably want a thread count more like 50 or 100 (this highly depends on the
# nature of the work that your jobs perform, and your systems resources!)
#
# "THREAD_PRIO" can be any int between Thread.MIN_PRIORITY (1) and
# Thread.MAX_PRIORITY (10).  The default is Thread.NORM_PRIORITY (5).
#
# "DAEMON_THREADS" can be set to "true" to have the threads in the pool created
# as daemon threads.  Default is "false".
#
# "INHERIT_GRP" can be "true" or "false", and defaults to true.
#
# "INHERIT_LDR" can be "true" or "false", and defaults to false.
#
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount = 3
org.quartz.threadPool.threadPriority = 5

# ===========================================================================
# Configure JobStore  =======================================================
# ===========================================================================
#
# The general pattern for defining a JobStore is one of the following:
#
#     org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore
#     org.quartz.jobStore.misfireThreshold = MISFIRE_THRESHOLD
#
#  or
#
#     org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.<JobStoreClass>
#       Where JobStoreClass is one of:
#         - JobStoreTX is for standalone-Quartz implementations
#         - JobStoreCMT is for appserver-based container-managed
#           transaction Quartz implementations
#
#     org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.<DriverDelegateClass>
#       Where DriverDelegateClass is one of:
#         - StdJDBCDelegate (for many JDBC-compliant drivers)
#         - MSSQLDelegate (for Microsoft SQL Server drivers)
#         - PostgreSQLDelegate (for PostgreSQL drivers)
#         - WebLogicDelegate (for WebLogic drivers)
#         - oracle.OracleDelegate (for Oracle drivers)
#
#     org.quartz.jobStore.useProperties = USE_PROPERTIES
#     org.quartz.jobStore.dataSource = DS_NAME
#     org.quartz.jobStore.tablePrefix = TABLE_PREFIX
#     org.quartz.jobStore.isClustered = IS_CLUSTERED
#     org.quartz.jobStore.selectWithLockSQL = LOCKING_SELECT_STATEMENT
#     org.quartz.jobStore.dontSetAutoCommitFalse = DONT_TURN_OFF_AUTO_COMMIT
#     org.quartz.jobStore.maxMisfiresToHandleAtATime = MAX_MISFIRE_HANDLE
#     org.quartz.jobStore.txIsolationLevelSerializable = SERIALIZABLE_ISOLATION
#
#   If you're using JobStoreCMT then you need this param also:
#
#     org.quartz.jobStore.nonManagedTXDataSource = NON_MANAGED_TX_DS_NAME
#
#   And, if you're using JobStoreCMT, then these params are optional:
#
#     org.quartz.jobStore.dontSetNonManagedTXConnectionAutoCommitFalse = DONT_TURN_OFF_AUTO_COMMIT
#     org.quartz.jobStore.txIsolationLevelReadCommitted = READ_COMMITTED_ISOLATION
#
#
#  or, for a custom JobStore implementation:
#
#     org.quartz.jobStore.class = com.mycompany.goo.FooJobStore
#     org.quartz.jobStore.somePropOfFooJobStore = someValue
#
#
# The value of "MISFIRE_THRESHOLD" should be the number of milliseconds the
# scheduler will 'tolerate' a trigger to pass its next-fire-time by, before
# being considered "misfired".  The default value (if you don't make an entry
# of this property in your configuration) is 60000 (60 seconds).
#
# The value of "MAX_MISFIRE_HANDLE" is the maximum number of misfired triggers 
# that the misfire handlingthread will try to recover at one time (within one 
# transaction).  If unspecified, the default is 20.
#
# The "USE_PROPERTIES" flag (true or false value - defaults to false) instructs
# JDBCJobStore that all values in JobDataMaps will be Strings, and therefore
# can be stored as name-value pairs, rather than storing more complex objects
# in their serialized form in the BLOB column.  This is much safer in the long