All Classes and Interfaces
Class
Description
Abstract base class for any simple item reader that opens a database cursor and
continually retrieves the next row in the ResultSet.
Base class for item writers that write data to a file or stream.
Abstract superclass for
ItemReaders that supports restart by storing item count
in the ExecutionContext (therefore requires item ordering to be preserved
between runs).Base class for
ItemReader implementations.Base class for
ItemWriter implementations.
Abstract JPA Query Provider to serve as a base class for all JPA
Query
providers.Abstract class handling common concerns of various
LineTokenizer
implementations such as dealing with names and actual construction of FieldSetSuperclass for delegating classes which dynamically call a custom method of injected
object.
A base class that handles basic reading logic based on the paginated semantics of
Spring Data's paginated facilities.
Abstract
ItemStreamReader for to extend when
reading database records in a paging fashion.Abstract SQL Paging Query Provider to serve as a base class for all provided SQL paging
query providers.
AMQP
ItemReader implementation using an AmqpTemplate to receive and/or
convert messages.A builder implementation for the
AmqpItemReader
AMQP
ItemWriter implementation using an AmqpTemplate to send messages.A builder implementation for the
AmqpItemWriterMethodResolver implementation that finds a single Method on the given
Class that contains the specified annotation type.A basic array mapper, returning the values backing a fieldset.
An
ItemReader that deserializes data from a Resource containing
serialized Avro objects.A builder implementation for the
AvroItemReader.An
ItemWriter that serializes data to an WritableResource using Avro.A builder implementation for the
AvroItemWriter.A convenient implementation for providing BeanPropertySqlParameterSource when the item
has JavaBean properties that correspond to names used for parameters in the SQL
statement.
A
ValidatingItemProcessor that uses the Bean Validation API (JSR-303) to
validate items.This is a field extractor for a java bean.
FieldSetMapper implementation based on bean property paths.This is an
ItemReader that reads items from a BlockingQueue.Builder for
BlockingQueueItemReader.This is an
ItemWriter that writes items to a BlockingQueue.Builder for a
BlockingQueueItemWriter.A factory strategy for custom extensions of
BufferedReader allowing
customisation of the standard behaviour of the java.io variety.Encapsulation of a list of items to be processed and possibly a list of failed items to
be skipped.
Calls one of a collection of ItemProcessors, based on a router pattern implemented
through the provided
Classifier.Creates a fully qualified
ClassifierCompositeItemProcessor.Calls one of a collection of ItemWriters for each item, based on a router pattern
implemented through the provided
Classifier.Creates a fully qualified ClassifierCompositeItemWriter.
Implementation of the
ItemPreparedStatementSetter interface that assumes all
keys are contained within a Map with the column name as the key.Interface for batch completion policies, to enable batch operations to strategise
normal completion conditions.
Very simple base class for
CompletionPolicy implementations.Composite policy that loops through a list of delegate policies and answers calls by a
consensus.
Composite
ExceptionHandler that loops though a list of delegates.Composite
Note the user is responsible for injecting a chain of
ItemProcessor that passes the item through a sequence of injected
ItemTransformers (return value of previous transformation is the entry
value of the next).Note the user is responsible for injecting a chain of
ItemProcessors that
conforms to declared input and output types.Creates a fully qualified
CompositeItemProcessorBuilder.Composite reader that delegates reading to a list of
ItemStreamReaders.Simple
ItemStream that delegates to a list of other streams.Calls a collection of
The implementation is thread-safe if all delegates are thread-safe.
ItemWriters in fixed-order sequence.The implementation is thread-safe if all delegates are thread-safe.
Creates a fully qualified CompositeItemWriter.
Allows a user to register one or more RepeatListeners to be notified on batch events.
Adapter for a
Consumer to an ItemWriter.Abstract base class for policies that need to count the number of occurrences of some
event (e.g. an exception type in the context), and terminate based on a limit for the
counter.
Enum representing a database type, such as DB2 or oracle.
Factory for creating
DataFieldMaxValueIncrementer implementations based upon a
provided string.DB2 implementation of a
PagingQueryProvider using database specific features.Default implementation of the
DataFieldMaxValueIncrementerFactory interface.Default implementation of
ExceptionHandler - just re-throws the exception it
encounters.Default implementation of
FieldSet using Java primitive and standard types and
utilities.Default implementation of
FieldSetFactory with no special knowledge of the
FieldSet required.Default implementation of
FragmentEventReaderTwo-phase
LineMapper implementation consisting of tokenization of the line into
FieldSet followed by mapping to item.This
MailErrorHandler implementation simply rethrows the exception it receives.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).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.Very simple
CompletionPolicy that bases its decision on the result of a batch
operation.A
LineAggregator implementation that converts an object into a delimited list
of strings.A
LineTokenizer implementation that splits the input String on a configurable
delimiter.Derby implementation of a
PagingQueryProvider using database specific features.A
Poller that uses the callers thread to poll for a result as soon as it is
asked for.Indicates an error has been encountered while trying to dynamically invoke a method
e.g. using
MethodInvoker.Handler to allow strategies for re-throwing exceptions.
Object representing a context for an
ItemStream.Facilitates assigning names to objects persisting data in
ExecutionContext and
generating keys for ExecutionContext based on the name.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.An abstract
LineAggregator implementation that utilizes a
FieldExtractor to convert the incoming object to an array of its parts.This class will convert an object to an array of its parts.
Interface used by flat file input sources to encapsulate concerns of converting an
array of Strings to Java native types.
Factory interface for creating
FieldSet instances.Interface that is used to map data obtained from a
FieldSet into an object.Utility methods for files used in batch processing.
Tokenizer used to process data obtained from files with fixed-length format.
Callback interface for writing a footer to a file.
Exception indicating that some type of error has occurred while attempting to parse a
line of input into tokens.
Callback interface for writing a header to a file.
Restartable
ItemReader that reads lines from input
FlatFileItemReader.setResource(Resource).A builder implementation for the
FlatFileItemReader.A builder for constructing a
DelimitedLineTokenizerA builder for constructing a
FixedLengthTokenizerThis class is an item writer that writes data to a file or stream.
A builder implementation for the
FlatFileItemWriterA builder for constructing a
DelimitedLineAggregatorA builder for constructing a
FormatterLineAggregator.Exception thrown when errors are encountered parsing flat files.
Unchecked exception indicating that an error has occurred while trying to flush a
buffer.
A
LineAggregator implementation which produces a String by aggregating the
provided item via the Formatter syntax.Interface for event readers which support treating XML fragments as standalone XML
documents by wrapping the fragments with StartDocument and EndDocument events.
An
ItemProcessor implementation that delegates to a FunctionA json object marshaller that uses Google
Gson to marshal an object into a json representation.
Implementation of
JsonObjectReader based on
Google Gson.H2 implementation of a
PagingQueryProvider using database
specific features.SAP HANA implementation of a
PagingQueryProvider using database specific
features.A
MethodInvoker that is a bit relaxed about its arguments.HSQLDB implementation of a
PagingQueryProvider using database
specific features.Exception indicating that the line size expected is different from what is expected.
Exception indicating that an incorrect number of tokens have been found while parsing a
file.
Marker interface indicating that an item should have the item count set on it.
A convenient strategy for SQL updates, acting effectively as the inverse of
RowMapper.Interface for item transformation.
Invokes a custom method on a delegate plain old Java object which itself processes an
item.
Strategy interface for providing the data.
Invokes a custom method on a delegate plain old Java object which itself provides an
item.
A base exception class that all exceptions thrown from an
ItemReader extend.A convenient strategy for providing SqlParameterSource for named parameter SQL updates.
Marker interface defining a contract for periodically storing state and restoring from
that state should an error occur.
Exception representing any errors encountered while processing a stream.
Convenience interface that combines
ItemStream and ItemReader .Empty method implementation of
ItemStream.Convenience interface that combines
ItemStream and ItemWriter .
Basic interface for generic output operations.
Delegates item processing to a custom method - passes the item as an argument for the
delegate method.
A base exception class that all exceptions thrown from an
ItemWriter extend.A json object marshaller that uses
Jackson to marshal an object into a
json representation.
Implementation of
JsonObjectReader based on
Jackson.ItemWriter that uses the batching features from
NamedParameterJdbcTemplate to execute a batch of statements for all items
provided.A builder implementation for the
JdbcBatchItemWriter.
Simple item reader implementation that opens a JDBC cursor and continually retrieves
the next row in the ResultSet.
Builder for the
JdbcCursorItemReaderItemReader for reading database records using
JDBC in a paging fashion.This is a builder for the
JdbcPagingItemReader.Helper methods for SQL statement parameter parsing.
An
ItemReader for JMS using a JmsTemplate.Creates a fully qualified JmsItemReader.
An
ItemWriter for JMS using a JmsTemplate.Creates a fully qualified JmsItemWriter.
A
MethodArgumentsKeyGenerator for JMSA
NewMethodArgumentsIdentifier for JMS that looks for a message in the
arguments and checks its delivery status.ItemStreamReader implementation based on JPA
Query.getResultStream().Builder for
JpaCursorItemReader.ItemWriter that is using a JPA
EntityManagerFactory to merge any Entities that aren't part of the persistence context.A builder for the
JpaItemWriter.
This query provider creates JPA named
Querys.
This query provider creates JPA
Querys from injected native SQL queries.ItemReader for reading database records built on
top of JPA.Creates a fully qualified JpaPagingItemReader.
Interface defining the functionality to be provided for generating queries for use with
JPA
ItemReaders or other custom built artifacts.Item writer that writes data in json format to an output file.
Builder for
JsonFileItemWriter.ItemStreamReader implementation that reads Json objects from a Resource
having the following format:A builder for
JsonItemReader.Interpret a line as a JSON object and parse it up to a Map.
Strategy interface to marshal an object into a json representation.
Strategy interface for Json readers.
JSON-based record separator.
An
ItemReader implementation for Apache Kafka.A builder implementation for the
KafkaItemReader.
An
ItemWriter implementation for Apache Kafka using a KafkaTemplate
with default topic configured.A builder implementation for the
KafkaItemWriterA base class to implement any
ItemWriter that writes to a key value store using
a Converter to derive a key from an itemComparator to sort resources by the file last modified time.
Creates a fully qualified LdifReader.
Interface used to create string representing object.
Callback interface for handling a line from file.
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.
Interface that is used by framework to split string obtained typically from a file into
tokens.
An
ItemReader that pulls data from a list.Item writer that writes items to a
List.Implementation of
ExceptionHandler based on an Classifier.Logging levels for the handler.
This class is used to handle errors that occur when email messages are unable to be
sent.
Creates a fully qualified MappingLdifReader.
MariaDB implementation of a
PagingQueryProvider using database specific
features.A strategy interface for invoking a method.
Utility methods for create MethodInvoker instances.
Strategy interface for detecting a single Method on a Class.
A simple
ItemWriter that can send mail messages.Cursor-based
ItemReader implementation for MongoDB.Deprecated, for removal: This API element is subject to removal in a future version.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
MongoPagingItemReaderBuilder instead.
A
ItemWriter implementation that writes to a MongoDB store using an
implementation of Spring Data's MongoOperations.Operation mode of the item writer.
A builder implementation for the
MongoItemWriter
Restartable
ItemReader that reads documents from MongoDB via a paging
technique.Builder for
MongoPagingItemReader.Reads items from multiple resources sequentially - resource list is given by
MultiResourceItemReader.setResources(Resource[]), the actual reading is delegated to
MultiResourceItemReader.setDelegate(ResourceAwareItemReaderItemStream).A builder implementation for the
MultiResourceItemReader.Wraps a
ResourceAwareItemWriterItemStream and creates a new output resource
when the count of items written in current resource exceeds
MultiResourceItemWriter.setItemCountLimitPerResource(int).A builder implementation for the
MultiResourceItemWriter.MySQL implementation of a
PagingQueryProvider using database specific features.Deprecated.
since 5.0 in favor of the item reader from ...
Deprecated.
since 5.0 in favor of the item reader builder from ...
Deprecated.
since 5.0 in favor of the item writer from ...
Deprecated.
since 5.0 in favor of the item writer builder from ...
Callback that delegates to another callback, via a
RepeatOperations instance.Exception thrown when errors are encountered with the underlying resource.
Exception indicating that an error has been encountered doing I/O from a reader, and
the exception should be considered fatal.
Delegating XMLEventWriter, which ignores start and end document events, but passes
through everything else.
Oracle implementation of a
PagingQueryProvider using database
specific features.The direction of the sort in an ORDER BY clause.
Interface defining the functionality to be provided for generating paging queries for
use with Paging Item Readers.
Exception indicating that an error has been encountered parsing IO, typically from a
file.
FieldExtractor that just returns the original item.Pass through
FieldSetMapper useful for passing a FieldSet back directly
rather than a mapped object.Simple
ItemProcessor that does nothing - simply passes its argument through to
the caller.A
LineAggregator implementation that simply calls Object.toString() on
the given objectPass through
LineMapper useful for passing the original String back
directly rather than a mapped object.
A
LineMapper implementation that stores a mapping of String patterns to
delegate LineTokenizers as well as a mapping of String patterns to delegate
FieldSetMappers.A
LineTokenizer implementation that stores a mapping of String patterns to
delegate LineTokenizers.
A specialisation of
ItemReader that allows the user to look ahead into the
stream of items.Interface for polling a
Callable instance provided by the user.Postgres implementation of a
PagingQueryProvider using database
specific features.A filtering
ItemProcessor that is based on a Predicate.Utility to convert a Properties object to a String and back.
Delegates processing to a custom method - extracts property values from item object and
uses them as arguments for the delegate method.
A class to represent ranges.
Property editor implementation which parses string and creates array of ranges.
Exception indicating that an
ItemReader needed to be opened before read.This interface can be used to operate on skipped records during open in the
LdifReader and the MappingLdifReader.This is a field extractor for a Java record.
This is a
FieldSetMapper that supports Java records mapping (requires JKD 14 or
higher).This interface should be implemented to map
LdapAttributes
objects to POJOs.Policy for text file-based input sources to determine the end of a record, e.g. a
record might be a single line, or it might be multiple lines terminated by a semicolon.
An implementation of
LineAggregator that concatenates a collection of items of
a common type with a line separator.Item reader for Redis based on Spring Data Redis.
Builder for
RedisItemReader.
An
ItemWriter implementation for Redis using a RedisTemplate .Builder for
RedisItemWriter.Provides reflection based utilities for Spring Batch that are not available in Spring
Framework.
Line-tokenizer using a regular expression to filter out data (by using matching and
non-matching groups).
Callback interface for batch operations.
Base interface for context which controls the state and completion / termination of a
batch step.
Helper class for policies that need to count the number of occurrences of some event
(e.g. an exception type in the context) in the scope of a batch.
Internal interface for extensions of
RepeatTemplate.Interface for listeners to the batch process.
Deprecated.
as of v5.0 in favor of the default methods in
RepeatListener.The main interface providing access to batch operations.
A
MethodInterceptor that can be used to automatically repeat calls to a method
on a service.Global variable support for repeat clients.
Simple implementation and base class for batch templates implementing
RepeatOperations.
A
ItemReader that reads records utilizing a
PagingAndSortingRepository.A builder implementation for the
RepositoryItemReader.
A
ItemWriter wrapper for a
CrudRepository from Spring Data.A builder implementation for the
RepositoryItemWriter.Establishes a proxy that will capture a the Repository and the associated
methodName that will be used by the writer.
Marker interface indicating that an item should have the Spring
Resource in
which it was read from, set on it.ItemReader which produces Resource instances from an array.Strategy interface for translating resource index into unique filename suffix.
Deprecated, for removal: This API element is subject to removal in a future version.
since 5.0 with no replacement.
Implementation of
ExceptionHandler that rethrows when exceptions of a given
type reach a threshold.ItemProcessor implementation that passes the
current item to process to the provided script.Creates a fully qualified ScriptItemProcessor.
A
BufferedReaderFactory useful for reading simple binary (or text) files with
no line endings, such as those produced by mainframe copy books.Policy for terminating a batch after a fixed number of operations.
Simple implementation of exception handler which looks for given exception types.
A simple
ItemWriter that can send mail messages.Creates a fully qualified SimpleMailMessageItemWriter.
Simple implementation of the
MethodInvoker interface that invokes a method on
an object.Simplest possible
RecordSeparatorPolicy - treats all lines as record endings.Trivial implementation of
ResourceSuffixCreator that uses the index itself as
suffix, separated by dot.
A
PeekableItemReader that allows the user to peek one item ahead.Creates a fully qualified SingleItemPeekeableItemReader.
Wrapper for an item and its exception if it failed processing.
An implementation of
Converter that uses SpEL to map a Value to a keyAdapts the
Validator interface to
Validator.SQLite implementation of a
PagingQueryProvider using database
specific features.Factory bean for
PagingQueryProvider interface.Utility class that generates the actual SQL statements used by query providers.
SQL Server implementation of a
PagingQueryProvider using database
specific features.Deprecated, for removal: This API element is subject to removal in a future version.
since 5.2.1 with no replacement.
Item reader for reading XML input based on StAX.
A fluent builder for the
StaxEventItemReaderAn implementation of
ItemWriter which uses StAX and Marshaller for
serializing object to XML.A builder for the
StaxEventItemWriter.Callback interface for writing to an XML file - useful e.g. for handling headers and
footers.
Item reader implementation that executes a stored procedure and then reads the returned
cursor and continually retrieves the next row in the
ResultSet.A fluent builder API for the configuration of a
StoredProcedureItemReader.A
RecordSeparatorPolicy that looks for an exact match for a String at the end
of a line (e.g. a semicolon).Adapter for a
Supplier to an ItemReader.Sybase implementation of a
PagingQueryProvider using database specific
features.An
AttributeAccessor that synchronizes on a mutex (not this) before modifying
or accessing the underlying attributes.This is an
ItemReader decorator with a synchronized ItemReader.read()
method.Builder for
SynchronizedItemReader.This is a simple ItemStreamReader decorator with a synchronized ItemReader.read()
method - which makes a non-thread-safe ItemReader thread-safe.
Creates a fully qualified SynchronizedItemStreamReader.
An
ItemStreamWriter decorator with a synchronized
write() method.Creates a fully qualified
SynchronizedItemStreamWriter.This is an
ItemWriter decorator with a synchronized ItemWriter.write(org.springframework.batch.item.Chunk<? extends T>)
method.Builder for
SynchronizedItemWriter.Deprecated, for removal: This API element is subject to removal in a future version.
since 5.2 with no replacement.
Provides
This implementation is sufficient to be used to configure transactional behaviour for each item by making the
This class is thread-safe if its collaborators are thread-safe (interceptors, terminationPolicy, callback).
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).
Deprecated, for removal: This API element is subject to removal in a future version.
since 5.0 with no replacement.
Termination policy that times out after a fixed period.
Wrapper for a
FileChannel that delays actually writing to or closing the buffer
if a transaction is active.
Factory for transaction aware objects (like lists, sets, maps).
Delegating XMLEventWriter, which collects the QNames of elements that were opened but
not closed.
Used to signal an unexpected end of an input or message stream.
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.
Simple implementation of
ItemProcessor that validates input and returns it
without modifications.This exception should be thrown when there are validation errors.
Interface used to validate objects.
Unchecked exception indicating that an error has occurred while trying to clear a
buffer on a rollback.
Exception indicating that an
ItemWriter needed to be opened before being
written to.
MongoPagingItemReaderinstead.