|
||||||||||
| 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.
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.
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.
StepExecution instances
when the input comes from remote steps, so the data need to be refreshed from
the repository.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.ItemReader which produces Resource instances from an array.JobExecution.
ResultQueue that throttles the number of
expected results, limiting it to a maximum at any given time.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.
events come from the expected source.
BackOffPolicy.
BackOffPolicy.
Step when it is created.
BufferedReader that will be used to extract lines from the file.
BundleContext for creating a job application context
later.
Callable.
CompletionPolicy applying to the chunk
level.
CompletionPolicy.
custom editors to register.
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.
HibernateQueryProvider.
EntityManager for the query to be built.
Classifier used by this handler.
ExceptionHandler.
ExecutionContext for this execution
ExecutionContext for this execution
RetryCallback.
ExitCodeMapper.
ExitStatus for this contribution.
ResultSet object.
ResultSet object.
FieldSet instances.
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.
JavaMailSender to be used to send messages in MimeMessageItemWriter.write(List).
Job to delegate to in this step.
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 is required to be able to run the enclosed
Job.
JobLauncher instance that can be used to launch jobs.
JobLocator to find a job to run.
JobParametersConverter.
JobParametersConverter.
JobParametersExtractor is used to extract
JobParametersExtractor from the StepExecution to run the
Job.
JobParametersIncrementer.
JobRegistry to use for jobs created.
JobRegistry to use for all the bind and
unbind events.
JobRegistry.
ListableJobLocator.
JobRepository that is needed to manage the
state of the batch meta domain (jobs, steps, executions) during the life
of a job.
JobRepository.
JobRepository.
JobRepository to use for creating new JobExecution
instances.
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.
MailSender to be used to send messages in SimpleMailMessageItemWriter.write(List).
ResultSet object can contain to the given number.
ExecutionContext.
NewMethodArgumentsIdentifier.
NumberFormat.
NumberFormat to use for parsing numbers.
NumberFormat to use for parsing numbers.
Partitioner that will be used to generate step execution meta
data for the target step.
PartitionHandler which can send out step executions for remote
processing and bring back the results.
ItemProcessor is transactional (defaults to
true).
BeanWrapperFieldSetMapper.mapFieldSet(FieldSet).
PagingQueryProvider.
Statement object to execute to the given number of seconds.
MethodInvocationRecoverer to use if the
retry is exhausted.
RepeatOperations.
ApplicationContext.
ClassPathXmlApplicationContextFactory.
RetryContextCache.
RetryListeners.
RetryPolicy.
ExecutionContext during the ItemStream call to
update.
ExecutionContext during
the ItemStream call to update.
ExecutionContext.
Session that can be used as a factory for queries.
SHORT_CONTEXT.
JdbcOperations.
SkipPolicy that determines the outcome of an exception when
processing an item.
Sleeper strategy.
Sleeper strategy.
SqlMapClient for injection purposes.
SqlMapClientTemplate.
StatelessSession that can be used as a factory for
queries.
Step that will be used to execute the partitioned
StepExecution.
StepExecutionAggregator that can aggregate step executions when
they come back from the handler.
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.
MultiResourceItemReader.open(org.springframework.batch.item.ExecutionContext) if there are no resources to read.
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.
BufferedReaderFactory useful for reading simple binary (or text)
files with no line endings, such as those produced by mainframe copy books.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.
ItemWriter that can send mail messages.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.
StepExecutionSplitter that delegates to a
Partitioner to generate ExecutionContext instances.SimpleStepExecutionSplitter from its mandatory
properties.
SimpleStepExecutionSplitter.SimpleStepExecutionSplitter(JobRepository, boolean, String, Partitioner) instead
SimpleStepFactoryBean.
StepHandler that manages repository and restart
concerns.SystemProcessExitCodeMapper implementation that performs following mapping:
0 -> ExitStatus.FINISHED
else -> ExitStatus.FAILEDPeekableItemReader that allows the user to peek one item ahead.SkipListener implementations.RetryContextCache.SoftReferenceMapRetryContextCache with default capacity.
StepExecution into a set of parallel
executable instances with the same parent JobExecution.
InlineFlowParser 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.JobLoader.
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.StepExecution and some of its associated properties using expressions
based on bean paths.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.Step.CompletionPolicy that picks up a commit interval from
JobParameters by listening to the start of a step.Step on behalf of a Job.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 interfaces.Step instance by name.Job.Step is not step scope aware (i.e. not the ones
provided by the framework).TestExecutionListener that sets up step-scope context for
dependency injection into unit tests.StepScope in unit tests.State implementation that delegates to a FlowExecutor to
execute the specified Step.JobLoader.clear().
JobExecution to stop.
JobExecution with the supplied id.
ResultSet.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 or closing 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.
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 | |||||||||