|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
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.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.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.
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.
FieldExtractor and
then aggregate them.
AggregateItemReader to
identify the start and end of an aggregate record.FieldSetMapper to one
that returns AggregateItem instances for consumption by the
AggregateItemReader.ItemReader that delivers a list as its item, storing up objects
from the injected ItemReader until they are ready to be packed out as
a collection.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 from a
path supplied, and pulls a bean out when asked to create a Job.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.
Callable<RepeatStatus> to the Tasklet
interface.Chunk.ChunkIterator.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.ListableJobRegistry interface that assumes all
Jobs will be loaded from ClassPathXml resources.RepeatOperations 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.
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.LineTokenizer that delegates the tokenization of a line to one of two potential
tokenizers.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.RetryPolicy that composes a list of other policies and delegates
calls to them in order.ExitStatus
according to injected map.ChunkProcessor.
ChunkProvider.
sql.
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.
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.
CustomerDebitDao object to arbitrary output.FieldSetMapper for mapping to a CustomerUpdate.DataFieldMaxValueIncrementer implementations
based upon a provided string.DataSource that can run scripts on start up and shut
down.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.JobParameters instances using a simple naming
convention for property keys.LineMapper implementation consisting of tokenization of the
line into FieldSet followed by mapping to item.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.
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.
FixedBackOffPolicy.setBackOffPeriod(long).
AbstractItemCountingItemStreamItemReader.doOpen().
PartitionHandler provided.
StepContext lifecycle.
HibernateCursorItemReader.setQueryString(String).
JdbcCursorItemReader.setSql(String) query.
FlowJob.
JobRepositoryFactoryBean.
JdbcCursorItemReader.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.ItemReader with hard-coded input data.ItemWriter which only logs data it receives.RetryPolicy that dynamically adapts to one of a set of injected
policies according to the value of the latest exception.ItemReader that throws exception on a given record number
(useful for testing restart).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 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.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).
FlowParser with the specified name and using the
provided job repository ref.
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.Trade items.RetryContext.
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).
JobOperator.start(String, String).
JobParameters instance.
Message then returns the JMS message ID.
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.
Step from the configuration provided.
PagingQueryProvider instance using the provided properties
and appropriate for the given database type.
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 instances belonging to the
JobExecution with the supplied id, giving details of status,
start and end times etc.
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.
State.
FlowExecutionStatus stored.
TaskExecutor
and wait for all of them to finish before proceeding.
PartitionHandler interface.
JobExecution.
FlatFileItemReader and
FlatFileItemWriter and copy header line from input file to output
file.ItemWriter contract.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.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.
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.ItemWriter extend.ItemWriterException based on a message and another exception.
ItemWriterException based on a message.
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.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.JobParameters in a sequence.JobParametersIncrementer is not
available.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.
ItemWriter that is using a JPA
EntityManagerFactory to merge any Entities that aren't part of the
persistence context.ItemReader for reading database records built on top of JPA.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.JobRegistry.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 static
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.
AggregateItem based on matching the first column in the
input FieldSet to check for begin and end delimiters.
JobExecutionDao.FactoryBean that automates the creation of a
SimpleJobExplorer using in-memory DAO implementations.JobInstanceDao.JobRegistry.FactoryBean that automates the creation of a
SimpleJobRepository using non-persistent in-memory DAO
implementations.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.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.Job is not
available.JobExecution is not
available.JobInstance.Sleeper implementation that just waits on a local Object.SimpleMessageApplicationEvent for open and
close we log the event at INFO level and send a JMX notification if we
are also an MBean.
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.
RetryPolicy having checked in the cache for an
existing value if the state is not null.
PagingQueryProvider using
database specific features.Order objects.Order object to a list of strings.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.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 and ItemWriter.TargetSource that lazily initializes its target, replacing bean
definition properties dynamically if they are marked as placeholders.Player objects to arbitrary output.PlayerSummaryPlayerSummaryPagingQueryProvider using database specific features.Job then register it.
SystemExiter so it can be adjusted before
dependency injection.
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.
java.sql.Date value in given format from column
with given name.
java.util.Date value in default format at
designated column index.
java.sql.Date value in given format from column
with given name.
double' value at index 'index'.
double' value from column with given 'name.
ItemReader needed to be opened before read.ReaderNotOpenException based on a message.
ReaderNotOpenException based on a message and another exception.
float' value at index 'index'.
float' value from column with given 'name.
int' value at index 'index'.
int' value from column with given 'name'.
int' value at index 'index',
using the supplied defaultValue if the field value is
blank.
int' value from column with given 'name',
using the supplied defaultValue if the field value is
blank.
long' value at index 'index'.
long' value from column with given 'name'.
long' value at index 'index',
using the supplied defaultValue if the field value is
blank.
long' value from column with given 'name',
using the supplied defaultValue if the field value is
blank.
String value at index 'index' including
trailing whitespace (don't trim).
String value from column with given 'name'
including trailing whitespace (don't trim).
short' value at index 'index'.
short' value from column with given 'name'.
String value at index 'index'.
String value from column with given 'name'.
LineAggregator that concatenates a collection of
items of a common type with the system line separator.JobFactory that just keeps a reference to a Job.Job at runtime.
StepSynchronizationManager.close() call in a finally block to ensure that the correct
context is available in the enclosing block.
ItemStream as one of the interesting providers under
the provided key.
RepeatOperations implementations to ensure that
RepeatSynchronizationManager.getContext() always returns the correct value.
RetryOperations implementations to ensure that
RetrySynchronizationManager.getContext() always returns the correct value.
JobExecutionListener
callbacks.
ItemStream for callbacks to the stream
interface.
RetryContext, and
also increment the retry count if the throwable is non-null.
JobExecution instances, and all associated
JobInstance and StepExecution instances from the standard
RDBMS locations used by Spring Batch.
JobExecution instances, and all associated
JobInstance and StepExecution instances from the standard
RDBMS locations used by Spring Batch.
RepeatContextCounter.
RepeatContextSupport.
RepeatTemplate.RepeatListener.MethodInterceptor that can be used to automatically repeat calls to
a method on a service.RepeatOperations.ExitStatus.
ItemReaders that implement ItemStream and read
input from Resource.ItemWriters that implement ItemStream and write
output to Resource.JobExecution.
ExceptionHandler that rethrows when exceptions of a
given type reach a threshold.RetryOperations.RetryContext instances.RetryListener.RetryOperations to
execute operations with configurable retry behaviour.MethodInterceptor that can be used to automatically retry calls to
a method on a service if it fails.RetryPolicy is responsible for allocating and managing resources
needed by RetryOperations.Job and JobParameters
.
JobParameters.
BackOffPolicy.
BackOffPolicy.
Step when it is created.
BundleContext for creating a job application context
later.
Callable.
CompletionPolicy applying to the chunk
level.
CompletionPolicy.
custom editors to register.
CustomerCreditDao.
LineTokenizer that will be used to tokenize any lines that begin with
A, U, or D, and are thus a customer operation.
DataSource.
DataSource.
DateFormat to use for parsing numbers.
DateFormat to use for parsing numbers.
Classifier annotation on a method in the supplied delegate and use that
to create a Classifier from the parameter type to the return
type.
LineAggregator to use on single items, that
are not Strings.
ResultSet.
Classifier used by this handler.
ExceptionHandler.
ExecutionContext for this execution
ExecutionContext for this execution
RetryCallback.
ExitCodeMapper.
ExitStatus for this contribution.
ResultSet object.
ResultSet object.
ResultSet object.
FieldSet instances.
LineTokenizer that will be used to tokenize any lines that being with
F and is thus a footer record.
StepExecutionSplitter in the
TaskExecutorPartitionHandler.handle(StepExecutionSplitter, StepExecution) method, instructing
it how many StepExecution instances are required, ideally.
HibernateOperations property.
StepInterruptionPolicy.
true tasklet will attempt to interrupt the thread
executing the system command if SystemCommandTasklet.setTimeout(long) has been
exceeded or user interrupts the job.
ItemPreparedStatementSetter.
ItemSqlParameterSourceProvider.
DataFieldMaxValueIncrementer to be used when
generating primary keys for JobExecution instances.
JobExecutionListeners.
JobExplorer.
JobExplorer.
DataFieldMaxValueIncrementer to be used when
generating primary keys for JobInstance instances.
JobLauncher.
JobLauncher.
JobLocator to find a job to run.
JobLocator.
JobParametersConverter.
JobParametersConverter.
JobParametersIncrementer.
JobRegistry to use for all the bind and
unbind events.
JobRegistry.
ListableJobRegistry.
JobRepository that is needed to manage the
state of the batch meta domain (jobs, steps, executions) during the life
of a job.
JobRepository.
JobRepository.
KeyGenerator to use to identify failed items across rollback.
KeyGenerator to use to identify failed items across rollback.
ExecutionContext.
JobParameters that will contain a commit interval.
JobLauncher.
LineAggregator.
StepListeners with the handler.
StepListeners with the handler.
Step.
ExecutionContext instances.
ResultSet object can contain to the given number.
ExecutionContext.
NewMethodArgumentsIdentifier.
NumberFormat.
NumberFormat to use for parsing numbers.
NumberFormat to use for parsing numbers.
PartitionHandler.
ApplicationContext.
BeanWrapperFieldSetMapper.mapFieldSet(FieldSet).
Statement object to execute to the given number of seconds.
MethodInvocationRecoverer to use if the retry is
exhausted.
JobRegistry.
RepeatOperations.
RetryContextCache.
RetryListeners.
RetryPolicy.
ExecutionContext during the ItemStream call to
update.
ExecutionContext during the ItemStream call to
update.
ExecutionContext.
JdbcOperations.
Sleeper strategy.
Sleeper strategy.
SqlMapClient for injection purposes.
SqlMapClientTemplate.
Step that will be used to execute the partitioned
StepExecution.
StepExecutionSplitter.
RepeatOperations to use for the outer loop of the batch
processing.
Step.
ExecutionContext.
AbstractItemCountingItemStreamItemReader.open(org.springframework.batch.item.ExecutionContext) if the
input resource does not exist.
AbstractItemCountingItemStreamItemReader.open(org.springframework.batch.item.ExecutionContext) if the
input resource does not exist.
SystemExiter.
TaskExecutor that is used to farm out step
executions to multiple threads.
TaskExecutor.
Tasklet.
CompletionPolicy.
TransactionAttribute.
PlatformTransactionManager.
PlatformTransactionManager.
PlatformTransactionManager.
RetryCallback.
ChunkProcessor interface that handles
basic item writing and processing.ItemReader.Flow that branches conditionally depending on the exit status of
the last State.Job interface providing the ability to run a
JobExecution.JobExplorer using the injected DAOs.JobLauncher interface.JobRepository that stores JobInstances,
JobExecutions, and StepExecutions using the injected DAOs.ExitCodeMapper that can be configured through a
map from batch exit codes (String) to integer results.SimpleLimitExceptionHandler to
set the limit.
SimpleLimitExceptionHandler.
MethodInvoker interface that invokes a
method on an object.Partitioner.RecordSeparatorPolicy - treats all lines as record
endings.ResourceSuffixCreator that uses the index
itself as suffix, separated by dot.ExceptionHandler that is aware of the retry context so that it can
distinguish between a fatal exception and one that can be retried.SimpleRetryPolicy with the default number of retry
attempts.
SimpleRetryPolicy with the specified number of retry
attempts, and default exceptions to retry.
StepExecutionSplitter that delegates to a
Partitioner to generate ExecutionContext instances.SimpleStepExecutionSplitter from its mandatory
properties.
SimpleStepFactoryBean.
SystemProcessExitCodeMapper implementation that performs following mapping:
0 -> ExitStatus.FINISHED
else -> ExitStatus.FAILEDSkipListener implementations.RetryContextCache.SoftReferenceMapRetryContextCache with default capacity.
StepExecution into a set of parallel
executable instances with the same parent JobExecution.
FlowParser using the provided job repository ref.
State implementation that splits a Flow into multiple
parallel subflows.Validator interface to
Validator.PagingQueryProvider interface.PagingQueryProvider using
database specific features.ItemReader implementing the process indicator
pattern.ItemReader implementing the process indicator
pattern.ItemWriter implementing the process indicator pattern.RepeatContextSupport and return it.
CompletionPolicy.
BackOffContext configured
with the 'expSeed' and 'increment' values.
null'.
JobInstance determined by the
JobParametersIncrementer attached to the specified job.
MethodInterceptor that can be used to automatically retry calls to
a method on a service if it fails.BackOffPolicy implementations that maintain no
state across invocations.State to
another.ItemWriter which uses StAX and
Marshaller for serializing object to XML.StepContext.StepContext for this
StepExecution.
ContextFactory that provides the current
StepContext as a context object.Step.StepExecution, buffering changes until
they can be applied at a chunk boundary.StepExecution instances
into a single result.StepExecution as an argument and
publishes notifications in the form of ApplicationEvent.Step.CompletionPolicy that picks up a commit interval from
JobParameters by listening to the start of a step.Step as a convenience for callers who need
access to the underlying instance.StepExecutionListener,
ChunkListener, ItemReadListener and
ItemWriteListenerAbstractListenerFactoryBean implementation is used to create a
StepListener.StepListener meta data, which ties together the names
of methods, their interfaces, annotation, and expected arguments.StepListener implementations.Step instance by name.Job.Step is not step scope aware (i.e. not the ones
provided by the framework).State implementation that delegates to a FlowExecutor to
execute the specified Step.JobExecution to stop.
JobExecution with the supplied id.
Classifier for a parameterised object type based on a map.SubclassClassifier with null default value.
SubclassClassifier with supplied default value.
SubclassClassifier with supplied default value.
RecordSeparatorPolicy that looks for an exact match for a String at
the end of a line (e.g. a semicolon).PagingQueryProvider using
database specific features.AttributeAccessor that synchronizes on a mutex (not this) before
modifying or accessing the underlying attributes.Tasklet that executes a system command.PartitionHandler that uses a TaskExecutor to execute the
partitioned Step locally in multiple threads.RepeatOperations support including interceptors that can be
used to modify or monitor the behaviour at run time.Tasklet,
possibly repeated, and each call surrounded by a transaction.ResultQueue that throttles the number of
expected results, limiting it to a maximum at any given time.RetryPolicy that allows a retry only if it hasn't timed out.TimeoutTerminationPolicy with the specified timeout
value (in milliseconds).
line.
line.
CompletionPolicy if set, otherwise
returns the value of StepExecutionSimpleCompletionPolicy.setKeyName(String).
Writer that delays actually writing to the buffer if a
transaction is active.JobFactory provided and unregister it with the
JobRegistry.
UnexpectedInputException based on a message.
UnexpectedInputException based on a message and another exception.
Job.
JobExecution (but not its ExecutionContext).
StepExecution (but not its ExecutionContext).
ExecutionContext.
ExecutionContext provider for the contributions
registered under the given key.
CompletionPolicy.
ExecutionContexts of the given
StepExecution.
ExecutionContext of the given
JobExecution.
JobExecution.
StepExecution if necessary.
ItemProcessor that validates input and
returns it without modifications.ValidationException based on a message and another exception.
ValidationException based on a message.
SimpleChunkProcessor.doWrite(List) method and
increments the write count in the contribution.
ItemWriter instances according to their
classification by the Classifier.
XMLEventWriter.
WriteFailedException based on a message and another
exception.
WriteFailedException based on a message.
Writer.
Writer.
ItemWriter needed to be opened before being
written to..WriterNotOpenException based on a message.
WriterNotOpenException based on a message and another exception.
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||