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

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

TaskExecutorRepeatTemplate()

Method Summary

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 ExitStatus	getNextResult(RepeatContext context, RepeatCallback callback, RepeatInternalState state) Use the setTaskExecutor(TaskExecutor) to generate a result.
void	setTaskExecutor(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

setTaskExecutor

public void setTaskExecutor(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 ExitStatus 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

See Also:

RepeatTemplate.isComplete(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(ExitStatus) 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.

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 it doesn't make sense for the throttle limit to be less than the thread pool size.

Parameters:

throttleLimit - the throttleLimit to set.