org.springframework.batch.core.step.builder

## Class SimpleStepBuilder<I,O>

- java.lang.Object
- - org.springframework.batch.core.step.builder.StepBuilderHelper<AbstractTaskletStepBuilder<B>>
  - - org.springframework.batch.core.step.builder.AbstractTaskletStepBuilder<SimpleStepBuilder<I,O>>
    - - org.springframework.batch.core.step.builder.SimpleStepBuilder<I,O>

- Direct Known Subclasses:
    FaultTolerantStepBuilder, JsrSimpleStepBuilder

      public class SimpleStepBuilder<I,O>
      extends AbstractTaskletStepBuilder<SimpleStepBuilder<I,O>>

  Step builder for simple item processing (chunk oriented) steps. Items are read and cached in chunks, and then processed (transformed) and written (optionally either the processor or the writer can be omitted) all in the same transaction.
  Since:
    2.2
  Author:
    Dave Syer, Mahmoud Ben Hassine
  See Also:
    `for a step that handles retry and skip of failed items`

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class org.springframework.batch.core.step.builder.StepBuilderHelper

      `StepBuilderHelper.CommonStepProperties`

  - ### Field Summary

    - ### Fields inherited from class org.springframework.batch.core.step.builder.AbstractTaskletStepBuilder

      `chunkListeners`

    - ### Fields inherited from class org.springframework.batch.core.step.builder.StepBuilderHelper

      `logger, properties`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `SimpleStepBuilder(SimpleStepBuilder<I,O> parent)` Create a new builder initialized with any properties in the parent.
    `` | `SimpleStepBuilder(StepBuilderHelper<?> parent)` Create a new builder initialized with any properties in the parent.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `TaskletStep` | `build()` Build a step with the reader, writer, processor as provided.
    `SimpleStepBuilder<I,O>` | `chunk(CompletionPolicy completionPolicy)` Sets a completion policy for the chunk processing.
    `SimpleStepBuilder<I,O>` | `chunk(int chunkSize)` Sets the chunk size or commit interval for this step.
    `SimpleStepBuilder<I,O>` | `chunkOperations(RepeatOperations repeatTemplate)` Instead of a `chunk size` or `completion policy` you can provide a complete repeat operations instance that handles the iteration over the item reader.
    `protected RepeatOperations` | `createChunkOperations()`
    `protected Tasklet` | `createTasklet()`
    `FaultTolerantStepBuilder<I,O>` | `faultTolerant()`
    `protected CompletionPolicy` | `getChunkCompletionPolicy()`
    `protected int` | `getChunkSize()`
    `protected java.util.Set<StepListener>` | `getItemListeners()`
    `protected ItemProcessor<? super I,? extends O>` | `getProcessor()`
    `protected ItemReader<? extends I>` | `getReader()`
    `protected ItemWriter<? super O>` | `getWriter()`
    `protected boolean` | `isReaderTransactionalQueue()`
    `SimpleStepBuilder<I,O>` | `listener(ItemProcessListener<? super I,? super O> listener)` Register an item processor listener.
    `SimpleStepBuilder<I,O>` | `listener(ItemReadListener<? super I> listener)` Register an item reader listener.
    `SimpleStepBuilder<I,O>` | `listener(ItemWriteListener<? super O> listener)` Register an item writer listener.
    `SimpleStepBuilder<I,O>` | `listener(java.lang.Object listener)` Registers objects using the annotation based listener configuration.
    `SimpleStepBuilder<I,O>` | `processor(java.util.function.Function<? super I,? extends O> function)` A `Function` to be delegated to as an `ItemProcessor`.
    `SimpleStepBuilder<I,O>` | `processor(ItemProcessor<? super I,? extends O> processor)` An item processor that processes or transforms a stream of items.
    `SimpleStepBuilder<I,O>` | `reader(ItemReader<? extends I> reader)` An item reader that provides a stream of items.
    `SimpleStepBuilder<I,O>` | `readerIsTransactionalQueue()` Sets a flag to say that the reader is transactional (usually a queue), which is to say that failed items might be rolled back and re-presented in a subsequent transaction.
    `protected void` | `registerAsStreamsAndListeners(ItemReader<? extends I> itemReader, ItemProcessor<? super I,? extends O> itemProcessor, ItemWriter<? super O> itemWriter)`
    `protected void` | `registerStepListenerAsItemListener()`
    `SimpleStepBuilder<I,O>` | `writer(ItemWriter<? super O> writer)` An item writer that writes a chunk of items.

    - ### Methods inherited from class org.springframework.batch.core.step.builder.AbstractTaskletStepBuilder

      `concurrent, exceptionHandler, getExceptionHandler, getStepOperations, getStreams, getTaskExecutor, getThrottleLimit, getTransactionAttribute, listener, registerStepListenerAsChunkListener, stepOperations, stream, taskExecutor, throttleLimit, transactionAttribute`

    - ### Methods inherited from class org.springframework.batch.core.step.builder.StepBuilderHelper

      `allowStartIfComplete, enhance, getJobRepository, getName, getTransactionManager, isAllowStartIfComplete, listener, repository, startLimit, transactionManager`

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

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

