128 lines
7.6 KiB
Plaintext
128 lines
7.6 KiB
Plaintext
|
|
[[listOfReadersAndWriters]]
|
|
|
|
[appendix]
|
|
[[list-of-itemreaders-and-itemwriters]]
|
|
= List of ItemReaders and ItemWriters
|
|
|
|
[[itemReadersAppendix]]
|
|
== Item Readers
|
|
|
|
.Available Item Readers
|
|
[options="header"]
|
|
|===============
|
|
|Item Reader|Description|Thread-safe
|
|
|`AbstractItemStreamItemReader`|Abstract base class that combines the `ItemStream` and `ItemReader` interfaces.|Yes
|
|
|`AbstractItemCountingItemStreamItemReader`|Abstract base class that provides basic
|
|
restart capabilities by counting the number of items returned from
|
|
an `ItemReader`.|No
|
|
|`AbstractPagingItemReader`|Abstract base class that provides basic paging features|No
|
|
|`AbstractPaginatedDataItemReader`|Abstract base class that provides basic paging features based on Spring Data's
|
|
paginated facilities|No
|
|
|`AggregateItemReader`|An `ItemReader` that delivers a list as its
|
|
item, storing up objects from the injected `ItemReader` until they
|
|
are ready to be packed out as a collection. This class must be used
|
|
as a wrapper for a custom `ItemReader` that can identify the record
|
|
boundaries. The custom reader should mark the beginning and end of
|
|
records by returning an `AggregateItem` which responds `true` to its
|
|
query methods (`isHeader()` and `isFooter()`). Note that this reader
|
|
is not part of the library of readers provided by Spring Batch
|
|
but given as a sample in `spring-batch-samples`.|Yes
|
|
|`AmqpItemReader`|Given a Spring `AmqpTemplate`, it provides
|
|
synchronous receive methods. The `receiveAndConvert()` method
|
|
lets you receive POJO objects.|Yes
|
|
|`KafkaItemReader`|An `ItemReader` that reads messages from an Apache Kafka topic.
|
|
It can be configured to read messages from multiple partitions of the same topic.
|
|
This reader stores message offsets in the execution context to support restart capabilities.|No
|
|
|`FlatFileItemReader`|Reads from a flat file. Includes `ItemStream`
|
|
and `Skippable` functionality. See link:readersAndWriters.html#flatFileItemReader["`FlatFileItemReader`"].|No
|
|
|`ItemReaderAdapter`|Adapts any class to the
|
|
`ItemReader` interface.|Yes
|
|
|`JdbcCursorItemReader`|Reads from a database cursor over JDBC. See
|
|
link:readers-and-writers/database.html#cursorBasedItemReaders["`Cursor-based ItemReaders`"].|No
|
|
|`JdbcPagingItemReader`|Given an SQL statement, pages through the rows,
|
|
such that large datasets can be read without running out of
|
|
memory.|Yes
|
|
|`JmsItemReader`|Given a Spring `JmsOperations` object and a JMS
|
|
destination or destination name to which to send errors, provides items
|
|
received through the injected `JmsOperations#receive()`
|
|
method.|Yes
|
|
|`JpaCursorItemReader`|Executes a JPQL query and iterates over the returned result set|No
|
|
|`JpaPagingItemReader`|Given a JPQL query, pages through the
|
|
rows, such that large datasets can be read without running out of
|
|
memory.|Yes
|
|
|`ListItemReader`|Provides the items from a list, one at a time.|No
|
|
|`MongoItemReader`|Given a `MongoOperations` object and a JSON-based MongoDB
|
|
query, provides items received from the `MongoOperations#find()` method.|Yes
|
|
|`Neo4jItemReader`|Given a `Neo4jOperations` object and the components of a
|
|
Cyhper query, items are returned as the result of the Neo4jOperations.query
|
|
method.|Yes
|
|
|`RepositoryItemReader`|Given a Spring Data `PagingAndSortingRepository` object,
|
|
a `Sort`, and the name of method to execute, returns items provided by the
|
|
Spring Data repository implementation.|Yes
|
|
|`StoredProcedureItemReader`|Reads from a database cursor resulting from the
|
|
execution of a database stored procedure. See link:readersAndWriters.html#StoredProcedureItemReader[`StoredProcedureItemReader`]|No
|
|
|`StaxEventItemReader`|Reads over StAX. see link:readersAndWriters.html#StaxEventItemReader[`StaxEventItemReader`].|No
|
|
|`JsonItemReader`|Reads items from a Json document. see link:readersAndWriters.html#JsonItemReader[`JsonItemReader`].|No
|
|
|`AvroItemReader`|Reads items from a resource containing serialized Avro objects.|No
|
|
|`LdifReader`|Reads items from a LDIF resource and returns them as `LdapAttributes`|No
|
|
|`MappingLdifReader`|Reads items from a LDIF resource and uses a `RecordMapper` to map them to domain objects|No
|
|
|
|
|===============
|
|
|
|
|
|
[[itemWritersAppendix]]
|
|
== Item Writers
|
|
|
|
.Available Item Writers
|
|
[options="header"]
|
|
|===============
|
|
|Item Writer|Description|Thread-safe
|
|
|`AbstractItemStreamItemWriter`|Abstract base class that combines the`ItemStream` and`ItemWriter` interfaces.|Yes
|
|
|`AmqpItemWriter`|Given a Spring `AmqpTemplate`, provides
|
|
for a synchronous `send` method. The `convertAndSend(Object)`
|
|
method lets you send POJO objects.|Yes
|
|
|`CompositeItemWriter`|Passes an item to the `write` method of each item
|
|
in an injected `List` of `ItemWriter` objects.|Yes
|
|
|`FlatFileItemWriter`|Writes to a flat file. Includes `ItemStream` and
|
|
Skippable functionality. See link:readersAndWriters.html#flatFileItemWriter["`FlatFileItemWriter`"].|No
|
|
|`ItemWriterAdapter`|Adapts any class to the
|
|
`ItemWriter` interface.|Yes
|
|
|`JdbcBatchItemWriter`|Uses batching features from a
|
|
`PreparedStatement`, if available, and can
|
|
take rudimentary steps to locate a failure during a
|
|
`flush`.|Yes
|
|
|`JmsItemWriter`|Using a `JmsOperations` object, items are written
|
|
to the default queue through the `JmsOperations#convertAndSend()` method.|Yes
|
|
|`JpaItemWriter`|This item writer is JPA `EntityManager`-aware
|
|
and handles some transaction-related work that a non-"`JPA-aware`"
|
|
`ItemWriter` would not need to know about and
|
|
then delegates to another writer to do the actual writing.|Yes
|
|
|`KafkaItemWriter`|Using a `KafkaTemplate` object, items are written to the default topic through the
|
|
`KafkaTemplate#sendDefault(Object, Object)` method by using a `Converter` to map the key from the item.
|
|
A delete flag can also be configured to send delete events to the topic.|No
|
|
|`MimeMessageItemWriter`|Using Spring's `JavaMailSender`, items of type `MimeMessage`
|
|
are sent as mail messages.|Yes
|
|
|`MongoItemWriter`|Given a `MongoOperations` object, items are written
|
|
through the `MongoOperations.save(Object)` method. The actual write is delayed
|
|
until the last possible moment before the transaction commits.|Yes
|
|
|`Neo4jItemWriter`|Given a `Neo4jOperations` object, items are persisted through the
|
|
`save(Object)` method or deleted through the `delete(Object)`, as dictated by the
|
|
`ItemWriter's` configuration|Yes
|
|
|`PropertyExtractingDelegatingItemWriter`|Extends `AbstractMethodInvokingDelegator`
|
|
creating arguments on the fly. Arguments are created by retrieving
|
|
the values from the fields in the item to be processed (through a
|
|
`SpringBeanWrapper`), based on an injected array of field
|
|
names.|Yes
|
|
|`RepositoryItemWriter`|Given a Spring Data `CrudRepository` implementation,
|
|
items are saved through the method specified in the configuration.|Yes
|
|
|`StaxEventItemWriter`|Uses a `Marshaller` implementation to
|
|
convert each item to XML and then writes it to an XML file by using
|
|
StAX.|No
|
|
|`JsonFileItemWriter`|Uses a `JsonObjectMarshaller` implementation to
|
|
convert each item to Json and then writes it to a Json file.|No
|
|
|`AvroItemWriter`|Serializes data to an `WritableResource` using Avro|No
|
|
|`ListItemWriter`|Item writer that writes items to a `List`.|No
|
|
|
|
|===============
|