Package org.springframework.batch.core.step.builder

# Class AbstractTaskletStepBuilder<B extends AbstractTaskletStepBuilder<B>>

java.lang.Object
org.springframework.batch.core.step.builder.StepBuilderHelper<AbstractTaskletStepBuilder<B>>
org.springframework.batch.core.step.builder.AbstractTaskletStepBuilder<B>

Type Parameters:
  `B` - the type of builder represented

Direct Known Subclasses:
  `SimpleStepBuilder`, `TaskletStepBuilder`

public abstract class AbstractTaskletStepBuilder<B extends AbstractTaskletStepBuilder<B>> extends StepBuilderHelper<AbstractTaskletStepBuilder<B>>
Base class for step builders that want to build a `TaskletStep`. Handles common concerns across all tasklet step variants, which are mostly to do with the type of tasklet they carry.

Since:
  2.2
Author:
  Dave Syer, Michael Minella, Mahmoud Ben Hassine

- ## Nested Class Summary

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

  `StepBuilderHelper.CommonStepProperties`

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `protected Set<ChunkListener>`
  `chunkListeners`

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

  `logger, properties`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `AbstractTaskletStepBuilder(StepBuilderHelper<?> parent)`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `TaskletStep`
  `build()`
  Build the step from the components collected by the fluent setters.
  `protected boolean`
  `concurrent()`
  Convenience method for subclasses to determine if the step is concurrent.
  `protected abstract Tasklet`
  `createTasklet()`
  `AbstractTaskletStepBuilder<B>`
  `exceptionHandler(ExceptionHandler exceptionHandler)`
  Sets the exception handler to use in the case of tasklet failures.
  `protected ExceptionHandler`
  `getExceptionHandler()`
  Convenience method for subclasses to access the exception handler that was injected by user.
  `protected RepeatOperations`
  `getStepOperations()`
  Convenience method for subclasses to access the step operations that were injected by user.
  `protected Set<ItemStream>`
  `getStreams()`
  `protected org.springframework.core.task.TaskExecutor`
  `getTaskExecutor()`
  `protected int`
  `getThrottleLimit()`
  `protected org.springframework.transaction.interceptor.TransactionAttribute`
  `getTransactionAttribute()`
  `B`
  `listener(Object listener)`
  Registers objects using the annotation based listener configuration.
  `AbstractTaskletStepBuilder<B>`
  `listener(ChunkListener listener)`
  Register a chunk listener.
  `protected void`
  `registerStepListenerAsChunkListener()`
  `AbstractTaskletStepBuilder<B>`
  `stepOperations(RepeatOperations repeatTemplate)`
  Sets the repeat template used for iterating the tasklet execution.
  `AbstractTaskletStepBuilder<B>`
  `stream(ItemStream stream)`
  Register a stream for callbacks that manage restart data.
  `AbstractTaskletStepBuilder<B>`
  `taskExecutor(org.springframework.core.task.TaskExecutor taskExecutor)`
  Provide a task executor to use when executing the tasklet.
  `AbstractTaskletStepBuilder<B>`
  `throttleLimit(int throttleLimit)`
  In the case of an asynchronous `taskExecutor(TaskExecutor)` the number of concurrent tasklet executions can be throttled (beyond any throttling provided by a thread pool).
  `AbstractTaskletStepBuilder<B>`
  `transactionAttribute(org.springframework.transaction.interceptor.TransactionAttribute transactionAttribute)`
  Sets the transaction attributes for the tasklet execution.

  ### 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`

- ## Field Details

  - ### chunkListeners

    protected Set<ChunkListener> chunkListeners

- ## Constructor Details

  - ### AbstractTaskletStepBuilder

    public AbstractTaskletStepBuilder(StepBuilderHelper<?> parent)

