java.lang.Object
- org.springframework.batch.core.step.builder.StepBuilderHelper<AbstractTaskletStepBuilder<B>>
- - org.springframework.batch.core.step.builder.AbstractTaskletStepBuilder<SimpleStepBuilder<I,O>>
  - - org.springframework.batch.core.step.builder.SimpleStepBuilder<I,O>
    - - org.springframework.batch.core.step.builder.FaultTolerantStepBuilder<I,O>
      - org.springframework.batch.integration.chunk.RemoteChunkingMasterStepBuilder<I,O>

Type Parameters:
I - type of input items
O - type of output items
```
public class RemoteChunkingMasterStepBuilder<I,O>
extends FaultTolerantStepBuilder<I,O>
```
Builder for a master step in a remote chunking setup. This builder creates and sets a ChunkMessageChannelItemWriter on the master step.
If no messagingTemplate is provided through messagingTemplate(MessagingTemplate), this builder will create one and set its default channel to the outputChannel provided through outputChannel(MessageChannel).
If a messagingTemplate is provided, it is assumed that it is fully configured and that its default channel is set to an output channel on which requests to workers will be sent.
Since:
4.1
Author:
Mahmoud Ben Hassine

Nested Class Summary
- Nested classes/interfaces inherited from class org.springframework.batch.core.step.builder.StepBuilderHelper
  StepBuilderHelper.CommonStepProperties

Field Summary
- Fields inherited from class org.springframework.batch.core.step.builder.AbstractTaskletStepBuilder
  chunkListeners
- Fields inherited from class org.springframework.batch.core.step.builder.StepBuilderHelper
  logger, properties

