|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
Query providers.ItemReaders that supports restart by storing
item count in the ExecutionContext (therefore requires item ordering
to be preserved between runs).ItemReader implementations.ItemWriter implementations.Job interface.FactoryBean that automates the creation of a
SimpleJobExplorer.FactoryBean that automates the creation of a
SimpleJobRepository.JobLauncherTestUtils insteadQuery providers.LineTokenizer
implementations such as dealing with names and actual construction of
FieldSetFactoryBean implementation that builds a listener based on the
various lifecycle methods or annotations that are provided.Throwable (not an Exception) thrown by a
reflectively-invoked delegate.ItemReader for to extend when
reading database records in a paging fashion.Step implementation that provides common behavior to subclasses,
including registering and calling listeners.StepExecution and its ExecutionContext.
Date parameter for the given key.
ExitStatus.
JobParameter for the given key.
StepExecution for the parent JobExecution.
Ordered.
Job has completed.Ordered.
ItemProcessor ItemProcessor.process(Object) returns.
Ordered.
JobRepository.
JobRepository have been
set.
ItemReader ItemReader.read()
Ordered.
Step has completed.Ordered.
ItemWriter List<?ItemWriter.write(java.util.List) This will be
called before any transaction is committed, and before
ChunkListener.afterChunk()
Ordered.
FlowExecutionStatuses of the
FlowExecutions into one status.
StepExecution.
StepExecution
delegating to the delegate aggregator once the input has been refreshed
from the JobExplorer.
FieldExtractor and
then aggregate them.
RetryPolicy that always permits a retry.SkipPolicy interface that
will always return that an item should be skipped.ExitStatus with a logical combination of the exit
code, and a concatenation of the descriptions.
ApplicationContexts.JobFactory that creates its own ApplicationContext and
pulls a bean out when asked to create a Job.Jobs when the application context is created
and destroyed.exp(backOffContext.expSeed)'.
StatelessBackOffPolicy.doBackOff() method without passing on
the BackOffContext argument which is not needed for stateless
implementations.
BackOffPolicy was interrupted, most likely by an
InterruptedException during a call to Thread.sleep(long).retry operation.Classifier with easy configuration options for
mapping from one arbitrary type of object to another via a pattern matcher.FieldSetMapper implementation based on bean property paths.Job is executed, which comes
after a JobExecution is created and persisted, but before the first
Step is executed.Ordered.
ItemProcessor ItemProcessor.process(Object).
Ordered.
ItemReader ItemReader.read()
Ordered.
Step is executed, which comes
after a StepExecution is created and persisted, but before the first
item is read.Ordered.
JobParameters to the Step
ExecutionContext, if not already present.
SimpleCompletionPolicy with a commit interval taken from
the JobParameters.
StepExecution for interrupt checks during
system command execution.
StepExecution from
the current scope.
ItemWriter List<?ItemWriter.write(java.util.List)
Ordered.
Classifier for exceptions that has only two classes (true and
false).JobFactory provided and register it with the
JobRegistry.
BufferedReader allowing
customisation of the standard behaviour of the java.io variety.Callable<RepeatStatus> to the Tasklet
interface.#remove(Exception)
method for dynamically removing an item and adding it to the skips.ChunkListenerTasklet implementing variations on read-process-write item
handling.Chunks.Chunks to be processed, used by the
ChunkOrientedTaskletClassifier interface.Classifier from the delegate provided.
Classifier from the delegate provided.
Classifier.Classifier implementations.PatternMatchingClassifier.setPatternMap(Map).
ApplicationContextFactory implementation that takes a parent context
and a path to the context to create.ApplicationContextFactory
components from a set of resources.AutomaticJobRegistrar insteadRepeatOperations implementations.
RepeatOperations implementations.
StepSynchronizationManager.register(StepExecution)
to ensure that StepSynchronizationManager.getContext() always returns the correct value.
MultiResourceItemReader.setDelegate(ResourceAwareItemReaderItemStream) reader and reset instance variable values.
ItemStream, just pass the call on,
otherwise reset the peek cache.
ItemPreparedStatementSetter interface that assumes all
keys are contained within a Map with the column name as the key.FlowExecution instances by comparing their
statuses.
FlowExecutionStatus instances by comparing
their statuses.
CompletionPolicy implementations.ExceptionHandler that loops though a list of delegates.ItemProcessor that passes the item through a sequence of
injected ItemTransformers (return value of previous
transformation is the entry value of the next).ItemStream that delegates to a list of other streams.ItemWriters in fixed-order sequence.JobParametersValidator that passes the job parameters through a sequence of
injected JobParametersValidatorsRetryPolicy that composes a list of other policies and delegates
calls to them in order.ExitStatus
according to injected map.ChunkProcessor.
ChunkProvider.
sql.
BufferedReader for reading String items from the
provided resource.
ApplicationContext from the provided path.
BundleContext and the enclosing Spring
ApplicationContext as a parent context.
StateTransition specification.
StateTransition specification.
ApplicationContext from the factory provided and pull
out a bean with the name given during initialization.
JobExecution for a given Job and
JobParameters.
JobExecution with default parameters.
JobExecution with the parameters provided.
JobExecution with the parameters provided.
JobExecution with the parameters provided.
JobExecution with the parameters provided.
JobRepository to create some JobExecution
instances each with the given job name and each having step executions
with the given step names.
JobRepository to create some JobExecution
instances each with a single step execution.
JobExecution with the parameters provided with attached
step executions.
JobInstance with the parameters provided.
JobInstance with the parameters provided.
JobInstance with the parameters provided.
JobInstance with default parameters.
SQLQuery from the session provided (preferring
stateless if both are available).
BeanDefinition for a target
wrapped in a placeholder tarrget source, able to defer binding of
placeholders until the bean is used.
BeanPropertySqlParameterSource based on values from
the provided item.
SqlParameterSource based on values from
the provided item.
StateTransition specification with a wildcard
pattern that matches all outcomes.
StateTransition specification from one State
to another (by name).
StepContribution.
StepExecution with default parameters.
StepExecution with the parameters provided.
StepExecution with the parameters provided.
StepExecution and all its parent entities with default
values, but using the ExecutionContext and JobParameters
provided.
StepExecution and all its parent entities with default
values, but using the JobParameters provided.
StepExecution and all its parent entities with default
values, but using the ExecutionContext provided.
DataFieldMaxValueIncrementer implementations
based upon a provided string.DataSource that can run scripts on start up and shut
down.PagingQueryProvider using
database specific features.JobExecution.
DataFieldMaxValueIncrementerFactory
interface.ExceptionHandler - just re-throws the exception it encounters.FieldSet using Java using Java primitive
and standard types and utilities.FieldSetFactory with no special knowledge
of the FieldSet required.FragmentEventReaderItemListenerSupport class that
writes all exceptions via commons logging.JobLoader.JobParameters instances using a simple naming
convention for property keys.JobParametersExtractor which pulls
parameters with named keys out of the step execution context and the job
parameters of the surrounding job.JobParametersValidator.LineMapper implementation consisting of tokenization of the line into FieldSet followed by
mapping to item.MailErrorHandler implementation simply rethrows the exception it
receives.PropertyEditorRegistrar that can be used wherever one
needs to register custom PropertyEditor instances with a
PropertyEditorRegistry (like a bean wrapper, or a type converter).RecordSeparatorPolicy that treats all lines as record endings, as
long as they do not have unterminated quotes, and do not end in a
continuation marker.CompletionPolicy that bases its decision on the result of
a batch operation.DefaultRetryState representing the state for a new retry
attempt.
StepExecution instances
into a single result.LineAggregator implementation that converts an object into a
delimited list of strings.LineTokenizer implementation that splits the input String on a
configurable delimiter.DelimitedLineTokenizer class for the
common case where the delimiter is a comma.
DelimitedLineTokenizer class.
PagingQueryProvider using standard SQL:2003 windowing functions.Job instances that were regsistered by this
post processor.
Poller that uses the callers thread to poll for a result as soon as
it is asked for.FixedBackOffPolicy.setBackOffPeriod(long).
AbstractItemCountingItemStreamItemReader.doOpen().
PartitionHandler provided.
JobLauncher to
prevent duplicate executions.
StepContext lifecycle.
FlowJob.
JobRepositoryFactoryBean
.
AbstractCursorItemReader.setVerifyCursorPosition(boolean) is true.
line.
line.
Job instances.MethodInvoker.State implementation for ending a job if it is in progress and
continuing if just starting.RetryPolicy that dynamically adapts to one of a set of injected
policies according to the value of the latest exception.SkipPolicy that depends on an exception classifier to make its
decision, and then delegates to the classifier result.AbstractJob.doExecute(JobExecution).
JobExecution and update the meta information like status
and statistics as necessary.
AbstractStep.open(ExecutionContext)), execution
logic (AbstractStep.doExecute(StepExecution)) and resource closing (
AbstractStep.close(ExecutionContext)).
StepExecution provided.
RepeatStatus.
ExitStatus by invoking a method in the delegate POJO.
ExitStatus using
SystemProcessExitCodeMapper.
RetryCallback with the configured retry
semantics.
RetryCallback with a fallback on exhausted
retry to the RecoveryCallback.
ItemStream.ExecutionContexts.Step
ExecutionContext to the Job ExecutionContext at the
end of a step.ExecutionContext values from job and
step executions.ExecutionContext and generating keys for
ExecutionContext based on the name.BackOffPolicy that increases the back off period
for each retry attempt in a given set using the exponential function.SmartDataSource that is capable of keeping a single
JDBC Connection which is NOT closed after each use even if
Connection.close() is called.LineAggregator implementation that utilizes a
FieldExtractor to convert the incoming object to an array of its
parts.ChunkProcessor interface, that
allows for skipping or retry of items that cause exceptions during writing.ChunkProcessor interface, that
allows for skipping or retry of items that cause exceptions during reading or
processing.FieldSet instances.FieldSet into an
object.JobExecution for given JobInstance, sorted
backwards by creation order (so the first element is the most recent).
BackOffPolicy that pauses for a fixed period of
time before continuing.FlatFileFormatException based on a message.
FlatFileFormatException based on a message and another exception.
ItemReader that reads lines from input FlatFileItemReader.setResource(Resource).FlowExecution instances into a
single exit status.FlowExecution.FlowJob to allow it to delegate
its execution step by step.Job interface that allows for complex flows of
steps, rather than requiring sequential execution.FlowJob with null name and no flow (invalid state).
FlowJob with provided name and no flow (invalid state).
XPath.Step implementation that delegates to a Flow.FlowStep that sets the flow and of the step
explicitly.
FlushFailedException based on a message and another exception.
FlushFailedException based on a message.
LineAggregator implementation which produces a String by
aggregating the provided item via the Formatter syntax.RetryContext.
EntityManager
CommandLineJobRunner as it exits.
ExceptionHandler.
ExecutionContext for this execution.
ExecutionContext for this execution
JobExecutions associated with a particular
JobInstance, in reverse order of creation (and therefore usually
of execution).
FieldSet'.
DataFieldMaxValueIncrementer for the provided database type.
ItemProcessor for subclasses to use
ItemReader for subclasses to use.
ItemWriter for subclasses to use
Job at runtime.
JobExecution by its id.
JobInstance values in descending order of creation (and
therefore usually of first execution).
JobInstances for a given job name, in
reverse order of creation (and therefore usually of first execution).
JobInstance names (sorted
alphabetically).
JobOperator.start(String, String).
JobParameters instance.
JobExecution.
JobRepository without
a cast.
Message then returns the JMS message ID.
ExecutionContextUserSupport.getName() to create a unique key that can be safely used to identify data
stored in ExecutionContext.
JobExecution to have been created for a given
JobInstance.
JobExecutionListener interfaces.
StepListener interfaces.
StepListeners.
MethodInvoker for the method with the provided annotation
on the provided object.
MethodInvoker using the provided method name to search.
MethodInvoker using the provided interface, and method
name from that interface.
MethodInvoker for the delegate from a single public
method.
TaskExecutorRepeatTemplate.setTaskExecutor(TaskExecutor) to generate a result.
ApplicationContextFactory from each resource provided
in ClasspathXmlApplicationContextsFactoryBean.setResources(Resource[]).
Step from the configuration provided.
PagingQueryProvider instance using the provided properties
and appropriate for the given database type.
ApplicationContextFactory.
FactoryBean.getObject().
AbstractJobRepositoryFactoryBean.getObject().
PagingQueryProvider.
JobParameters as an easily readable String.
Properties instance.
JobExecutions
with the given job name.
StepExecution by its id and parent
JobExecution id.
StepExecution from its id.
StepExecution that is active in this context.
StepExecution as a field in the test case or create
one if none is available.
StepExecution instances belonging to the
JobExecution with the supplied id, giving details of status,
start and end times etc.
StepRunner for running
steps by name.
StepRunner for running
steps by name.
JobExecution with the supplied id, giving details
of status, start and end times etc.
TaskExecutor available to subclasses
TransactionAttribute for subclasses only.
TransactionAttribute for subclasses only.
Job that can optionally prepend a group name to another job's name,
to make it fit a naming convention for type or origin.Job with the delegate and no group name.
Job with the given group name and delegate.
PagingQueryProvider using database specific features.State.
FlowExecutionStatus stored.
TaskExecutor
and wait for all of them to finish before proceeding.
PartitionHandler interface.
MailException.
JobExecution.
ItemReader for reading database records built on top of Hibernate.ItemWriter that uses a Hibernate session to save or update entities
that are not part of the current Hibernate session.Querys from injected native SQL
queries.ItemReader for reading database records built on top of Hibernate and
reading only up to a fixed number of items at a time.ItemReaders or other custom built artifacts.MethodInvoker that is a bit relaxed about its arguments.PagingQueryProvider using database specific features.ItemWriter that uses the batching features from
SqlMapClientTemplate to execute a batch of statements for all items
provided.ItemReader for reading database
records using iBATIS in a paging fashion.String value from column with given '
name.
DataSource if necessary.
InlineFlowParser with the specified name and using the
provided job repository ref.
RepeatOperations.
AbstractMethodInvokingDelegator.setArguments(Object[]).
Connection
true, otherwise
delegate to CompletionPolicySupport.isComplete(RepeatContext).
RepeatStatus indicating
completion.
CompletionPolicy.
CompletionPolicy.
State is an end state.
RetryContext.setExhaustedOnly().
JobExecutionListener.
StepListener.
JobExecution indicates that it is running.
Step should not be
treated as thread safe.
JobExecution indicates that it has been signalled to
stop.
ItemReadListener,
ItemProcessListener, and ItemWriteListener interfaces.RowMapper.ItemReader extend.ItemReaderException based on a message and another exception.
ItemReaderException based on a message.
ItemStream and ItemReader
.ItemStream.ItemStream and ItemWriter
.ItemWriter extend.ItemWriterException based on a message and another exception.
ItemWriterException based on a message.
ItemReader that pulls data from a Iterator or
Iterable using the constructors.Iterator from it.
ItemWriter that uses the batching features from
SimpleJdbcTemplate to execute a batch of statements for all items
provided.ExecutionContext.JobExecutionDao.JobInstanceDao.ItemReader for reading database
records using JDBC in a paging fashion.StepExecutionDao.ItemReader for JMS using a JmsTemplate.ItemWriter for JMS using a JmsTemplate.MethodArgumentsKeyGenerator for JMSNewMethodArgumentsIdentifier for JMS that looks for a message in
the arguments and checks its delivery status.JobExecutionException with a generic message.
JobExecutionException with a generic message and a
cause.
Job.JobExecutionNotRunningException with a message.
FactoryBean that automates the creation of a
SimpleJobExplorer using JDBC DAO implementations.JobFactory in a
JobRegistry.FlowExecutor for use in components that need to
execute a flow related to a JobExecution.Job and JobParameters.Job is not
available.AbstractListenerFactoryBean implementation is used to create a
JobExecutionListener.JobExecutionListener meta data, which ties together the names
of methods, their interfaces, annotation, and expected arguments.name.JobParameters to the Step ExecutionContext.JobParameters.JobParameters instances.StepExecution into
JobParameters.JobParameters in a sequence.Job to signal that some JobParameters are
invalid.JobParametersIncrementer is not
available.Job to use in validating its parameters for
an execution.name.JobRegistry.BeanPostProcessor that registers Job beans with a
JobRegistry.FactoryBean that automates the creation of a
SimpleJobRepository using JDBC DAO implementations which persist
batch metadata in database.JobExecution instances
from a database.JobRepositoryTestUtils with all its mandatory
properties.
Step that delegates to a Job to do its work.ItemWriter that is using a JPA
EntityManagerFactory to merge any Entities that aren't part of the
persistence context.Querys from injected native SQL
queries.ItemReader for reading database
records built on top of JPA.ItemReaders or other custom built artifacts.ResultSet.absolute(int) if possible, otherwise scroll by
calling ResultSet.next().
SystemExiter interface that calls the standards
System.exit method.SkipPolicy that determines whether or not reading should continue
based upon how many items have been skipped.JobLocator.ItemReader that pulls data from a list.PreparedStatementSetter interface that accepts
a list of values to be set on a PreparedStatement.ExceptionHandler based on an Classifier.CommandLineJobRunner.
ExecutionContextDao backed by maps.FieldSet to an object retrieved from the enclosing Spring
context, or to a new instance of the required type if no prototype is
available.
FieldSet into an object.
JobExecutionDao.FactoryBean that automates the creation of a
SimpleJobExplorer using in-memory DAO implementations.MapJobRepositoryFactoryBean
as a source of Dao instances.
MapJobRepositoryFactoryBean.
JobInstanceDao.JobRegistry.FactoryBean that automates the creation of a
SimpleJobRepository using non-persistent in-memory DAO
implementations.ResourcelessTransactionManager.
ExitStatus already just return that,
otherwise return ExitStatus.COMPLETED.
RetryContextCache.MapRetryContextCache with default capacity.
StepExecutionDao.FlowExecutionAggregator interface that aggregates
FlowExecutionStatus', using the status with the high precedence as the
aggregate status.JobExecution,
JobInstance and StepExecution.MethodInterceptor that, given a map of method names and
MethodInvokers, will execute all methods tied to a particular method
name, with the provided arguments.Tasklet that wraps a method in a POJO.ItemWriter that can send mail messages.MultiResourceItemReader.setResources(Resource[]), the
actual reading is delegated to MultiResourceItemReader.setDelegate(ResourceAwareItemReaderItemStream).ResourceAwareItemWriterItemStream and creates a new output
resource when the count of items written in current resource exceeds
MultiResourceItemWriter.setItemCountLimitPerResource(int).Partitioner that locates multiple resources and
associates their file names with execution context keys.PagingQueryProvider using database specific features.RepeatOperations
instance.RetryPolicy that allows the first attempt but never permits a
retry.SkipPolicy implementation that always returns false,
indicating that an item should not be skipped.BackOffPolicy that performs a no-op and as such all
retry operation in a given set proceed one after the other with no pause.NonTransientResourceException based on a message and
another exception.
NonTransientResourceException based on a message.
Job is not
available.JobExecution is not
available.JobInstance.Sleeper implementation that just waits on a local Object.Job found therein.
ItemProcessor Exception e)ItemProcessor.process(Object).
Ordered.
ItemReader Exception ex)Ordered.
ItemProcessor.Ordered.
ItemReader Throwable t)Ordered.
ItemWriter.Ordered.
ItemWriter Exception exception,
List<?Ordered.
ExecutionContext.
ItemStream, just pass the call on,
otherwise reset the peek cache.
RetryPolicy having checked in the cache for an
existing value if the state is not null.
PagingQueryProvider using
database specific features.ApplicationContextFactory that can be used to load a context from an
XML location in a bundle.ParseException based on a message and another exception.
ParseException based on a message.
ExecutionContext.
ExecutionContext instances together with
a unique identifier for each one.
ExecutionContext instances.StepExecution.Partitioner implementations that need to use a
custom naming scheme for partitions.Step which partitions the execution and spreads the
load using a PartitionHandler.FieldExtractor that just returns the original item.FieldSetMapper useful for passing a FieldSet
back directly rather than a mapped object.ItemProcessor that does nothing - simply passes its argument
through to the caller.LineAggregator implementation that simply calls
Object.toString() on the given objectLineMapper useful for passing the original
String back directly rather than a mapped object.PatternMatcher with a map of patterns to values
Classifier that maps from String patterns with wildcards to a set
of values of a given type.LineMapper implementation that stores a mapping of String patterns
to delegate LineTokenizers as well as a mapping of String patterns to
delegate FieldSetMappers.LineTokenizer implementation that stores a mapping of String
patterns to delegate LineTokenizers.ItemReader.read(), without
affecting the result of ItemReader.read().
ItemStream the state is stored for the next call to
SingleItemPeekableItemReader.update(ExecutionContext).
ItemReader that allows the user to look ahead
into the stream of items.TargetSource that lazily initializes its target, replacing bean
definition properties dynamically if they are marked as placeholders.Callable instance provided by the user.PagingQueryProvider using database specific features.Job then register it.
StepExecution as a test context attribute.
SystemExiter so it can be adjusted before
dependency injection.
SimpleChunkProvider.doRead().
Resource instance from
the input, or null if none remain.
ItemReader.read() that just iterates over the
iterator provided.
String value at 'index'.
BigDecimal value at index 'index'.
BigDecimal value from column with given 'name.
BigDecimal value at index 'index',
returning the supplied defaultValue if the trimmed string
value at index 'index' is blank.
BigDecimal value from column with given 'name,
returning the supplied defaultValue if the trimmed string
value at index 'index' is blank.
boolean' value at index 'index'.
boolean' value from column with given 'name'.
boolean' value at index 'index'.
boolean' value from column with given 'name'.
byte' value at index 'index'.
byte' value from column with given 'name'.
char' value at index 'index'.
char' value from column with given 'name'.
java.util.Date value in default format at
designated column index.