org.springframework.batch.repeat.support

## Class TaskExecutorRepeatTemplate

- java.lang.Object
- - org.springframework.batch.repeat.support.RepeatTemplate
  - - org.springframework.batch.repeat.support.TaskExecutorRepeatTemplate

- All Implemented Interfaces:
    RepeatOperations

      public class TaskExecutorRepeatTemplate
      extends RepeatTemplate

  Provides `RepeatOperations` support including interceptors that can be used to modify or monitor the behaviour at run time.
  This implementation is sufficient to be used to configure transactional behaviour for each item by making the `RepeatCallback` transactional, or for the whole batch by making the execute method transactional (but only then if the task executor is synchronous).
  This class is thread-safe if its collaborators are thread-safe (interceptors, terminationPolicy, callback). Normally this will be the case, but clients need to be aware that if the task executor is asynchronous, then the other collaborators should be also. In particular the `RepeatCallback` that is wrapped in the execute method must be thread-safe - often it is based on some form of data source, which itself should be both thread-safe and transactional (multiple threads could be accessing it at any given time, and each thread would have its own transaction).
  Author:
    Dave Syer

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static int` | `DEFAULT_THROTTLE_LIMIT` Default limit for maximum number of concurrent unfinished results allowed by the template.

    - ### Fields inherited from class org.springframework.batch.repeat.support.RepeatTemplate

      `logger`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `TaskExecutorRepeatTemplate()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected RepeatInternalState` | `createInternalState(RepeatContext context)` Create an internal state object that is used to store data needed internally in the scope of an iteration.
    `protected RepeatStatus` | `getNextResult(RepeatContext context, RepeatCallback callback, RepeatInternalState state)` Use the `setTaskExecutor(TaskExecutor)` to generate a result.
    `void` | `setTaskExecutor(org.springframework.core.task.TaskExecutor taskExecutor)` Setter for task executor to be used to run the individual item callbacks.
    `void` | `setThrottleLimit(int throttleLimit)` Public setter for the throttle limit.
    `protected boolean` | `waitForResults(RepeatInternalState state)` Wait for all the results to appear on the queue and execute the after interceptors for each one.

    - ### Methods inherited from class org.springframework.batch.repeat.support.RepeatTemplate

      `canContinue, executeAfterInterceptors, isComplete, isComplete, iterate, registerListener, setCompletionPolicy, setExceptionHandler, setListeners, start, update`

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

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

- - ### Field Detail

    - #### DEFAULT_THROTTLE_LIMIT

          public static final int DEFAULT_THROTTLE_LIMIT

      Default limit for maximum number of concurrent unfinished results allowed by the template. `getNextResult(RepeatContext, RepeatCallback, RepeatInternalState)` .
      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### TaskExecutorRepeatTemplate

          public TaskExecutorRepeatTemplate()

  - ### Method Detail

    - #### setThrottleLimit

          public void setThrottleLimit(int throttleLimit)

      Public setter for the throttle limit. The throttle limit is the largest number of concurrent tasks that can be executing at one time - if a new task arrives and the throttle limit is breached we wait for one of the executing tasks to finish before submitting the new one to the `TaskExecutor`. Default value is `DEFAULT_THROTTLE_LIMIT`. N.B. when used with a thread pooled `TaskExecutor` the thread pool might prevent the throttle limit actually being reached (so make the core pool size larger than the throttle limit if possible).
      Parameters:
        `throttleLimit` - the throttleLimit to set.

    - #### setTaskExecutor

          public void setTaskExecutor(org.springframework.core.task.TaskExecutor taskExecutor)

      Setter for task executor to be used to run the individual item callbacks.
      Parameters:
        `taskExecutor` - a TaskExecutor
      Throws:
        `java.lang.IllegalArgumentException` - if the argument is null

    - #### getNextResult

          protected RepeatStatus getNextResult(RepeatContext context,
                                               RepeatCallback callback,
                                               RepeatInternalState state)
                                        throws java.lang.Throwable

      Use the `setTaskExecutor(TaskExecutor)` to generate a result. The internal state in this case is a queue of unfinished result holders of type `ResultHolder`. The holder with the return value should not be on the queue when this method exits. The queue is scoped in the calling method so there is no need to synchronize access.
      Overrides:
        `getNextResult` in class `RepeatTemplate`
      Parameters:
        `context` - current BatchContext.
        `callback` - the callback to execute.
        `state` - maintained by the implementation.
      Returns:
        a finished result.
      Throws:
        `java.lang.Throwable`
      See Also:
        `RepeatTemplate.isComplete(RepeatContext)`, `RepeatTemplate.createInternalState(RepeatContext)`

    - #### waitForResults

          protected boolean waitForResults(RepeatInternalState state)

      Wait for all the results to appear on the queue and execute the after interceptors for each one.
      Overrides:
        `waitForResults` in class `RepeatTemplate`
      Parameters:
        `state` - the internal state.
      Returns:
        true if `RepeatTemplate.canContinue(RepeatStatus)` is true for all results retrieved.
      See Also:
        `RepeatTemplate.waitForResults(org.springframework.batch.repeat.support.RepeatInternalState)`

    - #### createInternalState

          protected RepeatInternalState createInternalState(RepeatContext context)

      Description copied from class: `RepeatTemplate`
      Create an internal state object that is used to store data needed internally in the scope of an iteration. Used by subclasses to manage the queueing and retrieval of asynchronous results. The default just provides an accumulation of Throwable instances for processing at the end of the batch.
      Overrides:
        `createInternalState` in class `RepeatTemplate`
      Parameters:
        `context` - the current `RepeatContext`
      Returns:
        a `RepeatInternalState` instance.
      See Also:
        `RepeatTemplate.waitForResults(RepeatInternalState)`