- - ### Constructor Detail

    - #### SimpleStepBuilder

          public SimpleStepBuilder(StepBuilderHelper<?> parent)

      Create a new builder initialized with any properties in the parent. The parent is copied, so it can be re-used.
      Parameters:
        `parent` - a parent helper containing common step properties

    - #### SimpleStepBuilder

          protected SimpleStepBuilder(SimpleStepBuilder<I,O> parent)

      Create a new builder initialized with any properties in the parent. The parent is copied, so it can be re-used.
      Parameters:
        `parent` - a parent helper containing common step properties

  - ### Method Detail

    - #### faultTolerant

          public FaultTolerantStepBuilder<I,O> faultTolerant()

    - #### build

          public TaskletStep build()

      Build a step with the reader, writer, processor as provided.
      Overrides:
        `build` in class `AbstractTaskletStepBuilder<SimpleStepBuilder<I,O>>`
      Returns:
        a tasklet step fully configured and ready to execute
      See Also:
        `AbstractTaskletStepBuilder.build()`

    - #### registerStepListenerAsItemListener

          protected void registerStepListenerAsItemListener()

    - #### createTasklet

          protected Tasklet createTasklet()

      Specified by:
        `createTasklet` in class `AbstractTaskletStepBuilder<SimpleStepBuilder<I,O>>`

    - #### chunk

          public SimpleStepBuilder<I,O> chunk(int chunkSize)

      Sets the chunk size or commit interval for this step. This is the maximum number of items that will be read before processing starts in a single transaction. Not compatible with `completionPolicy` .
      Parameters:
        `chunkSize` - the chunk size (a.k.a commit interval)
      Returns:
        this for fluent chaining

    - #### chunk

          public SimpleStepBuilder<I,O> chunk(CompletionPolicy completionPolicy)

      Sets a completion policy for the chunk processing. Items are read until this policy determines that a chunk is complete, giving more control than with just the `chunk size` (or commit interval).
      Parameters:
        `completionPolicy` - a completion policy for the chunk
      Returns:
        this for fluent chaining

    - #### reader

          public SimpleStepBuilder<I,O> reader(ItemReader<? extends I> reader)

      An item reader that provides a stream of items. Will be automatically registered as a `AbstractTaskletStepBuilder.stream(ItemStream)` or listener if it implements the corresponding interface. By default assumed to be non-transactional.
      Parameters:
        `reader` - an item reader
      Returns:
        this for fluent chaining
      See Also:
        `readerTransactionalQueue`

    - #### writer

          public SimpleStepBuilder<I,O> writer(ItemWriter<? super O> writer)

      An item writer that writes a chunk of items. Will be automatically registered as a `AbstractTaskletStepBuilder.stream(ItemStream)` or listener if it implements the corresponding interface.
      Parameters:
        `writer` - an item writer
      Returns:
        this for fluent chaining

    - #### processor

          public SimpleStepBuilder<I,O> processor(ItemProcessor<? super I,? extends O> processor)

      An item processor that processes or transforms a stream of items. Will be automatically registered as a `AbstractTaskletStepBuilder.stream(ItemStream)` or listener if it implements the corresponding interface.
      Parameters:
        `processor` - an item processor
      Returns:
        this for fluent chaining

    - #### processor

          public SimpleStepBuilder<I,O> processor(java.util.function.Function<? super I,? extends O> function)

      A `Function` to be delegated to as an `ItemProcessor`. If this is set, it will take precedence over any `ItemProcessor` configured via `processor(ItemProcessor)`.
      Parameters:
        `function` - the function to delegate item processing to
      Returns:
        this for fluent chaining

    - #### readerIsTransactionalQueue

          public SimpleStepBuilder<I,O> readerIsTransactionalQueue()

      Sets a flag to say that the reader is transactional (usually a queue), which is to say that failed items might be rolled back and re-presented in a subsequent transaction. Default is false, meaning that the items are read outside a transaction and possibly cached.
      Returns:
        this for fluent chaining

    - #### listener

          public SimpleStepBuilder<I,O> listener(java.lang.Object listener)

      Registers objects using the annotation based listener configuration.
      Overrides:
        `listener` in class `AbstractTaskletStepBuilder<SimpleStepBuilder<I,O>>`
      Parameters:
        `listener` - the object that has a method configured with listener annotation
      Returns:
        this for fluent chaining

    - #### listener

          public SimpleStepBuilder<I,O> listener(ItemReadListener<? super I> listener)

      Register an item reader listener.
      Parameters:
        `listener` - the listener to register
      Returns:
        this for fluent chaining

    - #### listener

          public SimpleStepBuilder<I,O> listener(ItemWriteListener<? super O> listener)

      Register an item writer listener.
      Parameters:
        `listener` - the listener to register
      Returns:
        this for fluent chaining

    - #### listener

          public SimpleStepBuilder<I,O> listener(ItemProcessListener<? super I,? super O> listener)

      Register an item processor listener.
      Parameters:
        `listener` - the listener to register
      Returns:
        this for fluent chaining

    - #### chunkOperations

          public SimpleStepBuilder<I,O> chunkOperations(RepeatOperations repeatTemplate)

      Instead of a `chunk size` or `completion policy` you can provide a complete repeat operations instance that handles the iteration over the item reader.
      Parameters:
        `repeatTemplate` - a complete repeat template for the chunk
      Returns:
        this for fluent chaining

    - #### createChunkOperations

          protected RepeatOperations createChunkOperations()

    - #### getReader

          protected ItemReader<? extends I> getReader()

    - #### getWriter

          protected ItemWriter<? super O> getWriter()

    - #### getProcessor

          protected ItemProcessor<? super I,? extends O> getProcessor()

    - #### getChunkSize

          protected int getChunkSize()

    - #### isReaderTransactionalQueue

          protected boolean isReaderTransactionalQueue()

    - #### getItemListeners

          protected java.util.Set<StepListener> getItemListeners()

    - #### getChunkCompletionPolicy

          protected CompletionPolicy getChunkCompletionPolicy()

      Returns:
        a `CompletionPolicy` consistent with the chunk size and injected policy (if present).

    - #### registerAsStreamsAndListeners

          protected void registerAsStreamsAndListeners(ItemReader<? extends I> itemReader,
                                                       ItemProcessor<? super I,? extends O> itemProcessor,
                                                       ItemWriter<? super O> itemWriter)