Package 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
  Description
  `static final 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
  Description
  `TaskExecutorRepeatTemplate()`

- ## Method Summary

  Modifier and Type
  Method
  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 Details

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

  - ### TaskExecutorRepeatTemplate

    public TaskExecutorRepeatTemplate()

- ## Method Details

  - ### 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:
      `IllegalArgumentException` - if the argument is null

  - ### getNextResult

    protected RepeatStatus getNextResult(RepeatContext context, RepeatCallback callback, RepeatInternalState state) throws 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:
      `Throwable` - any Throwable emitted during the iteration
    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)`