# All Classes and Interfaces

Class
Description
AbstractApplicationContextFactory
`ApplicationContextFactory` implementation that takes a parent context and a path to the context to create.
AbstractBatchConfiguration
Base `Configuration` class providing common structure for enabling and using Spring Batch.
AbstractCursorItemReader<T>
Abstract base class for any simple item reader that opens a database cursor and continually retrieves the next row in the ResultSet.
AbstractFileItemWriter<T>
Base class for item writers that write data to a file or stream.
AbstractFlowParser
AbstractHibernateQueryProvider<T>
Abstract Hibernate Query Provider to serve as a base class for all Hibernate `Query` providers.
AbstractItemCountingItemStreamItemReader<T>
Abstract superclass for `ItemReader`s that supports restart by storing item count in the `ExecutionContext` (therefore requires item ordering to be preserved between runs).
AbstractItemStreamItemReader<T>
Base class for `ItemReader` implementations.
AbstractItemStreamItemWriter<T>
Base class for `ItemWriter` implementations.
AbstractJdbcBatchMetadataDao
Encapsulates common functionality needed by JDBC batch metadata DAOs - provides jdbcTemplate for subclasses and handles table prefixes.
AbstractJob
Abstract implementation of the `Job` interface.
AbstractJobExplorerFactoryBean
A `FactoryBean` that automates the creation of a `SimpleJobExplorer`.
AbstractJobRepositoryFactoryBean
A `FactoryBean` that automates the creation of a `SimpleJobRepository`.
AbstractJpaQueryProvider
Abstract JPA Query Provider to serve as a base class for all JPA `Query` providers.
AbstractLineTokenizer
Abstract class handling common concerns of various `LineTokenizer` implementations such as dealing with names and actual construction of `FieldSet`
AbstractListenerFactoryBean<T>
`FactoryBean` implementation that builds a listener based on the various lifecycle methods or annotations that are provided.
AbstractListenerParser
AbstractMethodInvokingDelegator<T>
Superclass for delegating classes which dynamically call a custom method of injected object.
AbstractMethodInvokingDelegator.InvocationTargetThrowableWrapper
Used to wrap a `Throwable` (not an `Exception`) thrown by a reflectively-invoked delegate.
AbstractPaginatedDataItemReader<T>
A base class that handles basic reading logic based on the paginated semantics of Spring Data's paginated facilities.
AbstractPagingItemReader<T>
Abstract `ItemStreamReader` for to extend when reading database records in a paging fashion.
AbstractPartitionHandler
Base `PartitionHandler` implementation providing common base features.
AbstractSqlPagingQueryProvider
Abstract SQL Paging Query Provider to serve as a base class for all provided SQL paging query providers.
AbstractState
AbstractStep
A `Step` implementation that provides common behavior to subclasses, including registering and calling listeners.
AbstractStepParser
Internal parser for the <step/> elements inside a job.
AbstractTaskletStepBuilder<B extends AbstractTaskletStepBuilder<B>>
Base class for step builders that want to build a `TaskletStep`.
AfterChunk
Marks a method to be called after a chunk is executed.
Expected signature: void afterChunk(ChunkContext context)
AfterChunkError
Marks a method to be called after a has failed and been marked for rollback.
Expected signature: void afterFailedChunk(ChunkContext context)
AfterJob
Marks a method to be called after a `Job` has completed.
AfterProcess
Marks a method to be called after an item is passed to an `ItemProcessor`
Expected signature: void afterProcess(T item, S result)
AfterRead
Marks a method to be called after an item is read from an `ItemReader`
Expected signature: void afterRead(T item)
AfterStep
Marks a method to be called after a `Step` has completed.
AfterWrite
Marks a method to be called after an item is passed to an `ItemWriter`
Expected signature: void afterWrite(`List`<? extends S> items)
AlwaysSkipItemSkipPolicy
Implementation of the `SkipPolicy` interface that will always return that an item should be skipped.
AmqpItemReader<T>
AMQP `ItemReader` implementation using an `AmqpTemplate` to receive and/or convert messages.
AmqpItemReaderBuilder<T>
A builder implementation for the `AmqpItemReader`
AmqpItemWriter<T>
AMQP `ItemWriter` implementation using an `AmqpTemplate` to send messages.
AmqpItemWriterBuilder<T>
A builder implementation for the `AmqpItemWriter`
AnnotationMethodResolver
`MethodResolver` implementation that finds a single Method on the given Class that contains the specified annotation type.
ApplicationContextFactory
Factory for the creation of `ApplicationContext`s.
ApplicationContextJobFactory
A `JobFactory` that creates its own `ApplicationContext` and pulls a bean out when asked to create a `Job`.
ArrayFieldSetMapper
A basic array mapper, returning the values backing a fieldset.
AssertFile
This class can be used to assert that two files are the same.
AsynchronousFailureException
Exception indicating that a failure or early completion condition was detected in a remote worker.
AsyncItemProcessor<I,O>
An `ItemProcessor` that delegates to a nested processor and in the background.
AsyncItemWriter<T>
AutomaticJobRegistrar
Loads and unloads `Jobs` when the application context is created and destroyed.
AvroItemReader<T>
An `ItemReader` that deserializes data from a `Resource` containing serialized Avro objects.
AvroItemReaderBuilder<T>
A builder implementation for the `AvroItemReader`.
AvroItemWriter<T>
An `ItemWriter` that serializes data to an `WritableResource` using Avro.
AvroItemWriterBuilder<T>
A builder implementation for the `AvroItemWriter`.
BatchConfigurationException
Represents an error has occurred in the configuration of base batch infrastructure (creation of a `JobRepository` for example.
BatchConfigurationSelector
Base `Configuration` class providing common structure for enabling and using Spring Batch.
BatchConfigurer
Strategy interface for users to provide as a factory for custom components needed by a Batch system.
BatchIntegrationConfiguration
Base configuration class for Spring Batch Integration factory beans.
BatchIntegrationNamespaceHandler
The namespace handler for the Spring Batch Integration namespace.
BatchMetrics
Central class for batch metrics.
BatchRetryTemplate
A special purpose retry template that deals specifically with multi-valued stateful retry.
BatchScopeSupport
ScopeSupport.
BatchScopeSupport.Scopifier
Helper class to scan a bean definition hierarchy and force the use of auto-proxy for step scoped beans.
BatchStatus
Enumeration representing the status of an Execution.
BatchTestContextCustomizer
`ContextCustomizer` implementation that adds batch test utility classes (`JobLauncherTestUtils` and `JobRepositoryTestUtils`) as beans in the test context.
BatchTestContextCustomizerFactory
Factory for `BatchTestContextCustomizer`.
BeanDefinitionUtils
BeanFactoryStepLocator
A `StepLocator` implementation that just looks in its enclosing bean factory for components of type `Step`.
BeanPropertyItemSqlParameterSourceProvider<T>
A convenient implementation for providing BeanPropertySqlParameterSource when the item has JavaBean properties that correspond to names used for parameters in the SQL statement.
BeanValidatingItemProcessor<T>
A `ValidatingItemProcessor` that uses the Bean Validation API (JSR-303) to validate items.
BeanWrapperFieldExtractor<T>
This is a field extractor for a java bean.
BeanWrapperFieldSetMapper<T>
`FieldSetMapper` implementation based on bean property paths.
BeforeChunk
Marks a method to be called before a chunk is executed.
BeforeJob
Marks a method to be called before a `Job` is executed, which comes after a `JobExecution` is created and persisted, but before the first `Step` is executed.
BeforeProcess
Marks a method to be called before an item is passed to an `ItemProcessor`
Expected signature: void beforeProcess(T item)
BeforeRead
Marks a method to be called before an item is read from an `ItemReader`
Expected signature: void beforeRead()
BeforeStep
Marks a method to be called before a `Step` is executed, which comes after a `StepExecution` is created and persisted, but before the first item is read.
BeforeWrite
Marks a method to be called before an item is passed to an `ItemWriter`
Expected signature: void beforeWrite(`List`<? extends S> items)
BufferedReaderFactory
A factory strategy for custom extensions of `BufferedReader` allowing customisation of the standard behaviour of the `java.io` variety.
CallableTaskletAdapter
Adapts a `Callable`<`RepeatStatus`> to the `Tasklet` interface.
Chunk<W>
Encapsulation of a list of items to be processed and possibly a list of failed items to be skipped.
ChunkContext
Context object for weakly typed data stored for the duration of a chunk (usually a group of items processed together in a transaction).
ChunkElementParser
Internal parser for the <chunk/> element inside a step.
ChunkHandler<T>
Interface for a remote worker in the Remote Chunking pattern.
ChunkListener
Listener interface for the lifecycle of a chunk.
ChunkListenerSupport
Deprecated.
as of 5.0, in favor of the default methods on the `ChunkListener`
ChunkMessageChannelItemWriter<T>
ChunkMonitor
Manage the offset data between the last successful commit and updates made to an input chunk.
ChunkMonitor.ChunkMonitorData
ChunkOrientedTasklet<I>
A `Tasklet` implementing variations on read-process-write item handling.
ChunkProcessor<I>
Interface defined for processing `Chunk`s.
ChunkProcessorChunkHandler<S>
A `ChunkHandler` based on a `ChunkProcessor`.
ChunkProvider<T>
Interface for providing `Chunk`s to be processed, used by the `ChunkOrientedTasklet`
ChunkRequest<T>
Encapsulation of a chunk of items to be processed remotely as part of a step execution.
ChunkResponse
Encapsulates a response to processing a chunk of items, summarising the result as a `StepContribution`.
Classifier
Mark a method as capable of classifying its input to an instance of its output.
ClassifierCompositeItemProcessor<I,O>
Calls one of a collection of ItemProcessors, based on a router pattern implemented through the provided `Classifier`.
ClassifierCompositeItemProcessorBuilder<I,O>
Creates a fully qualified `ClassifierCompositeItemProcessor`.
ClassifierCompositeItemWriter<T>
Calls one of a collection of ItemWriters for each item, based on a router pattern implemented through the provided `Classifier`.
ClassifierCompositeItemWriterBuilder<T>
Creates a fully qualified ClassifierCompositeItemWriter.
ClasspathXmlApplicationContextsFactoryBean
A convenient factory for creating a set of `ApplicationContextFactory` components from a set of `resources`.
ColumnMapItemPreparedStatementSetter
Implementation of the `ItemPreparedStatementSetter` interface that assumes all keys are contained within a `Map` with the column name as the key.
CommandLineJobRunner
Basic launcher for starting jobs from the command line.
CompletionPolicy
Interface for batch completion policies, to enable batch operations to strategise normal completion conditions.
CompletionPolicySupport
Very simple base class for `CompletionPolicy` implementations.
CompositeChunkListener
CompositeCompletionPolicy
Composite policy that loops through a list of delegate policies and answers calls by a consensus.
CompositeExceptionHandler
Composite `ExceptionHandler` that loops though a list of delegates.
CompositeItemProcessListener<T,S>
CompositeItemProcessor<I,O>
Composite `ItemProcessor` that passes the item through a sequence of injected `ItemTransformer`s (return value of previous transformation is the entry value of the next).
Note the user is responsible for injecting a chain of `ItemProcessor`s that conforms to declared input and output types.
CompositeItemProcessorBuilder<I,O>
Creates a fully qualified `CompositeItemProcessorBuilder`.
CompositeItemReadListener<T>
CompositeItemStream
Simple `ItemStream` that delegates to a list of other streams.
CompositeItemWriteListener<S>
CompositeItemWriter<T>
Calls a collection of `ItemWriter`s in fixed-order sequence.
The implementation is thread-safe if all delegates are thread-safe.
CompositeItemWriterBuilder<T>
Creates a fully qualified CompositeItemWriter.
CompositeJobExecutionListener
CompositeJobParametersValidator
Composite `JobParametersValidator` that passes the job parameters through a sequence of injected `JobParametersValidator`s
CompositeRepeatListener
Allows a user to register one or more RepeatListeners to be notified on batch events.
CompositeSkipListener<T,S>
CompositeSkipPolicy
CompositeStepExecutionListener
ConfigurableSystemProcessExitCodeMapper
Maps exit codes to `ExitStatus` according to injected map.
ConversionException
CoreNamespaceHandler
CoreNamespacePostProcessor
Post-process jobs and steps defined using the batch namespace to inject dependencies.
CoreNamespaceUtils
Utility methods used in parsing of the batch core namespace
CountingCompletionPolicy
Abstract base class for policies that need to count the number of occurrences of some event (e.g.
DatabaseType
Enum representing a database type, such as DB2 or oracle.
DataFieldMaxValueIncrementerFactory
Factory for creating `DataFieldMaxValueIncrementer` implementations based upon a provided string.
DataFieldMaxValueJobParametersIncrementer
This incrementer uses a `DataFieldMaxValueIncrementer` to generate the sequence of values to use as job instance discriminator.
DataSourceInitializer
Wrapper for a `DataSource` that can run scripts on start up and shut down.
Db2PagingQueryProvider
DB2 implementation of a `PagingQueryProvider` using database specific features.
DecisionParser
Internal parser for the <decision/> elements inside a job.
DecisionState
State that requires a decider to make the status decision.
DefaultBatchConfigurer
DefaultBufferedReaderFactory
DefaultDataFieldMaxValueIncrementerFactory
Default implementation of the `DataFieldMaxValueIncrementerFactory` interface.
DefaultExceptionHandler
Default implementation of `ExceptionHandler` - just re-throws the exception it encounters.
DefaultExecutionContextSerializer
An implementation of the `ExecutionContextSerializer` using the default serialization implementations from Spring (`DefaultSerializer` and `DefaultDeserializer`).
DefaultFieldSet
Default implementation of `FieldSet` using Java using Java primitive and standard types and utilities.
DefaultFieldSetFactory
Default implementation of `FieldSetFactory` with no special knowledge of the `FieldSet` required.
DefaultFragmentEventReader
Default implementation of `FragmentEventReader`
DefaultItemFailureHandler
Default implementation of the `ItemListenerSupport` class that writes all exceptions via commons logging.
DefaultJobKeyGenerator
Default implementation of the `JobKeyGenerator` interface.
DefaultJobLoader
Default implementation of `JobLoader`.
DefaultJobParametersConverter
Converter for `JobParameters` instances using a simple naming convention for property keys.
DefaultJobParametersExtractor
Simple implementation of `JobParametersExtractor` which pulls parameters with named keys out of the step execution context and the job parameters of the surrounding job.
DefaultJobParametersValidator
Default implementation of `JobParametersValidator`.
DefaultLineMapper<T>
Two-phase `LineMapper` implementation consisting of tokenization of the line into `FieldSet` followed by mapping to item.
DefaultMailErrorHandler
This `MailErrorHandler` implementation simply rethrows the exception it receives.
DefaultPropertyEditorRegistrar
A re-usable `PropertyEditorRegistrar` that can be used wherever one needs to register custom `PropertyEditor` instances with a `PropertyEditorRegistry` (like a bean wrapper, or a type converter).
DefaultRecordSeparatorPolicy
A `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.
DefaultResultCompletionPolicy
Very simple `CompletionPolicy` that bases its decision on the result of a batch operation.
DefaultStateTransitionComparator
Sorts by decreasing specificity of pattern, based on just counting wildcards (with * taking precedence over ?).
DefaultStepExecutionAggregator
Convenience class for aggregating a set of `StepExecution` instances into a single result.
DelegateStep
Provides a wrapper for an existing `Step`, delegating execution to it, but serving all other operations locally.
DelimitedLineAggregator<T>
A `LineAggregator` implementation that converts an object into a delimited list of strings.
DelimitedLineTokenizer
A `LineTokenizer` implementation that splits the input String on a configurable delimiter.
DerbyPagingQueryProvider
Derby implementation of a `PagingQueryProvider` using standard SQL:2003 windowing functions.
DirectPoller<S>
A `Poller` that uses the callers thread to poll for a result as soon as it is asked for.
DuplicateJobException
Checked exception that indicates a name clash when registering `Job` instances.
DynamicMethodInvocationException
Indicates an error has been encountered while trying to dynamically invoke a method e.g.
EnableBatchIntegration
Enable Spring Batch Integration features and provide a base configuration for setting up remote chunking or partitioning infrastructure beans.
EnableBatchProcessing
Enable Spring Batch features and provide a base configuration for setting up batch jobs in an @Configuration class, roughly equivalent to using the `<batch:*>` XML namespace.
EndState
`State` implementation for ending a job if it is in progress and continuing if just starting.
Entity
Batch Domain Entity class.
ExceptionClassifierSkipPolicy
A `SkipPolicy` that depends on an exception classifier to make its decision, and then delegates to the classifier result.
ExceptionElementParser
ExceptionHandler
Handler to allow strategies for re-throwing exceptions.
ExecutionContext
Object representing a context for an `ItemStream`.
ExecutionContextDao
DAO interface for persisting and retrieving `ExecutionContext`s.
ExecutionContextPromotionListener
This class can be used to automatically promote items from the `Step` `ExecutionContext` to the `Job` `ExecutionContext` at the end of a step.
ExecutionContextSerializer
A composite interface that combines both serialization and deserialization of an execution context into a single implementation.
ExecutionContextTestUtils
Convenience class for accessing `ExecutionContext` values from job and step executions.
ExecutionContextUserSupport
Facilitates assigning names to objects persisting data in `ExecutionContext` and generating keys for `ExecutionContext` based on the name.
ExitCodeMapper
This interface should be implemented when an environment calling the batch framework has specific requirements regarding the operating system process return status.
ExitStatus
Value object used to carry information about the status of a job or step execution.
ExtendedConnectionDataSourceProxy
Implementation of `SmartDataSource` that is capable of keeping a single JDBC Connection which is NOT closed after each use even if `Connection.close()` is called.
ExtractorLineAggregator<T>
An abstract `LineAggregator` implementation that utilizes a `FieldExtractor` to convert the incoming object to an array of its parts.
FatalStepExecutionException
FaultTolerantChunkProcessor<I,O>
FaultTolerant implementation of the `ChunkProcessor` interface, that allows for skipping or retry of items that cause exceptions during writing.
FaultTolerantChunkProvider<I>
FaultTolerant implementation of the `ChunkProcessor` interface, that allows for skipping or retry of items that cause exceptions during reading or processing.
FaultTolerantStepBuilder<I,O>
A step builder for fully fault tolerant chunk-oriented item processing steps.
FaultTolerantStepFactoryBean<T,S>
Factory bean for step that provides options for configuring skip behavior.
FieldExtractor<T>
This class will convert an object to an array of its parts.
FieldSet
Interface used by flat file input sources to encapsulate concerns of converting an array of Strings to Java native types.
FieldSetFactory
Factory interface for creating `FieldSet` instances.
FieldSetMapper<T>
Interface that is used to map data obtained from a `FieldSet` into an object.
FileUtils
Utility methods for files used in batch processing.
FixedLengthTokenizer
Tokenizer used to process data obtained from files with fixed-length format.
FlatFileFooterCallback
Callback interface for writing a footer to a file.
FlatFileFormatException
Exception indicating that some type of error has occurred while attempting to parse a line of input into tokens.
FlatFileHeaderCallback
Callback interface for writing a header to a file.
FlatFileItemReader<T>
Restartable `ItemReader` that reads lines from input `FlatFileItemReader.setResource(Resource)`.
FlatFileItemReaderBuilder<T>
A builder implementation for the `FlatFileItemReader`.
FlatFileItemReaderBuilder.DelimitedBuilder<T>
A builder for constructing a `DelimitedLineTokenizer`
FlatFileItemReaderBuilder.FixedLengthBuilder<T>
A builder for constructing a `FixedLengthTokenizer`
FlatFileItemWriter<T>
This class is an item writer that writes data to a file or stream.
FlatFileItemWriterBuilder<T>
A builder implementation for the `FlatFileItemWriter`
FlatFileItemWriterBuilder.DelimitedBuilder<T>
A builder for constructing a `DelimitedLineAggregator`
FlatFileItemWriterBuilder.FormattedBuilder<T>
A builder for constructing a `FormatterLineAggregator`.
FlatFileParseException
Exception thrown when errors are encountered parsing flat files.
Flow
FlowBuilder<Q>
A builder for a flow of steps that can be executed as a job or as part of a job.
FlowBuilder.SplitBuilder<Q>
A builder for building a split state.
FlowBuilder.TransitionBuilder<Q>
A builder for transitions within a flow.
FlowBuilder.UnterminatedFlowBuilder<Q>
A builder for continuing a flow from a decision state.
FlowBuilderException
FlowElementParser
Internal parser for the <flow/> elements inside a job.
FlowExecution
FlowExecutionAggregator
Strategy interface for aggregating `FlowExecution` instances into a single exit status.
FlowExecutionException
FlowExecutionStatus
Represents the status of `FlowExecution`.
FlowExecutor
Context and execution strategy for `FlowJob` to allow it to delegate its execution step by step.
FlowHolder
Convenient interface for components that contain nested flows.
FlowJob
Implementation of the `Job` interface that allows for complex flows of steps, rather than requiring sequential execution.
FlowJobBuilder
A job builder for `FlowJob` instances.
FlowState
State that delegates to a Flow
FlowStep
A `Step` implementation that delegates to a `Flow`.
FlowStepBuilder
A step builder for `FlowStep` instances.
FlushFailedException
Unchecked exception indicating that an error has occurred while trying to flush a buffer.
ForceRollbackForWriteSkipException
Fatal exception to be thrown when a rollback must be forced, typically after catching an exception that otherwise would not cause a rollback.
FormatterLineAggregator<T>
A `LineAggregator` implementation which produces a String by aggregating the provided item via the `Formatter` syntax.
FragmentEventReader
Interface for event readers which support treating XML fragments as standalone XML documents by wrapping the fragments with StartDocument and EndDocument events.
FunctionItemProcessor<I,O>
An `ItemProcessor` implementation that delegates to a `Function`
GemfireItemWriter<K,V>
An `ItemWriter` that stores items in GemFire
GemfireItemWriterBuilder<K,V>
A builder implementation for the `GemfireItemWriter`
GenericApplicationContextFactory
`ApplicationContextFactory` implementation that takes a parent context and a path to the context to create.
GroupAwareJob
A `Job` that can optionally prepend a group name to another job's name, to make it fit a naming convention for type or origin.
GsonJsonObjectMarshaller<T>
A json object marshaller that uses Google Gson to marshal an object into a json representation.
GsonJsonObjectReader<T>
Implementation of `JsonObjectReader` based on Google Gson.
H2PagingQueryProvider
H2 implementation of a `PagingQueryProvider` using database specific features.
HibernateCursorItemReader<T>
`ItemStreamReader` for reading database records built on top of Hibernate.
HibernateCursorItemReaderBuilder<T>
This is a builder for the `HibernateCursorItemReader`.
HibernateItemReaderHelper<T>
Internal shared state helper for hibernate readers managing sessions and queries.
HibernateItemWriter<T>
`ItemWriter` that uses a Hibernate session to save or update entities that are not part of the current Hibernate session.
HibernateItemWriterBuilder<T>
A builder for the `HibernateItemWriter`
HibernateNativeQueryProvider<E>
This query provider creates Hibernate `Query`s from injected native SQL queries.
HibernatePagingItemReader<T>
`ItemReader` for reading database records built on top of Hibernate and reading only up to a fixed number of items at a time.
HibernatePagingItemReaderBuilder<T>
A builder for the `HibernatePagingItemReader`.
HibernateQueryProvider<T>
Interface defining the functionality to be provided for generating queries for use with Hibernate `ItemReader`s or other custom built artifacts.
HippyMethodInvoker
A `MethodInvoker` that is a bit relaxed about its arguments.
HsqlPagingQueryProvider
HSQLDB implementation of a `PagingQueryProvider` using database specific features.
IncorrectLineLengthException
Exception indicating that the line size expected is different from what is expected.
IncorrectTokenCountException
Exception indicating that an incorrect number of tokens have been found while parsing a file.
InlineFlowParser
InlineStepParser
Internal parser for the <step/> elements inside a job.
IntArrayPropertyEditor
ItemCountAware
Marker interface indicating that an item should have the item count set on it.
ItemListenerSupport<I,O>
Basic no-op implementation of the `ItemReadListener`, `ItemProcessListener`, and `ItemWriteListener` interfaces.
ItemPreparedStatementSetter<T>
A convenient strategy for SQL updates, acting effectively as the inverse of `RowMapper`.
ItemProcessListener<T,S>
Listener interface for the processing of an item.
ItemProcessor<I,O>
Interface for item transformation.
ItemProcessorAdapter<I,O>
Invokes a custom method on a delegate plain old Java object which itself processes an item.
ItemReader<T>
Strategy interface for providing the data.
ItemReaderAdapter<T>
Invokes a custom method on a delegate plain old Java object which itself provides an item.
ItemReaderException
A base exception class that all exceptions thrown from an `ItemReader` extend.
ItemReadListener<T>
Listener interface around the reading of an item.
ItemSqlParameterSourceProvider<T>
A convenient strategy for providing SqlParameterSource for named parameter SQL updates.
ItemStream
Marker interface defining a contract for periodically storing state and restoring from that state should an error occur.
ItemStreamException
Exception representing any errors encountered while processing a stream.
ItemStreamReader<T>
Convenience interface that combines `ItemStream` and `ItemReader` .
ItemStreamSupport
Empty method implementation of `ItemStream`.
ItemStreamWriter<T>
Convenience interface that combines `ItemStream` and `ItemWriter` .
ItemWriteListener<S>
Listener interface for the writing of items.
ItemWriter<T>
Basic interface for generic output operations.
ItemWriterAdapter<T>
Delegates item processing to a custom method - passes the item as an argument for the delegate method.
ItemWriterException
A base exception class that all exceptions thrown from an `ItemWriter` extend.
IteratorItemReader<T>
An `ItemReader` that pulls data from a `Iterator` or `Iterable` using the constructors.
Jackson2ExecutionContextStringSerializer
Implementation that uses Jackson2 to provide (de)serialization.
JacksonJsonObjectMarshaller<T>
A json object marshaller that uses Jackson to marshal an object into a json representation.
JacksonJsonObjectReader<T>
Implementation of `JsonObjectReader` based on Jackson.
JdbcBatchItemWriter<T>
`ItemWriter` that uses the batching features from `NamedParameterJdbcTemplate` to execute a batch of statements for all items provided.
JdbcBatchItemWriterBuilder<T>
A builder implementation for the `JdbcBatchItemWriter`.
JdbcCursorItemReader<T>
Simple item reader implementation that opens a JDBC cursor and continually retrieves the next row in the ResultSet.
JdbcCursorItemReaderBuilder<T>
Builder for the `JdbcCursorItemReader`
JdbcExecutionContextDao
JDBC DAO for `ExecutionContext`.
JdbcJobExecutionDao
JDBC implementation of `JobExecutionDao`.
JdbcJobInstanceDao
JDBC implementation of `JobInstanceDao`.
JdbcPagingItemReader<T>
`ItemReader` for reading database records using JDBC in a paging fashion.
JdbcPagingItemReaderBuilder<T>
This is a builder for the `JdbcPagingItemReader`.
JdbcParameterUtils
Helper methods for SQL statement parameter parsing.
JdbcStepExecutionDao
JDBC implementation of `StepExecutionDao`.
Allows customization of the tables names used by Spring Batch for step meta data via a prefix property.
Uses sequences or tables (via Spring's `DataFieldMaxValueIncrementer` abstraction) to create all primary keys before inserting a new row.
JmsItemReader<T>
An `ItemReader` for JMS using a `JmsTemplate`.
JmsItemReaderBuilder<T>
Creates a fully qualified JmsItemReader.
JmsItemWriter<T>
An `ItemWriter` for JMS using a `JmsTemplate`.
JmsItemWriterBuilder<T>
Creates a fully qualified JmsItemWriter.
JmsMethodArgumentsKeyGenerator
A `MethodArgumentsKeyGenerator` for JMS
JmsMethodInvocationRecoverer<T>
JmsNewMethodArgumentsIdentifier<T>
A `NewMethodArgumentsIdentifier` for JMS that looks for a message in the arguments and checks its delivery status.
JmsRedeliveredExtractor
Job
Batch domain object representing a job.
JobBuilder
Convenience for building jobs of various kinds.
JobBuilderException
JobBuilderFactory
Convenient factory for a `JobBuilder` which sets the `JobRepository` automatically.
JobBuilderHelper<B extends JobBuilderHelper<B>>
A base class and utility for other job builders providing access to common properties like job repository.
JobBuilderHelper.CommonJobProperties
JobContext
A context object that can be used to interrogate the current `JobExecution` and some of its associated properties using expressions based on bean paths.
JobExecution
Batch domain object representing the execution of a job.
JobExecutionAlreadyRunningException
JobExecutionDao
Data Access Object for job executions.
JobExecutionDecider
Interface allowing for programmatic access to the decision on what the status of a flow should be.
JobExecutionException
Root of exception hierarchy for checked exceptions in job and step execution.
JobExecutionListener
Provide callbacks at specific points in the lifecycle of a `Job`.
JobExecutionListenerParser
Parser for a step listener element.
JobExecutionListenerSupport
Deprecated.
as of 5.0, in favor of the default methods on the `JobExecutionListener`
JobExecutionNotFailedException
Checked exception to indicate that user asked for a job execution to be resumed when actually it didn't fail.
JobExecutionNotRunningException
Checked exception indicating that a JobExecution that is not currently running has been requested to stop.
JobExecutionNotStoppedException
Checked exception to indicate that user asked for a job execution to be aborted when hasn't been stopped.
JobExplorer
Entry point for browsing executions of running or historical jobs and steps.
JobExplorerFactoryBean
A `FactoryBean` that automates the creation of a `SimpleJobExplorer` using JDBC DAO implementations.
JobFactory
Strategy for creating a single job.
JobFactoryRegistrationListener
Generic service that can bind and unbind a `JobFactory` in a `JobRegistry`.
JobFlowBuilder
JobFlowExecutor
Implementation of `FlowExecutor` for use in components that need to execute a flow related to a `JobExecution`.
JobInstance
Batch domain object representing a uniquely identifiable job run.
JobInstanceAlreadyCompleteException
An exception indicating an illegal attempt to restart a job that was already completed successfully.
JobInstanceAlreadyExistsException
Checked exception to indicate that a required `Job` is not available.
JobInstanceDao
Data Access Object for job instances.
JobInterruptedException
Exception to indicate the job has been interrupted.
JobKeyGenerator<T>
Strategy interface for the generation of the key used in identifying unique `JobInstance`.
JobLauncher
Simple interface for controlling jobs, including possible ad-hoc executions, based on different runtime identifiers.
JobLauncherTestUtils
Utility class for testing batch jobs.
JobLaunchingGateway
The `JobLaunchingGateway` is used to launch Batch Jobs.
JobLaunchingGatewayParser
The parser for the Job-Launching Gateway, which will instantiate a `JobLaunchingGatewayParser`.
JobLaunchingMessageHandler
Message handler which uses strategies to convert a Message into a job and a set of job parameters
JobLaunchRequest
Encapsulation of a `Job` and its `JobParameters` forming a request for a job to be launched.
JobLaunchRequestHandler
Interface for handling a `JobLaunchRequest` and returning a `JobExecution`.
JobListenerFactoryBean
This `AbstractListenerFactoryBean` implementation is used to create a `JobExecutionListener`.
JobListenerMetaData
Enumeration for `JobExecutionListener` meta data, which ties together the names of methods, their interfaces, annotation, and expected arguments.
JobLoader
JobLocator
A runtime service locator interface for retrieving job configurations by `name`.
JobOperator
Low level interface for inspecting and controlling jobs with access only to primitive and collection types.
JobParameter
Domain representation of a parameter to a batch job.
JobParameter.ParameterType
Enumeration representing the type of a JobParameter.
JobParameterExecutionContextCopyListener
This class can be used to automatically copy items from the `JobParameters` to the `Step` `ExecutionContext`.
JobParameters
Value object representing runtime parameters to a batch job.
JobParametersBuilder
Helper class for creating `JobParameters`.
JobParametersConverter
A factory for `JobParameters` instances.
JobParametersExtractor
Strategy interface for translating a `StepExecution` into `JobParameters`.
JobParametersIncrementer
Interface for obtaining the next `JobParameters` in a sequence.
JobParametersInvalidException
Exception for `Job` to signal that some `JobParameters` are invalid.
JobParametersNotFoundException
Checked exception to indicate that a required `JobParametersIncrementer` is not available.
JobParametersValidator
Strategy interface for a `Job` to use in validating its parameters for an execution.
JobParser
Parser for the <job/> element in the Batch namespace.
JobParserJobFactoryBean
This `FactoryBean` is used by the batch namespace parser to create `FlowJob` objects.
JobRegistry
A runtime service registry interface for registering job configurations by `name`.
JobRegistryBackgroundJobRunner
Command line launcher for registering jobs with a `JobRegistry`.
JobRegistryBeanPostProcessor
A `BeanPostProcessor` that registers `Job` beans with a `JobRegistry`.
JobRepository
Repository responsible for persistence of batch meta-data entities.
JobRepositoryFactoryBean
A `FactoryBean` that automates the creation of a `SimpleJobRepository` using JDBC DAO implementations which persist batch metadata in database.
JobRepositoryParser
Parser for the <job-repository/> element in the Batch namespace.
JobRepositoryTestUtils
Convenience class for creating and removing `JobExecution` instances from a database.
JobRestartException
An exception indicating an illegal attempt to restart a job.
JobScope
Convenient annotation for job scoped beans that defaults the proxy mode, so that it doesn't have to be specified explicitly on every bean definition.
JobScope
Scope for job context.
JobScopeManager
Convenient aspect to wrap a single threaded job execution, where the implementation of the `Job` is not job scope aware (i.e.
JobScopeTestExecutionListener
A `TestExecutionListener` that sets up job-scope context for dependency injection into unit tests.
JobScopeTestUtils
Utility class for creating and manipulating `JobScope` in unit tests.
JobStep
A `Step` that delegates to a `Job` to do its work.
JobStepBuilder
A step builder for `JobStep` instances.
JobSynchronizationManager
Central convenience class for framework use in managing the job scope context.
JpaCursorItemReader<T>
`ItemStreamReader` implementation based on JPA `Query.getResultStream()`.
JpaCursorItemReaderBuilder<T>
Builder for `JpaCursorItemReader`.
JpaItemWriter<T>
`ItemWriter` that is using a JPA EntityManagerFactory to merge any Entities that aren't part of the persistence context.
JpaItemWriterBuilder<T>
A builder for the `JpaItemWriter`.
JpaNamedQueryProvider<E>
This query provider creates JPA named `Query`s.
JpaNativeQueryProvider<E>
This query provider creates JPA `Query`s from injected native SQL queries.
JpaPagingItemReader<T>
`ItemReader` for reading database records built on top of JPA.
JpaPagingItemReaderBuilder<T>
Creates a fully qualified JpaPagingItemReader.
JpaQueryProvider
Interface defining the functionality to be provided for generating queries for use with JPA `ItemReader`s or other custom built artifacts.
JsonFileItemWriter<T>
Item writer that writes data in json format to an output file.
JsonFileItemWriterBuilder<T>
Builder for `JsonFileItemWriter`.
JsonItemReader<T>
`ItemStreamReader` implementation that reads Json objects from a `Resource` having the following format:
JsonItemReaderBuilder<T>
A builder for `JsonItemReader`.
JsonLineMapper
Interpret a line as a JSON object and parse it up to a Map.
JsonObjectMarshaller<T>
Strategy interface to marshal an object into a json representation.
JsonObjectReader<T>
Strategy interface for Json readers.
JsonRecordSeparatorPolicy
JSON-based record separator.
JvmSystemExiter
Implementation of the `SystemExiter` interface that calls the standards System.exit method.
KafkaItemReader<K,V>
An `ItemReader` implementation for Apache Kafka.
KafkaItemReaderBuilder<K,V>
A builder implementation for the `KafkaItemReader`.
KafkaItemWriter<K,T>
An `ItemWriter` implementation for Apache Kafka using a `KafkaTemplate` with default topic configured.
KafkaItemWriterBuilder<K,V>
A builder implementation for the `KafkaItemWriter`
KeyGenerator
Interface for defining keys to uniquely identify items.
KeyValueItemWriter<K,V>
A base class to implement any `ItemWriter` that writes to a key value store using a `Converter` to derive a key from an item
LastModifiedResourceComparator
Comparator to sort resources by the file last modified time.
LdifReader
The `LdifReader` is an adaptation of the `FlatFileItemReader` built around an `LdifParser`.
LdifReaderBuilder
Creates a fully qualified LdifReader.
LimitCheckingItemSkipPolicy
`SkipPolicy` that determines whether or not reading should continue based upon how many items have been skipped.
LineAggregator<T>
Interface used to create string representing object.
LineCallbackHandler
Callback interface for handling a line from file.
LineMapper<T>
Interface for mapping lines (strings) to domain objects typically used to map lines read from a file to domain objects on a per line basis.
LineTokenizer
Interface that is used by framework to split string obtained typically from a file into tokens.
ListableJobLocator
A listable extension of `JobLocator`.
ListenerMetaData
A common interface for listener meta data enumerations.
ListItemReader<T>
An `ItemReader` that pulls data from a list.
ListItemWriter<T>
LogOrRethrowExceptionHandler
Implementation of `ExceptionHandler` based on an `Classifier`.
LogOrRethrowExceptionHandler.Level
Logging levels for the handler.
MailErrorHandler
This class is used to handle errors that occur when email messages are unable to be sent.
MapJobRegistry
Simple, thread-safe, map-based implementation of `JobRegistry`.
MappingLdifReader<T>
The `MappingLdifReader` is an adaptation of the `FlatFileItemReader` built around an `LdifParser`.
MappingLdifReaderBuilder<T>
Creates a fully qualified MappingLdifReader.
MapStepRegistry
Simple map-based implementation of `StepRegistry`.
MaxValueFlowExecutionAggregator
Implementation of the `FlowExecutionAggregator` interface that aggregates `FlowExecutionStatus`', using the status with the high precedence as the aggregate status.
MessageChannelPartitionHandler
A `PartitionHandler` that uses `MessageChannel` instances to send instructions to remote workers and receive their responses.
MessageSourcePollerInterceptor
A `ChannelInterceptor` that turns a pollable channel into a "pass-thru channel": if a client calls `receive()` on the channel it will delegate to a `MessageSource` to pull the message directly from an external source.
MetaDataInstanceFactory
Convenience methods for creating test instances of `JobExecution`, `JobInstance` and `StepExecution`.
MethodInvoker
A strategy interface for invoking a method.
MethodInvokerMethodInterceptor
`MethodInterceptor` that, given a map of method names and `MethodInvoker`s, will execute all methods tied to a particular method name, with the provided arguments.
MethodInvokerUtils
Utility methods for create MethodInvoker instances.
MethodInvokingTaskletAdapter
A `Tasklet` that wraps a method in a POJO.
MethodResolver
Strategy interface for detecting a single Method on a Class.
MimeMessageItemWriter
A simple `ItemWriter` that can send mail messages.
ModularBatchConfiguration
Base `Configuration` class providing common structure for enabling and using Spring Batch.
MongoItemReader<T>
Restartable `ItemReader` that reads documents from MongoDB via a paging technique.
MongoItemReaderBuilder<T>
A builder implementation for the `MongoItemReader`
MongoItemWriter<T>
A `ItemWriter` implementation that writes to a MongoDB store using an implementation of Spring Data's `MongoOperations`.
MongoItemWriterBuilder<T>
A builder implementation for the `MongoItemWriter`
MulticasterBatchListener<T,S>
MultiResourceItemReader<T>
Reads items from multiple resources sequentially - resource list is given by `MultiResourceItemReader.setResources(Resource[])`, the actual reading is delegated to `MultiResourceItemReader.setDelegate(ResourceAwareItemReaderItemStream)`.
MultiResourceItemReaderBuilder<T>
A builder implementation for the `MultiResourceItemReader`.
MultiResourceItemWriter<T>
Wraps a `ResourceAwareItemWriterItemStream` and creates a new output resource when the count of items written in current resource exceeds `MultiResourceItemWriter.setItemCountLimitPerResource(int)`.
MultiResourceItemWriterBuilder<T>
A builder implementation for the `MultiResourceItemWriter`.
MultiResourcePartitioner
Implementation of `Partitioner` that locates multiple resources and associates their file names with execution context keys.
MySqlPagingQueryProvider
MySQL implementation of a `PagingQueryProvider` using database specific features.
Neo4jItemReader<T>
Deprecated.
since 5.0 in favor of the item reader from https://github.com/spring-projects/spring-batch-extensions/blob/main/spring-batch-neo4j
Neo4jItemReaderBuilder<T>
Deprecated.
since 5.0 in favor of the item reader builder from https://github.com/spring-projects/spring-batch-extensions/blob/main/spring-batch-neo4j
Neo4jItemWriter<T>
Deprecated.
since 5.0 in favor of the item writer from https://github.com/spring-projects/spring-batch-extensions/blob/main/spring-batch-neo4j
Neo4jItemWriterBuilder<T>
Deprecated.
since 5.0 in favor of the item writer builder from https://github.com/spring-projects/spring-batch-extensions/blob/main/spring-batch-neo4j
NestedRepeatCallback
Callback that delegates to another callback, via a `RepeatOperations` instance.
NeverSkipItemSkipPolicy
`SkipPolicy` implementation that always returns false, indicating that an item should not be skipped.
NonSkippableProcessException
Fatal exception to be thrown when a process operation could not be skipped.
NonSkippableReadException
Fatal exception to be thrown when a read operation could not be skipped.
NonSkippableWriteException
Fatal exception to be thrown when a process operation could not be skipped.
NonTransientFlatFileException
Exception thrown when errors are encountered with the underlying resource.
NonTransientResourceException
Exception indicating that an error has been encountered doing I/O from a reader, and the exception should be considered fatal.
NoStartEndDocumentStreamWriter
Delegating XMLEventWriter, which ignores start and end document events, but passes through everything else.
NoSuchJobException
Checked exception to indicate that a required `Job` is not available.
NoSuchJobExecutionException
Checked exception to indicate that a required `JobExecution` is not available.
NoSuchJobInstanceException
Exception that signals that the user requested an operation on a non-existent `JobInstance`.
NoSuchObjectException
This exception identifies that a batch domain object is invalid, which is generally caused by an invalid ID.
NoSuchStepException
Exception to signal that a step was requested that is unknown or does not exist.
NoWorkFoundStepExecutionListener
Fails the step if no items have been processed ( item count is 0).
OnProcessError
Marks a method to be called if an exception is thrown by an `ItemProcessor`
Expected signature: void onProcessError(T item, `Exception` e)
OnReadError
Marks a method to be called if an exception is thrown by an `ItemReader`
Expected signature: void onReadError(`Exception` ex)
OnSkipInProcess
Marks a method to be called when an item is skipped due to an exception thrown in the `ItemProcessor`.
Expected signature: void onSkipInProcess(T item, `Throwable` t)
OnSkipInRead
Marks a method to be called when an item is skipped due to an exception thrown in the `ItemReader`
Expected signature: void onSkipInRead(`Throwable` t)
OnSkipInWrite
Marks a method to be called when an item is skipped due to an exception thrown in the `ItemWriter`.
Expected signature: void onSkipInWrite(S item, `Throwable` t)
OnWriteError
Marks a method to be called if an exception is thrown by an `ItemWriter`
Expected signature: void onWriteError(`Exception` exception, `List`<? extends S> items)
OraclePagingQueryProvider
Oracle implementation of a `PagingQueryProvider` using database specific features.
Order
The direction of the sort in an ORDER BY clause.
PagingQueryProvider
Interface defining the functionality to be provided for generating paging queries for use with Paging Item Readers.
ParseException
Exception indicating that an error has been encountered parsing IO, typically from a file.
Partitioner
Central strategy interface for creating input parameters for a partitioned step in the form of `ExecutionContext` instances.
PartitionHandler
Interface defining the responsibilities of controlling the execution of a partitioned `StepExecution`.
PartitionNameProvider
Optional interface for `Partitioner` implementations that need to use a custom naming scheme for partitions.
PartitionStep
Implementation of `Step` which partitions the execution and spreads the load using a `PartitionHandler`.
PartitionStepBuilder
Step builder for `PartitionStep` instances.
PassThroughFieldExtractor<T>
`FieldExtractor` that just returns the original item.
PassThroughFieldSetMapper
Pass through `FieldSetMapper` useful for passing a `FieldSet` back directly rather than a mapped object.
PassThroughItemProcessor<T>
Simple `ItemProcessor` that does nothing - simply passes its argument through to the caller.
PassThroughLineAggregator<T>
A `LineAggregator` implementation that simply calls `Object.toString()` on the given object
PassThroughLineMapper
Pass through `LineMapper` useful for passing the original `String` back directly rather than a mapped object.
PatternMatcher<S>
PatternMatchingCompositeLineMapper<T>
A `LineMapper` implementation that stores a mapping of String patterns to delegate `LineTokenizer`s as well as a mapping of String patterns to delegate `FieldSetMapper`s.
PatternMatchingCompositeLineTokenizer
A `LineTokenizer` implementation that stores a mapping of String patterns to delegate `LineTokenizer`s.
PeekableItemReader<T>
A specialisation of `ItemReader` that allows the user to look ahead into the stream of items.
Poller<T>
Interface for polling a `Callable` instance provided by the user.
PostgresPagingQueryProvider
Postgres implementation of a `PagingQueryProvider` using database specific features.
PropertiesConverter
Utility to convert a Properties object to a String and back.
PropertyExtractingDelegatingItemWriter<T>
Delegates processing to a custom method - extracts property values from item object and uses them as arguments for the delegate method.
Range
A class to represent ranges.
RangeArrayPropertyEditor
Property editor implementation which parses string and creates array of ranges.
ReaderNotOpenException
Exception indicating that an `ItemReader` needed to be opened before read.
RecordCallbackHandler
This interface can be used to operate on skipped records during open in the `LdifReader` and the `MappingLdifReader`.
RecordFieldSetMapper<T>
This is a `FieldSetMapper` that supports Java records mapping (requires JKD 14 or higher).
RecordMapper<T>
This interface should be implemented to map `LdapAttributes` objects to POJOs.
RecordSeparatorPolicy
Policy for text file-based input sources to determine the end of a record, e.g.
RecursiveCollectionLineAggregator<T>
An implementation of `LineAggregator` that concatenates a collection of items of a common type with the system line separator.
ReferenceJobFactory
A `JobFactory` that just keeps a reference to a `Job`.
ReflectionUtils
Provides reflection based utilities for Spring Batch that are not available via Spring Core
RegexLineTokenizer
Line-tokenizer using a regular expression to filter out data (by using matching and non-matching groups).
RemoteChunkHandlerFactoryBean<T>
Convenient factory bean for a chunk handler that also converts an existing chunk-oriented step into a remote chunk manager.
RemoteChunkingManagerParser
Parser for the remote-chunking-manager namespace element.
RemoteChunkingManagerStepBuilder<I,O>
Builder for a manager step in a remote chunking setup.
RemoteChunkingManagerStepBuilderFactory
Convenient factory for a `RemoteChunkingManagerStepBuilder` which sets the `JobRepository` and `PlatformTransactionManager` automatically.
RemoteChunkingWorkerBuilder<I,O>
Builder for a worker in a remote chunking setup.
RemoteChunkingWorkerParser
Parser for the remote-chunking-worker namespace element.
RemotePartitioningManagerStepBuilder
Builder for a manager step in a remote partitioning setup.
RemotePartitioningManagerStepBuilderFactory
Convenient factory for a `RemotePartitioningManagerStepBuilder` which sets the `JobRepository`, `JobExplorer`, `BeanFactory` and `PlatformTransactionManager` automatically.
RemotePartitioningWorkerStepBuilder
Builder for a worker step in a remote partitioning setup.
RemotePartitioningWorkerStepBuilderFactory
Convenient factory for a `RemotePartitioningWorkerStepBuilder` which sets the `JobRepository`, `JobExplorer`, `BeanFactory` and `PlatformTransactionManager` automatically.
RemoteStepExecutionAggregator
Convenience class for aggregating a set of `StepExecution` instances when the input comes from remote steps, so the data need to be refreshed from the repository.
RepeatCallback
Callback interface for batch operations.
RepeatContext
Base interface for context which controls the state and completion / termination of a batch step.
RepeatContextCounter
Helper class for policies that need to count the number of occurrences of some event (e.g.
RepeatContextSupport
RepeatException
RepeatInternalState
Internal interface for extensions of `RepeatTemplate`.
RepeatInternalStateSupport
RepeatListener
Interface for listeners to the batch process.
RepeatListenerSupport
Deprecated.
as of v5.0 in favor of the default methods in `RepeatListener`.
RepeatOperations
The main interface providing access to batch operations.
RepeatOperationsInterceptor
A `MethodInterceptor` that can be used to automatically repeat calls to a method on a service.
RepeatStatus
RepeatSynchronizationManager
Global variable support for repeat clients.
RepeatTemplate
Simple implementation and base class for batch templates implementing `RepeatOperations`.
RepositoryItemReader<T>
A `ItemReader` that reads records utilizing a `PagingAndSortingRepository`.
RepositoryItemReaderBuilder<T>
A builder implementation for the `RepositoryItemReader`.
RepositoryItemReaderBuilder.RepositoryMethodReference<T>
Establishes a proxy that will capture a the Repository and the associated methodName that will be used by the reader.
RepositoryItemWriter<T>
A `ItemWriter` wrapper for a `CrudRepository` from Spring Data.
RepositoryItemWriterBuilder<T>
A builder implementation for the `RepositoryItemWriter`.
RepositoryItemWriterBuilder.RepositoryMethodReference<T>
Establishes a proxy that will capture a the Repository and the associated methodName that will be used by the writer.
ResourceAware
Marker interface indicating that an item should have the Spring `Resource` in which it was read from, set on it.
ResourceAwareItemReaderItemStream<T>
Interface for `ItemReader`s that implement `ItemStream` and read input from `Resource`.
ResourceAwareItemWriterItemStream<T>
Interface for `ItemWriter`s that implement `ItemStream` and write output to `Resource`.
ResourcelessTransactionManager
ResourcesItemReader
`ItemReader` which produces `Resource` instances from an array.
ResourceSuffixCreator
Strategy interface for translating resource index into unique filename suffix.
ResultHolderResultQueue
An implementation of the `ResultQueue` that throttles the number of expected results, limiting it to a maximum at any given time.
RethrowOnThresholdExceptionHandler
Implementation of `ExceptionHandler` that rethrows when exceptions of a given type reach a threshold.
RunIdIncrementer
This incrementer increments a "run.id" parameter of type `Long` from the given job parameters.
RuntimeExceptionTranslator
ScopeConfiguration
`Configuration` class that provides `StepScope` and `JobScope`.
ScriptItemProcessor<I,O>
`ItemProcessor` implementation that passes the current item to process to the provided script.
ScriptItemProcessorBuilder<I,O>
Creates a fully qualified ScriptItemProcessor.
SimpleBatchConfiguration
Base `Configuration` class providing common structure for enabling and using Spring Batch.
SimpleBinaryBufferedReaderFactory
A `BufferedReaderFactory` useful for reading simple binary (or text) files with no line endings, such as those produced by mainframe copy books.
SimpleChunkProcessor<I,O>
Simple implementation of the `ChunkProcessor` interface that handles basic item writing and processing.
SimpleChunkProvider<I>
Simple implementation of the ChunkProvider interface that does basic chunk providing from an `ItemReader`.
SimpleCompletionPolicy
Policy for terminating a batch after a fixed number of operations.
SimpleFlow
A `Flow` that branches conditionally depending on the exit status of the last `State`.
SimpleFlowFactoryBean
Convenience factory for SimpleFlow instances for use in XML namespace.
SimpleFlowFactoryBean.DelegateState
A State that proxies a delegate and changes its name but leaves its behavior unchanged.
SimpleJob
Simple implementation of `Job` interface providing the ability to run a `JobExecution`.
SimpleJobBuilder
SimpleJobExplorer
Implementation of `JobExplorer` using the injected DAOs.
SimpleJobLauncher
Simple implementation of the `JobLauncher` interface.
SimpleJobOperator
Simple implementation of the JobOperator interface.
SimpleJobRepository
Implementation of `JobRepository` that stores JobInstances, JobExecutions, and StepExecutions using the injected DAOs.
SimpleJvmExitCodeMapper
An implementation of `ExitCodeMapper` that can be configured through a map from batch exit codes (String) to integer results.
SimpleLimitExceptionHandler
Simple implementation of exception handler which looks for given exception types.
SimpleMailMessageItemWriter
A simple `ItemWriter` that can send mail messages.
SimpleMailMessageItemWriterBuilder
Creates a fully qualified SimpleMailMessageItemWriter.
SimpleMethodInvoker
Simple implementation of the `MethodInvoker` interface that invokes a method on an object.
SimplePartitioner
Simplest possible implementation of `Partitioner`.
SimpleRecordSeparatorPolicy
Simplest possible `RecordSeparatorPolicy` - treats all lines as record endings.
SimpleResourceSuffixCreator
Trivial implementation of `ResourceSuffixCreator` that uses the index itself as suffix, separated by dot.
SimpleRetryExceptionHandler
An `ExceptionHandler` that is aware of the retry context so that it can distinguish between a fatal exception and one that can be retried.
SimpleStepBuilder<I,O>
Step builder for simple item processing (chunk oriented) steps.
SimpleStepExecutionSplitter
Generic implementation of `StepExecutionSplitter` that delegates to a `Partitioner` to generate `ExecutionContext` instances.
SimpleStepFactoryBean<T,S>
Most common configuration options for simple steps should be found here.
SimpleStepHandler
Implementation of `StepHandler` that manages repository and restart concerns.
SimpleSystemProcessExitCodeMapper
Simple `SystemProcessExitCodeMapper` implementation that performs following mapping: 0 -> ExitStatus.FINISHED else -> ExitStatus.FAILED
SingleItemPeekableItemReader<T>
A `PeekableItemReader` that allows the user to peek one item ahead.
SingleItemPeekableItemReaderBuilder<T>
Creates a fully qualified SingleItemPeekeableItemReader.
SkipException
Base exception indicating that the skip has failed or caused a failure.
SkipLimitExceededException
Exception indicating that the skip limit for a particular `Step` has been exceeded.
SkipListener<T,S>
Interface for listener to skipped items.
SkipListenerFailedException
Special exception to indicate a failure in a skip listener.
SkipListenerSupport<T,S>
Deprecated.
as of v5.0 in favor of the default methods in `SkipListener`.
SkipOverflowException
SkipPolicy
Policy for determining whether or not some processing should be skipped.
SkipPolicyFailedException
Special exception to indicate a failure in a skip policy.
SkipWrapper<T>
Wrapper for an item and its exception if it failed processing.
SpELItemKeyMapper<K,V>
An implementation of `Converter` that uses SpEL to map a Value to a key
SpELMappingGemfireItemWriter<K,V>
A convenient `GemfireItemWriter` implementation that uses a `SpELItemKeyMapper`
SplitParser
Internal parser for the <split/> elements inside a job.
SplitState
A `State` implementation that splits a `Flow` into multiple parallel subflows.
SpringBatchTest
Annotation that can be specified on a test class that runs Spring Batch based tests.
SpringValidator<T>
Adapts the `Validator` interface to `Validator`.
SqlitePagingQueryProvider
SQLite implementation of a `PagingQueryProvider` using database specific features.
SqlPagingQueryProviderFactoryBean
Factory bean for `PagingQueryProvider` interface.
SqlPagingQueryUtils
Utility class that generates the actual SQL statements used by query providers.
SqlServerPagingQueryProvider
SQL Server implementation of a `PagingQueryProvider` using database specific features.
SqlServerSequenceMaxValueIncrementer
Incrementer for SQL Server sequences.
SqlWindowingPagingQueryProvider
Generic Paging Query Provider using standard SQL:2003 windowing functions.
StandaloneStepParser
Internal parser for the <step/> elements for a job.
StartLimitExceededException
Indicates the step's start limit has been exceeded.
State
StateTransition
Value object representing a potential transition from one `State` to another.
StaxEventItemReader<T>
Item reader for reading XML input based on StAX.
StaxEventItemReaderBuilder<T>
A fluent builder for the `StaxEventItemReader`
StaxEventItemWriter<T>
An implementation of `ItemWriter` which uses StAX and `Marshaller` for serializing object to XML.
StaxEventItemWriterBuilder<T>
A builder for the `StaxEventItemWriter`.
StaxWriterCallback
Callback interface for writing to an XML file - useful e.g.
Step
Batch domain interface representing the configuration of a step.
StepBuilder
Convenient entry point for building all kinds of steps.
StepBuilderException
Utility exception thrown by builders when they encounter unexpected checked exceptions.
StepBuilderFactory
Convenient factory for a `StepBuilder` which sets the `JobRepository` and `PlatformTransactionManager` automatically.
StepBuilderHelper<B extends StepBuilderHelper<B>>
A base class and utility for other step builders providing access to common properties like job repository and transaction manager.
StepBuilderHelper.CommonStepProperties
StepContext
A context object that can be used to interrogate the current `StepExecution` and some of its associated properties using expressions based on bean paths.
StepContextRepeatCallback
Convenient base class for clients who need to do something in a repeat callback inside a `Step`.
StepContribution
Represents a contribution to a `StepExecution`, buffering changes until they can be applied at a chunk boundary.
StepContributionSource
A source of `StepContribution` instances that can be aggregated and used to update an ongoing `StepExecution`.
StepExecution
Batch domain object representation the execution of a step.
StepExecutionAggregator
Strategy for a aggregating step executions, usually when they are the result of partitioned or remote execution.
StepExecutionDao
StepExecutionInterceptor
A `ChannelInterceptor` that adds the current `StepExecution` (if there is one) as a header to the message.
StepExecutionListener
Listener interface for the lifecycle of a `Step`.
StepExecutionListenerSupport
Deprecated.
as of 5.0, in favor of the default methods on the `StepExecutionListener`
StepExecutionRequest
Class encapsulating information required to request a step execution in a remote partitioning setup.
StepExecutionRequestHandler
A `MessageEndpoint` that can handle a `StepExecutionRequest` and return a `StepExecution` as the result.
StepExecutionSimpleCompletionPolicy
A `CompletionPolicy` that picks up a commit interval from `JobParameters` by listening to the start of a step.
StepExecutionSplitter
Strategy interface for generating input contexts for a partitioned step execution independent from the fabric they are going to run on.
StepHandler
Strategy interface for handling a `Step` on behalf of a `Job`.
StepHolder
Interface for holders of a `Step` as a convenience for callers who need access to the underlying instance.
StepInterruptionPolicy
Strategy interface for an interruption policy.
StepListener
Marker interface that acts as a parent to all step domain listeners, such as: `StepExecutionListener`, `ChunkListener`, `ItemReadListener` and `ItemWriteListener`
StepListenerFactoryBean
This `AbstractListenerFactoryBean` implementation is used to create a `StepListener`.
StepListenerFailedException
Exception to indicate a problem in a step listener.
StepListenerMetaData
Enumeration for `StepListener` meta data, which ties together the names of methods, their interfaces, annotation, and expected arguments.
StepListenerParser
Parser for a step listener element.
StepListenerSupport<T,S>
Basic no-op implementations of all `StepListener` interfaces.
StepLocator
Interface for locating a `Step` instance by name.
StepLocatorStepFactoryBean
Convenience factory for `Step` instances given a `StepLocator`.
StepParserStepFactoryBean<I,O>
This `FactoryBean` is used by the batch namespace parser to create `Step` objects.
StepRegistry
Registry keeping track of all the `Step` defined in a `Job`.
StepRunner
Utility class for executing steps outside of a `Job`.
StepScope
Convenient annotation for step scoped beans that defaults the proxy mode, so that it doesn't have to be specified explicitly on every bean definition.
StepScope
Scope for step context.
StepScopeManager
Convenient aspect to wrap a single threaded step execution, where the implementation of the `Step` is not step scope aware (i.e.
StepScopeTestExecutionListener
A `TestExecutionListener` that sets up step-scope context for dependency injection into unit tests.
StepScopeTestUtils
Utility class for creating and manipulating `StepScope` in unit tests.
StepState
`State` implementation that delegates to a `FlowExecutor` to execute the specified `Step`.
StepSynchronizationManager
Central convenience class for framework use in managing the step scope context.
StoppableTasklet
An extension to the `Tasklet` interface to allow users to add logic for stopping a tasklet.
StoredProcedureItemReader<T>
Item reader implementation that executes a stored procedure and then reads the returned cursor and continually retrieves the next row in the `ResultSet`.
StoredProcedureItemReaderBuilder<T>
A fluent builder API for the configuration of a `StoredProcedureItemReader`.
SuffixRecordSeparatorPolicy
A `RecordSeparatorPolicy` that looks for an exact match for a String at the end of a line (e.g.
SybasePagingQueryProvider
Sybase implementation of a `PagingQueryProvider` using database specific features.
SynchronizationManagerSupport<E,C>
Central convenience class for framework use in managing the scope context.
SynchronizedAttributeAccessor
An `AttributeAccessor` that synchronizes on a mutex (not this) before modifying or accessing the underlying attributes.
SynchronizedItemStreamReader<T>
This is a simple ItemStreamReader decorator with a synchronized ItemReader.read() method - which makes a non-thread-safe ItemReader thread-safe.
SynchronizedItemStreamReaderBuilder<T>
Creates a fully qualified SynchronizedItemStreamReader.
SynchronizedItemStreamWriter<T>
An `ItemStreamWriter` decorator with a synchronized `write()` method.
SynchronizedItemStreamWriterBuilder<T>
Creates a fully qualified `SynchronizedItemStreamWriter`.
SystemCommandException
Exception indicating failed execution of system command.
SystemCommandTasklet
`Tasklet` that executes a system command.
SystemExiter
Interface for exiting the JVM.
SystemProcessExitCodeMapper
Maps the exit code of a system process to ExitStatus value returned by a system command.
SystemPropertyInitializer
Helper class that sets up a System property with a default value.
TaskExecutorPartitionHandler
A `PartitionHandler` that uses a `TaskExecutor` to execute the partitioned `Step` locally in multiple threads.
TaskExecutorRepeatTemplate
Provides `RepeatOperations` support including interceptors that can be used to modify or monitor the behaviour at run time.
This implementation is sufficient to be used to configure transactional behaviour for each item by making the `RepeatCallback` transactional, or for the whole batch by making the execute method transactional (but only then if the task executor is synchronous).
This class is thread-safe if its collaborators are thread-safe (interceptors, terminationPolicy, callback).
Tasklet
Strategy for processing in a step.
TaskletParser
Parse a tasklet element for a step.
TaskletStep
Simple implementation of executing the step as a call to a `Tasklet`, possibly repeated, and each call surrounded by a transaction.
TaskletStepBuilder
Builder for tasklet step based on a custom tasklet (not item oriented).
ThreadStepInterruptionPolicy
Policy that checks the current thread to see if it has been interrupted.
ThrottleLimitResultQueue<T>
An implementation of the `ResultQueue` that throttles the number of expected results, limiting it to a maximum at any given time.
TimeoutTerminationPolicy
Termination policy that times out after a fixed period.
TopLevelFlowParser
TopLevelJobListenerParser
Parse <job-listener/> elements in the batch namespace.
TopLevelStepListenerParser
Parse <step-listener/> elements in the batch namespace.
TopLevelStepParser
Parser for the <step/> top level element in the Batch namespace.
TransactionAwareBufferedWriter
Wrapper for a `FileChannel` that delays actually writing to or closing the buffer if a transaction is active.
TransactionAwareProxyFactory<T>
Factory for transaction aware objects (like lists, sets, maps).
UncheckedTransactionException
Convenience wrapper for a checked exception so that it can cause a rollback and be extracted afterwards.
UnclosedElementCollectingEventWriter
Delegating XMLEventWriter, which collects the QNames of elements that were opened but not closed.
UnexpectedInputException
Used to signal an unexpected end of an input or message stream.
UnexpectedJobExecutionException
Indicates to the framework that a critical error has occurred and processing should immediately stop.
UnopenedElementClosingEventWriter
Delegating XMLEventWriter, which writes EndElement events that match a given collection of QNames directly to the underlying java.io.Writer instead of to the delegate XMLEventWriter.
ValidatingItemProcessor<T>
Simple implementation of `ItemProcessor` that validates input and returns it without modifications.
ValidationException
This exception should be thrown when there are validation errors.
Validator<T>
Interface used to validate objects.
WriteFailedException
Unchecked exception indicating that an error has occurred while trying to clear a buffer on a rollback.
WriterNotOpenException
Exception indicating that an `ItemWriter` needed to be opened before being written to.