org.springframework.batch.core.step.item

## Class SimpleChunkProvider<I>

- java.lang.Object
- - org.springframework.batch.core.step.item.SimpleChunkProvider<I>

- All Implemented Interfaces:
    ChunkProvider<I>
  Direct Known Subclasses:
    FaultTolerantChunkProvider

      public class SimpleChunkProvider<I>
      extends java.lang.Object
      implements ChunkProvider<I>

  Simple implementation of the ChunkProvider interface that does basic chunk providing from an `ItemReader`.
  Author:
    Dave Syer, Michael Minella
  See Also:
    `ChunkOrientedTasklet`

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected ItemReader<? extends I>` | `itemReader`
    `protected org.apache.commons.logging.Log` | `logger`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `SimpleChunkProvider(ItemReader<? extends I> itemReader, RepeatOperations repeatOperations)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected I` | `doRead()` Surrounds the read call with listener callbacks.
    `protected MulticasterBatchListener<I,?>` | `getListener()`
    `void` | `postProcess(StepContribution contribution, Chunk<I> chunk)`
    `Chunk<I>` | `provide(StepContribution contribution)`
    `protected I` | `read(StepContribution contribution, Chunk<I> chunk)` Delegates to `doRead()`.
    `void` | `registerListener(StepListener listener)` Register a listener for callbacks at the appropriate stages in a process.
    `void` | `setListeners(java.util.List<? extends StepListener> listeners)` Register some `StepListener`s with the handler.

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

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

- - ### Field Detail

    - #### logger

          protected final org.apache.commons.logging.Log logger

    - #### itemReader

          protected final ItemReader<? extends I> itemReader

  - ### Constructor Detail

    - #### SimpleChunkProvider

          public SimpleChunkProvider(ItemReader<? extends I> itemReader,
                                     RepeatOperations repeatOperations)

  - ### Method Detail

    - #### setListeners

          public void setListeners(java.util.List<? extends StepListener> listeners)

      Register some `StepListener`s with the handler. Each will get the callbacks in the order specified at the correct stage.
      Parameters:
        `listeners` -

    - #### registerListener

          public void registerListener(StepListener listener)

      Register a listener for callbacks at the appropriate stages in a process.
      Parameters:
        `listener` - a `StepListener`

    - #### getListener

          protected MulticasterBatchListener<I,?> getListener()

      Returns:
        the listener

    - #### doRead

          protected final I doRead()
                            throws java.lang.Exception

      Surrounds the read call with listener callbacks.
      Returns:
        item
      Throws:
        `java.lang.Exception`

    - #### provide

          public Chunk<I> provide(StepContribution contribution)
                           throws java.lang.Exception

      Specified by:
        `provide` in interface `ChunkProvider<I>`
      Throws:
        `java.lang.Exception`

    - #### postProcess

          public void postProcess(StepContribution contribution,
                                  Chunk<I> chunk)

      Specified by:
        `postProcess` in interface `ChunkProvider<I>`

    - #### read

          protected I read(StepContribution contribution,
                           Chunk<I> chunk)
                    throws SkipOverflowException,
                           java.lang.Exception

      Delegates to `doRead()`. Subclasses can add additional behaviour (e.g. exception handling).
      Parameters:
        `contribution` - the current step execution contribution
        `chunk` - the current chunk
      Returns:
        a new item for processing
      Throws:
        `SkipOverflowException` - if specifically the chunk is accumulating too much data (e.g. skips) and it wants to force a commit.
        `java.lang.Exception` - if there is a generic issue