Package org.springframework.batch.item.support

# Class SingleItemPeekableItemReader<T>

java.lang.Object
org.springframework.batch.item.support.SingleItemPeekableItemReader<T>

All Implemented Interfaces:
  `ItemReader<T>`, `ItemStream`, `ItemStreamReader<T>`, `PeekableItemReader<T>`

public class SingleItemPeekableItemReader<T> extends Object implements ItemStreamReader<T>, PeekableItemReader<T>

A `PeekableItemReader` that allows the user to peek one item ahead. Repeated calls to `peek()` will return the same item, and this will be the next item returned from `read()`.

Intentionally not thread-safe: it wouldn't be possible to honour the peek in multiple threads because only one of the threads that peeked would get that item in the next call to read.

Author:
  Dave Syer

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `SingleItemPeekableItemReader()`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `close()`
  If the delegate is an `ItemStream`, just pass the call on, otherwise reset the peek cache.
  `void`
  `open(ExecutionContext executionContext)`
  If the delegate is an `ItemStream`, just pass the call on, otherwise reset the peek cache.
  `T`
  `peek()`
  Peek at the next item, ensuring that if the delegate is an `ItemStream` the state is stored for the next call to `update(ExecutionContext)`.
  `T`
  `read()`
  Get the next item from the delegate (whether or not it has already been peeked at).
  `void`
  `setDelegate(ItemReader<T> delegate)`
  The item reader to use as a delegate.
  `void`
  `update(ExecutionContext executionContext)`
  If there is a cached peek, then retrieve the execution context state from that point.

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Constructor Details

  - ### SingleItemPeekableItemReader

    public SingleItemPeekableItemReader()

- ## Method Details

  - ### setDelegate

    public void setDelegate(ItemReader<T> delegate)
    The item reader to use as a delegate. Items are read from the delegate and passed to the caller in `read()`.
    Parameters:
      `delegate` - the delegate to set

  - ### read

    @Nullable public T read() throws Exception, UnexpectedInputException, ParseException
    Get the next item from the delegate (whether or not it has already been peeked at).
    Specified by:
      `read` in interface `ItemReader<T>`
    Returns:
      T the item to be processed or `null` if the data source is exhausted
    Throws:
      `ParseException` - if there is a problem parsing the current record (but the next one may still be valid)
      `NonTransientResourceException` - if there is a fatal exception in the underlying resource. After throwing this exception implementations should endeavour to return null from subsequent calls to read.
      `UnexpectedInputException` - if there is an uncategorised problem with the input data. Assume potentially transient, so subsequent calls to read might succeed.
      `Exception` - if an there is a non-specific error.
    See Also:
      - `ItemReader.read()`

  - ### peek

    @Nullable public T peek() throws Exception, UnexpectedInputException, ParseException
    Peek at the next item, ensuring that if the delegate is an `ItemStream` the state is stored for the next call to `update(ExecutionContext)`.
    Specified by:
      `peek` in interface `PeekableItemReader<T>`
    Returns:
      the next item (or null if there is none).
    Throws:
      `Exception` - if there is a problem
      `UnexpectedInputException`
      `ParseException`
    See Also:
      - `PeekableItemReader.peek()`

  - ### close

    public void close() throws ItemStreamException
    If the delegate is an `ItemStream`, just pass the call on, otherwise reset the peek cache.
    Specified by:
      `close` in interface `ItemStream`
    Throws:
      `ItemStreamException` - if there is a problem
    See Also:
      - `ItemStream.close()`

  - ### open

    public void open(ExecutionContext executionContext) throws ItemStreamException
    If the delegate is an `ItemStream`, just pass the call on, otherwise reset the peek cache.
    Specified by:
      `open` in interface `ItemStream`
    Parameters:
      `executionContext` - the current context
    Throws:
      `ItemStreamException` - if there is a problem
    See Also:
      - `ItemStream.open(ExecutionContext)`

  - ### update

    public void update(ExecutionContext executionContext) throws ItemStreamException
    If there is a cached peek, then retrieve the execution context state from that point. If there is no peek cached, then call directly to the delegate.
    Specified by:
      `update` in interface `ItemStream`
    Parameters:
      `executionContext` - the current context
    Throws:
      `ItemStreamException` - if there is a problem
    See Also:
      - `ItemStream.update(ExecutionContext)`