org.springframework.batch.repeat.support
Class TaskExecutorRepeatTemplate

java.lang.Object
  extended by org.springframework.batch.repeat.support.RepeatTemplate
      extended by 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.


Copyright © 2008 SpringSource. All Rights Reserved.