- ## Method Details

  - ### createTasklet

    protected abstract Tasklet createTasklet()

  - ### build

    public TaskletStep build()
    Build the step from the components collected by the fluent setters. Delegates first to `StepBuilderHelper.enhance(Step)` and then to `createTasklet()` in subclasses to create the actual tasklet.
    Returns:
      a tasklet step fully configured and ready to execute

  - ### registerStepListenerAsChunkListener

    protected void registerStepListenerAsChunkListener()

  - ### listener

    public AbstractTaskletStepBuilder<B> listener(ChunkListener listener)
    Register a chunk listener.
    Parameters:
      `listener` - the listener to register
    Returns:
      this for fluent chaining

  - ### listener

    public B listener(Object listener)
    Registers objects using the annotation based listener configuration.
    Overrides:
      `listener` in class `StepBuilderHelper<AbstractTaskletStepBuilder<B extends AbstractTaskletStepBuilder<B>>>`
    Parameters:
      `listener` - the object that has a method configured with listener annotation
    Returns:
      this for fluent chaining

  - ### stream

    public AbstractTaskletStepBuilder<B> stream(ItemStream stream)
    Register a stream for callbacks that manage restart data.
    Parameters:
      `stream` - the stream to register
    Returns:
      this for fluent chaining

  - ### taskExecutor

    public AbstractTaskletStepBuilder<B> taskExecutor(org.springframework.core.task.TaskExecutor taskExecutor)
    Provide a task executor to use when executing the tasklet. Default is to use a single-threaded (synchronous) executor.
    Parameters:
      `taskExecutor` - the task executor to register
    Returns:
      this for fluent chaining

  - ### throttleLimit

    public AbstractTaskletStepBuilder<B> throttleLimit(int throttleLimit)
    In the case of an asynchronous `taskExecutor(TaskExecutor)` the number of concurrent tasklet executions can be throttled (beyond any throttling provided by a thread pool). The throttle limit should be less than the data source pool size used in the job repository for this step.
    Parameters:
      `throttleLimit` - maximum number of concurrent tasklet executions allowed
    Returns:
      this for fluent chaining

  - ### exceptionHandler

    public AbstractTaskletStepBuilder<B> exceptionHandler(ExceptionHandler exceptionHandler)
    Sets the exception handler to use in the case of tasklet failures. Default is to rethrow everything.
    Parameters:
      `exceptionHandler` - the exception handler
    Returns:
      this for fluent chaining

  - ### stepOperations

    public AbstractTaskletStepBuilder<B> stepOperations(RepeatOperations repeatTemplate)
    Sets the repeat template used for iterating the tasklet execution. By default it will terminate only when the tasklet returns FINISHED (or null).
    Parameters:
      `repeatTemplate` - a repeat template with rules for iterating
    Returns:
      this for fluent chaining

  - ### transactionAttribute

    public AbstractTaskletStepBuilder<B> transactionAttribute(org.springframework.transaction.interceptor.TransactionAttribute transactionAttribute)
    Sets the transaction attributes for the tasklet execution. Defaults to the default values for the transaction manager, but can be manipulated to provide longer timeouts for instance.
    Parameters:
      `transactionAttribute` - a transaction attribute set
    Returns:
      this for fluent chaining

  - ### getStepOperations

    protected RepeatOperations getStepOperations()
    Convenience method for subclasses to access the step operations that were injected by user.
    Returns:
      the repeat operations used to iterate the tasklet executions

  - ### getExceptionHandler

    protected ExceptionHandler getExceptionHandler()
    Convenience method for subclasses to access the exception handler that was injected by user.
    Returns:
      the exception handler

  - ### concurrent

    protected boolean concurrent()
    Convenience method for subclasses to determine if the step is concurrent.
    Returns:
      true if the tasklet is going to be run in multiple threads

  - ### getTaskExecutor

    protected org.springframework.core.task.TaskExecutor getTaskExecutor()

  - ### getThrottleLimit

    protected int getThrottleLimit()

  - ### getTransactionAttribute

    protected org.springframework.transaction.interceptor.TransactionAttribute getTransactionAttribute()

  - ### getStreams

    protected Set<ItemStream> getStreams()