Constructor Summary
Constructors
Constructor Description
RemoteChunkingMasterStepBuilder(java.lang.String stepName)
Create a new RemoteChunkingMasterStepBuilder.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`RemoteChunkingMasterStepBuilder<I,O>`	`allowStartIfComplete(boolean allowStartIfComplete)`
`RemoteChunkingMasterStepBuilder<I,O>`	`backOffPolicy(org.springframework.retry.backoff.BackOffPolicy backOffPolicy)`	Provide a backoff policy to prevent items being retried immediately (e.g.
`TaskletStep`	`build()`	Build a master `TaskletStep`.
`RemoteChunkingMasterStepBuilder<I,O>`	`chunk(int chunkSize)`	Sets the chunk size or commit interval for this step.
`RemoteChunkingMasterStepBuilder<I,O>`	`chunk(CompletionPolicy completionPolicy)`	Sets a completion policy for the chunk processing.
`RemoteChunkingMasterStepBuilder<I,O>`	`chunkOperations(RepeatOperations repeatTemplate)`	Instead of a `chunk size` or `completion policy` you can provide a complete repeat operations instance that handles the iteration over the item reader.
`RemoteChunkingMasterStepBuilder<I,O>`	`exceptionHandler(ExceptionHandler exceptionHandler)`	Sets the exception handler to use in the case of tasklet failures.
`RemoteChunkingMasterStepBuilder<I,O>`	`inputChannel(org.springframework.messaging.PollableChannel inputChannel)`	Set the input channel on which replies from workers will be received.
`RemoteChunkingMasterStepBuilder<I,O>`	`keyGenerator(KeyGenerator keyGenerator)`	Sets the key generator for identifying retried items.
`RemoteChunkingMasterStepBuilder<I,O>`	`listener(java.lang.Object listener)`	Registers objects using the annotation based listener configuration.
`RemoteChunkingMasterStepBuilder<I,O>`	`listener(ChunkListener listener)`	Register a chunk listener.
`RemoteChunkingMasterStepBuilder<I,O>`	`listener(ItemReadListener<? super I> listener)`	Register an item reader listener.
`RemoteChunkingMasterStepBuilder<I,O>`	`listener(ItemWriteListener<? super O> listener)`	Register an item writer listener.
`RemoteChunkingMasterStepBuilder<I,O>`	`listener(SkipListener<? super I,? super O> listener)`	Register a skip listener.
`RemoteChunkingMasterStepBuilder<I,O>`	`listener(StepExecutionListener listener)`
`RemoteChunkingMasterStepBuilder<I,O>`	`listener(org.springframework.retry.RetryListener listener)`	Register a retry listener.
`RemoteChunkingMasterStepBuilder<I,O>`	`maxWaitTimeouts(int maxWaitTimeouts)`	The maximum number of times to wait at the end of a step for a non-null result from the remote workers.
`RemoteChunkingMasterStepBuilder<I,O>`	`messagingTemplate(org.springframework.integration.core.MessagingTemplate messagingTemplate)`	Set the `MessagingTemplate` to use to send data to workers.
`RemoteChunkingMasterStepBuilder<I,O>`	`noRetry(java.lang.Class<? extends java.lang.Throwable> type)`	Explicitly ask for an exception (and subclasses) to be excluded from retry.
`RemoteChunkingMasterStepBuilder<I,O>`	`noRollback(java.lang.Class<? extends java.lang.Throwable> type)`	Mark this exception as ignorable during item read or processing operations.
`RemoteChunkingMasterStepBuilder<I,O>`	`noSkip(java.lang.Class<? extends java.lang.Throwable> type)`	Explicitly prevent certain exceptions (and subclasses) from being skipped.
`RemoteChunkingMasterStepBuilder<I,O>`	`outputChannel(org.springframework.messaging.MessageChannel outputChannel)`	Set the output channel on which requests to workers will be sent.
`RemoteChunkingMasterStepBuilder<I,O>`	`processor(ItemProcessor<? super I,? extends O> itemProcessor)`	An item processor that processes or transforms a stream of items.
`RemoteChunkingMasterStepBuilder<I,O>`	`reader(ItemReader<? extends I> reader)`	An item reader that provides a stream of items.
`RemoteChunkingMasterStepBuilder<I,O>`	`readerIsTransactionalQueue()`	Sets a flag to say that the reader is transactional (usually a queue), which is to say that failed items might be rolled back and re-presented in a subsequent transaction.
`RemoteChunkingMasterStepBuilder<I,O>`	`repository(JobRepository jobRepository)`
`RemoteChunkingMasterStepBuilder<I,O>`	`retry(java.lang.Class<? extends java.lang.Throwable> type)`	Explicitly ask for an exception (and subclasses) to be retried.
`RemoteChunkingMasterStepBuilder<I,O>`	`retryContextCache(org.springframework.retry.policy.RetryContextCache retryContextCache)`	Provide an explicit retry context cache.
`RemoteChunkingMasterStepBuilder<I,O>`	`retryLimit(int retryLimit)`	The maximum number of times to try a failed item.
`RemoteChunkingMasterStepBuilder<I,O>`	`retryPolicy(org.springframework.retry.RetryPolicy retryPolicy)`	Provide an explicit retry policy instead of using the `FaultTolerantStepBuilder.retryLimit(int)` and retryable exceptions provided elsewhere.
`RemoteChunkingMasterStepBuilder<I,O>`	`skip(java.lang.Class<? extends java.lang.Throwable> type)`	Explicitly request certain exceptions (and subclasses) to be skipped.
`RemoteChunkingMasterStepBuilder<I,O>`	`skipLimit(int skipLimit)`	Sets the maximum number of failed items to skip before the step fails.
`RemoteChunkingMasterStepBuilder<I,O>`	`skipPolicy(SkipPolicy skipPolicy)`	Provide an explicit policy for managing skips.
`RemoteChunkingMasterStepBuilder<I,O>`	`startLimit(int startLimit)`
`RemoteChunkingMasterStepBuilder<I,O>`	`stepOperations(RepeatOperations repeatTemplate)`	Sets the repeat template used for iterating the tasklet execution.
`RemoteChunkingMasterStepBuilder<I,O>`	`stream(ItemStream stream)`	Register a stream for callbacks that manage restart data.
`RemoteChunkingMasterStepBuilder<I,O>`	`throttleLimit(long throttleLimit)`	Public setter for the throttle limit.
`RemoteChunkingMasterStepBuilder<I,O>`	`transactionAttribute(org.springframework.transaction.interceptor.TransactionAttribute transactionAttribute)`	Sets the transaction attributes for the tasklet execution.
`RemoteChunkingMasterStepBuilder<I,O>`	`transactionManager(org.springframework.transaction.PlatformTransactionManager transactionManager)`
`RemoteChunkingMasterStepBuilder<I,O>`	`writer(ItemWriter<? super O> writer)`	This method will throw a `UnsupportedOperationException` since the item writer of the master step in a remote chunking setup will be automatically set to an instance of `ChunkMessageChannelItemWriter`.

Methods inherited from class org.springframework.batch.core.step.builder.FaultTolerantStepBuilder
createChunkProcessor, createChunkProvider, createRetryOperations, createSkipPolicy, createTasklet, detectStreamInReader, getChunkMonitor, getFatalExceptionAwareProxy, getJsrRetryListeners, getRollbackClassifier, getSkipListeners, listener, processorNonTransactional, registerStepListenerAsSkipListener

Methods inherited from class org.springframework.batch.core.step.builder.SimpleStepBuilder
createChunkOperations, faultTolerant, getChunkCompletionPolicy, getChunkSize, getItemListeners, getProcessor, getReader, getWriter, isReaderTransactionalQueue, listener, processor, registerAsStreamsAndListeners, registerStepListenerAsItemListener

Methods inherited from class org.springframework.batch.core.step.builder.AbstractTaskletStepBuilder
concurrent, getExceptionHandler, getStepOperations, getStreams, getTaskExecutor, getThrottleLimit, getTransactionAttribute, registerStepListenerAsChunkListener, taskExecutor, throttleLimit

Methods inherited from class org.springframework.batch.core.step.builder.StepBuilderHelper
enhance, getJobRepository, getName, getTransactionManager, isAllowStartIfComplete

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - RemoteChunkingMasterStepBuilder
```
public RemoteChunkingMasterStepBuilder(java.lang.String stepName)
```
    Create a new RemoteChunkingMasterStepBuilder.
    Parameters:
    stepName - name of the master step
- Method Detail
  - inputChannel
```
public RemoteChunkingMasterStepBuilder<I,O> inputChannel(org.springframework.messaging.PollableChannel inputChannel)
```
    Set the input channel on which replies from workers will be received. The provided input channel will be set as a reply channel on the ChunkMessageChannelItemWriter created by this builder.
    Parameters:
    inputChannel - the input channel
    Returns:
    this builder instance for fluent chaining
    See Also:
    ChunkMessageChannelItemWriter.setReplyChannel(org.springframework.messaging.PollableChannel)
  - outputChannel
```
public RemoteChunkingMasterStepBuilder<I,O> outputChannel(org.springframework.messaging.MessageChannel outputChannel)
```
    Set the output channel on which requests to workers will be sent. By using this setter, a default messaging template will be created and the output channel will be set as its default channel.
    Use either this setter or messagingTemplate(MessagingTemplate) to provide a fully configured messaging template.
    Parameters:
    outputChannel - the output channel.
    Returns:
    this builder instance for fluent chaining
    See Also:
    messagingTemplate(MessagingTemplate)
  - messagingTemplate
```
public RemoteChunkingMasterStepBuilder<I,O> messagingTemplate(org.springframework.integration.core.MessagingTemplate messagingTemplate)
```
    Set the MessagingTemplate to use to send data to workers. The default channel of the messaging template must be set.
    Use either this setter to provide a fully configured messaging template or provide an output channel through outputChannel(MessageChannel) and a default messaging template will be created.
    Parameters:
    messagingTemplate - the messaging template to use
    Returns:
    this builder instance for fluent chaining
    See Also:
    outputChannel(MessageChannel)
  - maxWaitTimeouts
```
public RemoteChunkingMasterStepBuilder<I,O> maxWaitTimeouts(int maxWaitTimeouts)
```
    The maximum number of times to wait at the end of a step for a non-null result from the remote workers. This is a multiplier on the receive timeout set separately on the gateway. The ideal value is a compromise between allowing slow workers time to finish, and responsiveness if there is a dead worker. Defaults to 40.
    Parameters:
    maxWaitTimeouts - the maximum number of wait timeouts
    See Also:
    ChunkMessageChannelItemWriter.setMaxWaitTimeouts(int)
  - throttleLimit
```
public RemoteChunkingMasterStepBuilder<I,O> throttleLimit(long throttleLimit)
```
    Public setter for the throttle limit. This limits the number of pending requests for chunk processing to avoid overwhelming the receivers.
    Parameters:
    throttleLimit - the throttle limit to set
    See Also:
    ChunkMessageChannelItemWriter.setThrottleLimit(long)
  - build
```
public TaskletStep build()
```
    Build a master TaskletStep.
    Overrides:
    build in class FaultTolerantStepBuilder<I,O>
    Returns:
    the configured master step
    See Also:
    RemoteChunkHandlerFactoryBean
  - reader
```
public RemoteChunkingMasterStepBuilder<I,O> reader(ItemReader<? extends I> reader)
```
    Description copied from class: SimpleStepBuilder
    An item reader that provides a stream of items. Will be automatically registered as a AbstractTaskletStepBuilder.stream(ItemStream) or listener if it implements the corresponding interface. By default assumed to be non-transactional.
    Overrides:
    reader in class SimpleStepBuilder<I,O>
    Parameters:
    reader - an item reader
    Returns:
    this for fluent chaining
    See Also:
    SimpleStepBuilder.readerTransactionalQueue
  - repository
```
public RemoteChunkingMasterStepBuilder<I,O> repository(JobRepository jobRepository)
```
    Overrides:
    repository in class StepBuilderHelper<AbstractTaskletStepBuilder<SimpleStepBuilder<I,O>>>
  - transactionManager
```
public RemoteChunkingMasterStepBuilder<I,O> transactionManager(org.springframework.transaction.PlatformTransactionManager transactionManager)
```
    Overrides:
    transactionManager in class StepBuilderHelper<AbstractTaskletStepBuilder<SimpleStepBuilder<I,O>>>
  - listener
```
public RemoteChunkingMasterStepBuilder<I,O> listener(java.lang.Object listener)
```
    Description copied from class: FaultTolerantStepBuilder
    Registers objects using the annotation based listener configuration.
    Overrides:
    listener in class FaultTolerantStepBuilder<I,O>
    Parameters:
    listener - the object that has a method configured with listener annotation
    Returns:
    this for fluent chaining
  - listener
```
public RemoteChunkingMasterStepBuilder<I,O> listener(SkipListener<? super I,? super O> listener)
```
    Description copied from class: FaultTolerantStepBuilder
    Register a skip listener.
    Overrides:
    listener in class FaultTolerantStepBuilder<I,O>
    Parameters:
    listener - the listener to register
    Returns:
    this for fluent chaining
  - listener
```
public RemoteChunkingMasterStepBuilder<I,O> listener(ChunkListener listener)
```
    Description copied from class: AbstractTaskletStepBuilder
    Register a chunk listener.
    Overrides:
    listener in class FaultTolerantStepBuilder<I,O>
    Parameters:
    listener - the listener to register
    Returns:
    this for fluent chaining
  - transactionAttribute
```
public RemoteChunkingMasterStepBuilder<I,O> transactionAttribute(org.springframework.transaction.interceptor.TransactionAttribute transactionAttribute)
```
    Description copied from class: AbstractTaskletStepBuilder
    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.
    Overrides:
    transactionAttribute in class FaultTolerantStepBuilder<I,O>
    Parameters:
    transactionAttribute - a transaction attribute set
    Returns:
    this for fluent chaining
  - listener
```
public RemoteChunkingMasterStepBuilder<I,O> listener(org.springframework.retry.RetryListener listener)
```
    Description copied from class: FaultTolerantStepBuilder
    Register a retry listener.
    Overrides:
    listener in class FaultTolerantStepBuilder<I,O>
    Parameters:
    listener - the listener to register
    Returns:
    this for fluent chaining
  - keyGenerator
```
public RemoteChunkingMasterStepBuilder<I,O> keyGenerator(KeyGenerator keyGenerator)
```
    Description copied from class: FaultTolerantStepBuilder
    Sets the key generator for identifying retried items. Retry across transaction boundaries requires items to be identified when they are encountered again. The default strategy is to use the items themselves, relying on their own implementation to ensure that they can be identified. Often a key generator is not necessary as long as the items have reliable hash code and equals implementations, or the reader is not transactional (the default) and the item processor either is itself not transactional (not the default) or does not create new items.
    Overrides:
    keyGenerator in class FaultTolerantStepBuilder<I,O>
    Parameters:
    keyGenerator - a key generator for the stateful retry
    Returns:
    this for fluent chaining
  - retryLimit
```
public RemoteChunkingMasterStepBuilder<I,O> retryLimit(int retryLimit)
```
    Description copied from class: FaultTolerantStepBuilder
    The maximum number of times to try a failed item. Zero and one both translate to try only once and do not retry. Ignored if an explicit FaultTolerantStepBuilder.retryPolicy is set.
    Overrides:
    retryLimit in class FaultTolerantStepBuilder<I,O>
    Parameters:
    retryLimit - the retry limit (default 0)
    Returns:
    this for fluent chaining
  - retryPolicy
```
public RemoteChunkingMasterStepBuilder<I,O> retryPolicy(org.springframework.retry.RetryPolicy retryPolicy)
```
    Description copied from class: FaultTolerantStepBuilder
    Provide an explicit retry policy instead of using the FaultTolerantStepBuilder.retryLimit(int) and retryable exceptions provided elsewhere. Can be used to retry different exceptions a different number of times, for instance.
    Overrides:
    retryPolicy in class FaultTolerantStepBuilder<I,O>
    Parameters:
    retryPolicy - a retry policy
    Returns:
    this for fluent chaining
  - backOffPolicy
```
public RemoteChunkingMasterStepBuilder<I,O> backOffPolicy(org.springframework.retry.backoff.BackOffPolicy backOffPolicy)
```
    Description copied from class: FaultTolerantStepBuilder
    Provide a backoff policy to prevent items being retried immediately (e.g. in case the failure was caused by a remote resource failure that might take some time to be resolved). Ignored if an explicit FaultTolerantStepBuilder.retryPolicy is set.
    Overrides:
    backOffPolicy in class FaultTolerantStepBuilder<I,O>
    Parameters:
    backOffPolicy - the back off policy to use (default no backoff)
    Returns:
    this for fluent chaining
  - retryContextCache
```
public RemoteChunkingMasterStepBuilder<I,O> retryContextCache(org.springframework.retry.policy.RetryContextCache retryContextCache)
```
    Description copied from class: FaultTolerantStepBuilder
    Provide an explicit retry context cache. Retry is stateful across transactions in the case of failures in item processing or writing, so some information about the context for subsequent retries has to be stored.
    Overrides:
    retryContextCache in class FaultTolerantStepBuilder<I,O>
    Parameters:
    retryContextCache - cache for retry contexts in between transactions (default to standard in-memory implementation)
    Returns:
    this for fluent chaining
  - skipLimit
```
public RemoteChunkingMasterStepBuilder<I,O> skipLimit(int skipLimit)
```
    Description copied from class: FaultTolerantStepBuilder
    Sets the maximum number of failed items to skip before the step fails. Ignored if an explicit FaultTolerantStepBuilder.skipPolicy(SkipPolicy) is provided.
    Overrides:
    skipLimit in class FaultTolerantStepBuilder<I,O>
    Parameters:
    skipLimit - the skip limit to set
    Returns:
    this for fluent chaining
  - noSkip
```
public RemoteChunkingMasterStepBuilder<I,O> noSkip(java.lang.Class<? extends java.lang.Throwable> type)
```
    Description copied from class: FaultTolerantStepBuilder
    Explicitly prevent certain exceptions (and subclasses) from being skipped.
    Overrides:
    noSkip in class FaultTolerantStepBuilder<I,O>
    Parameters:
    type - the non-skippable exception
    Returns:
    this for fluent chaining
  - skip
```
public RemoteChunkingMasterStepBuilder<I,O> skip(java.lang.Class<? extends java.lang.Throwable> type)
```
    Description copied from class: FaultTolerantStepBuilder
    Explicitly request certain exceptions (and subclasses) to be skipped. These exceptions (and their subclasses) might be thrown during any phase of the chunk processing (read, process, write) but separate counts are made of skips on read, process and write inside the step execution.
    Overrides:
    skip in class FaultTolerantStepBuilder<I,O>
    Parameters:
    type - the exception type.
    Returns:
    this for fluent chaining
  - skipPolicy
```
public RemoteChunkingMasterStepBuilder<I,O> skipPolicy(SkipPolicy skipPolicy)
```
    Description copied from class: FaultTolerantStepBuilder
    Provide an explicit policy for managing skips. A skip policy determines which exceptions are skippable and how many times.
    Overrides:
    skipPolicy in class FaultTolerantStepBuilder<I,O>
    Parameters:
    skipPolicy - the skip policy
    Returns:
    this for fluent chaining
  - noRollback
```
public RemoteChunkingMasterStepBuilder<I,O> noRollback(java.lang.Class<? extends java.lang.Throwable> type)
```
    Description copied from class: FaultTolerantStepBuilder
    Mark this exception as ignorable during item read or processing operations. Processing continues with no additional callbacks (use skips instead if you need to be notified). Ignored during write because there is no guarantee of skip and retry without rollback.
    Overrides:
    noRollback in class FaultTolerantStepBuilder<I,O>
    Parameters:
    type - the exception to mark as no rollback
    Returns:
    this for fluent chaining
  - noRetry
```
public RemoteChunkingMasterStepBuilder<I,O> noRetry(java.lang.Class<? extends java.lang.Throwable> type)
```
    Description copied from class: FaultTolerantStepBuilder
    Explicitly ask for an exception (and subclasses) to be excluded from retry.
    Overrides:
    noRetry in class FaultTolerantStepBuilder<I,O>
    Parameters:
    type - the exception to exclude from retry
    Returns:
    this for fluent chaining
  - retry
```
public RemoteChunkingMasterStepBuilder<I,O> retry(java.lang.Class<? extends java.lang.Throwable> type)
```
    Description copied from class: FaultTolerantStepBuilder
    Explicitly ask for an exception (and subclasses) to be retried.
    Overrides:
    retry in class FaultTolerantStepBuilder<I,O>
    Parameters:
    type - the exception to retry
    Returns:
    this for fluent chaining
  - stream
```
public RemoteChunkingMasterStepBuilder<I,O> stream(ItemStream stream)
```
    Description copied from class: AbstractTaskletStepBuilder
    Register a stream for callbacks that manage restart data.
    Overrides:
    stream in class FaultTolerantStepBuilder<I,O>
    Parameters:
    stream - the stream to register
    Returns:
    this for fluent chaining
  - chunk
```
public RemoteChunkingMasterStepBuilder<I,O> chunk(int chunkSize)
```
    Description copied from class: SimpleStepBuilder
    Sets the chunk size or commit interval for this step. This is the maximum number of items that will be read before processing starts in a single transaction. Not compatible with SimpleStepBuilder.completionPolicy .
    Overrides:
    chunk in class SimpleStepBuilder<I,O>
    Parameters:
    chunkSize - the chunk size (a.k.a commit interval)
    Returns:
    this for fluent chaining
  - chunk
```
public RemoteChunkingMasterStepBuilder<I,O> chunk(CompletionPolicy completionPolicy)
```
    Description copied from class: SimpleStepBuilder
    Sets a completion policy for the chunk processing. Items are read until this policy determines that a chunk is complete, giving more control than with just the chunk size (or commit interval).
    Overrides:
    chunk in class SimpleStepBuilder<I,O>
    Parameters:
    completionPolicy - a completion policy for the chunk
    Returns:
    this for fluent chaining
  - writer
```
public RemoteChunkingMasterStepBuilder<I,O> writer(ItemWriter<? super O> writer)
                                                  throws java.lang.UnsupportedOperationException
```
    This method will throw a UnsupportedOperationException since the item writer of the master step in a remote chunking setup will be automatically set to an instance of ChunkMessageChannelItemWriter. When building a master step for remote chunking, no item writer must be provided.
    Overrides:
    writer in class SimpleStepBuilder<I,O>
    Parameters:
    writer - an item writer
    Returns:
    this for fluent chaining
    Throws:
    java.lang.UnsupportedOperationException - if an item writer is provided
    See Also:
    ChunkMessageChannelItemWriter, RemoteChunkHandlerFactoryBean.setChunkWriter(ItemWriter)
  - readerIsTransactionalQueue
```
public RemoteChunkingMasterStepBuilder<I,O> readerIsTransactionalQueue()
```
    Description copied from class: SimpleStepBuilder
    Sets a flag to say that the reader is transactional (usually a queue), which is to say that failed items might be rolled back and re-presented in a subsequent transaction. Default is false, meaning that the items are read outside a transaction and possibly cached.
    Overrides:
    readerIsTransactionalQueue in class SimpleStepBuilder<I,O>
    Returns:
    this for fluent chaining
  - listener
```
public RemoteChunkingMasterStepBuilder<I,O> listener(ItemReadListener<? super I> listener)
```
    Description copied from class: SimpleStepBuilder
    Register an item reader listener.
    Overrides:
    listener in class SimpleStepBuilder<I,O>
    Parameters:
    listener - the listener to register
    Returns:
    this for fluent chaining
  - listener
```
public RemoteChunkingMasterStepBuilder<I,O> listener(ItemWriteListener<? super O> listener)
```
    Description copied from class: SimpleStepBuilder
    Register an item writer listener.
    Overrides:
    listener in class SimpleStepBuilder<I,O>
    Parameters:
    listener - the listener to register
    Returns:
    this for fluent chaining
  - chunkOperations
```
public RemoteChunkingMasterStepBuilder<I,O> chunkOperations(RepeatOperations repeatTemplate)
```
    Description copied from class: SimpleStepBuilder
    Instead of a chunk size or completion policy you can provide a complete repeat operations instance that handles the iteration over the item reader.
    Overrides:
    chunkOperations in class SimpleStepBuilder<I,O>
    Parameters:
    repeatTemplate - a complete repeat template for the chunk
    Returns:
    this for fluent chaining
  - exceptionHandler
```
public RemoteChunkingMasterStepBuilder<I,O> exceptionHandler(ExceptionHandler exceptionHandler)
```
    Description copied from class: AbstractTaskletStepBuilder
    Sets the exception handler to use in the case of tasklet failures. Default is to rethrow everything.
    Overrides:
    exceptionHandler in class AbstractTaskletStepBuilder<SimpleStepBuilder<I,O>>
    Parameters:
    exceptionHandler - the exception handler
    Returns:
    this for fluent chaining
  - stepOperations
```
public RemoteChunkingMasterStepBuilder<I,O> stepOperations(RepeatOperations repeatTemplate)
```
    Description copied from class: AbstractTaskletStepBuilder
    Sets the repeat template used for iterating the tasklet execution. By default it will terminate only when the tasklet returns FINISHED (or null).
    Overrides:
    stepOperations in class AbstractTaskletStepBuilder<SimpleStepBuilder<I,O>>
    Parameters:
    repeatTemplate - a repeat template with rules for iterating
    Returns:
    this for fluent chaining
  - startLimit
```
public RemoteChunkingMasterStepBuilder<I,O> startLimit(int startLimit)
```
    Overrides:
    startLimit in class StepBuilderHelper<AbstractTaskletStepBuilder<SimpleStepBuilder<I,O>>>
  - listener
```
public RemoteChunkingMasterStepBuilder<I,O> listener(StepExecutionListener listener)
```
    Overrides:
    listener in class StepBuilderHelper<AbstractTaskletStepBuilder<SimpleStepBuilder<I,O>>>
  - allowStartIfComplete
```
public RemoteChunkingMasterStepBuilder<I,O> allowStartIfComplete(boolean allowStartIfComplete)
```
    Overrides:
    allowStartIfComplete in class StepBuilderHelper<AbstractTaskletStepBuilder<SimpleStepBuilder<I,O>>>
  - processor
```
public RemoteChunkingMasterStepBuilder<I,O> processor(ItemProcessor<? super I,? extends O> itemProcessor)
```
    Description copied from class: SimpleStepBuilder
    An item processor that processes or transforms a stream of items. Will be automatically registered as a AbstractTaskletStepBuilder.stream(ItemStream) or listener if it implements the corresponding interface.
    Overrides:
    processor in class SimpleStepBuilder<I,O>
    Parameters:
    itemProcessor - an item processor
    Returns:
    this for fluent chaining

Class RemoteChunkingMasterStepBuilder<I,​O>

Nested Class Summary

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

Field Summary

Fields inherited from class org.springframework.batch.core.step.builder.AbstractTaskletStepBuilder

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

Constructor Summary

Method Summary

Methods inherited from class org.springframework.batch.core.step.builder.FaultTolerantStepBuilder

Methods inherited from class org.springframework.batch.core.step.builder.SimpleStepBuilder

Methods inherited from class org.springframework.batch.core.step.builder.AbstractTaskletStepBuilder

Methods inherited from class org.springframework.batch.core.step.builder.StepBuilderHelper

Methods inherited from class java.lang.Object

Constructor Detail

RemoteChunkingMasterStepBuilder

Method Detail

inputChannel

outputChannel

messagingTemplate

maxWaitTimeouts

throttleLimit

build

reader

repository

transactionManager

listener

listener

listener

transactionAttribute

listener

keyGenerator

retryLimit

retryPolicy

backOffPolicy

retryContextCache

skipLimit

noSkip

skip

skipPolicy

noRollback

noRetry

retry

stream

chunk

chunk

writer

readerIsTransactionalQueue

listener

listener

chunkOperations

exceptionHandler

stepOperations

startLimit

listener

allowStartIfComplete

processor

Class RemoteChunkingMasterStepBuilder<I,O>