java.lang.Object
- org.springframework.batch.core.step.builder.StepBuilderHelper<PartitionStepBuilder>
- - org.springframework.batch.core.step.builder.PartitionStepBuilder
  - - org.springframework.batch.integration.partition.RemotePartitioningMasterStepBuilder

```
public class RemotePartitioningMasterStepBuilder
extends PartitionStepBuilder
```
Builder for a master step in a remote partitioning setup. This builder creates and sets a MessageChannelPartitionHandler 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.StepBuilderHelper
  logger, properties

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

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`RemotePartitioningMasterStepBuilder`	`aggregator(StepExecutionAggregator aggregator)`	Provide a step execution aggregator for aggregating partitioned step executions into a single result for the `PartitionStep` itself.
`RemotePartitioningMasterStepBuilder`	`allowStartIfComplete(boolean allowStartIfComplete)`
`RemotePartitioningMasterStepBuilder`	`beanFactory(org.springframework.beans.factory.BeanFactory beanFactory)`	Set the bean factory.
`Step`	`build()`
`RemotePartitioningMasterStepBuilder`	`gridSize(int gridSize)`	A hint to the `PartitionStepBuilder.splitter(StepExecutionSplitter)` about how many step executions are required.
`RemotePartitioningMasterStepBuilder`	`inputChannel(org.springframework.messaging.MessageChannel inputChannel)`	Set the input channel on which replies from workers will be received.
`RemotePartitioningMasterStepBuilder`	`jobExplorer(JobExplorer jobExplorer)`	Set the job explorer.
`RemotePartitioningMasterStepBuilder`	`listener(java.lang.Object listener)`	Registers objects using the annotation based listener configuration.
`RemotePartitioningMasterStepBuilder`	`listener(StepExecutionListener listener)`
`RemotePartitioningMasterStepBuilder`	`messagingTemplate(org.springframework.integration.core.MessagingTemplate messagingTemplate)`	Set the `MessagingTemplate` to use to send data to workers.
`RemotePartitioningMasterStepBuilder`	`outputChannel(org.springframework.messaging.MessageChannel outputChannel)`	Set the output channel on which requests to workers will be sent.
`RemotePartitioningMasterStepBuilder`	`partitioner(java.lang.String slaveStepName, Partitioner partitioner)`	Add a partitioner which can be used to create a `StepExecutionSplitter`.
`RemotePartitioningMasterStepBuilder`	`partitionHandler(PartitionHandler partitionHandler)`	This method will throw a `UnsupportedOperationException` since the partition handler of the master step will be automatically set to an instance of `MessageChannelPartitionHandler`.
`RemotePartitioningMasterStepBuilder`	`pollInterval(long pollInterval)`	How often to poll the job repository for the status of the workers.
`RemotePartitioningMasterStepBuilder`	`repository(JobRepository jobRepository)`
`RemotePartitioningMasterStepBuilder`	`splitter(StepExecutionSplitter splitter)`	Provide an explicit `StepExecutionSplitter` instead of having one build from the `PartitionStepBuilder.partitioner(String, Partitioner)`.
`RemotePartitioningMasterStepBuilder`	`startLimit(int startLimit)`
`RemotePartitioningMasterStepBuilder`	`step(Step step)`	Provide an actual step instance to execute in parallel.
`RemotePartitioningMasterStepBuilder`	`timeout(long timeout)`	When using job repository polling, the time limit to wait.
`RemotePartitioningMasterStepBuilder`	`transactionManager(org.springframework.transaction.PlatformTransactionManager transactionManager)`

Methods inherited from class org.springframework.batch.core.step.builder.PartitionStepBuilder
getAggregator, getGridSize, getPartitioner, getPartitionHandler, getSplitter, getStep, getStepName, getTaskExecutor, taskExecutor

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
  - RemotePartitioningMasterStepBuilder
```
public RemotePartitioningMasterStepBuilder(java.lang.String stepName)
```
    Create a new RemotePartitioningMasterStepBuilder.
    Parameters:
    stepName - name of the master step
- Method Detail
  - inputChannel
```
public RemotePartitioningMasterStepBuilder inputChannel(org.springframework.messaging.MessageChannel inputChannel)
```
    Set the input channel on which replies from workers will be received.
    Parameters:
    inputChannel - the input channel
    Returns:
    this builder instance for fluent chaining
  - outputChannel
```
public RemotePartitioningMasterStepBuilder 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 RemotePartitioningMasterStepBuilder 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)
  - jobExplorer
```
public RemotePartitioningMasterStepBuilder jobExplorer(JobExplorer jobExplorer)
```
    Set the job explorer.
    Parameters:
    jobExplorer - the job explorer to use.
    Returns:
    this builder instance for fluent chaining
  - pollInterval
```
public RemotePartitioningMasterStepBuilder pollInterval(long pollInterval)
```
    How often to poll the job repository for the status of the workers. Defaults to 10 seconds.
    Parameters:
    pollInterval - the poll interval value in milliseconds
    Returns:
    this builder instance for fluent chaining
  - timeout
```
public RemotePartitioningMasterStepBuilder timeout(long timeout)
```
    When using job repository polling, the time limit to wait. Defaults to -1 (no timeout).
    Parameters:
    timeout - the timeout value in milliseconds
    Returns:
    this builder instance for fluent chaining
  - beanFactory
```
public RemotePartitioningMasterStepBuilder beanFactory(org.springframework.beans.factory.BeanFactory beanFactory)
```
    Set the bean factory.
    Parameters:
    beanFactory - the bean factory to use
    Returns:
    this builder instance for fluent chaining
  - build
```
public Step build()
```
    Overrides:
    build in class PartitionStepBuilder
  - repository
```
public RemotePartitioningMasterStepBuilder repository(JobRepository jobRepository)
```
    Overrides:
    repository in class StepBuilderHelper<PartitionStepBuilder>
  - transactionManager
```
public RemotePartitioningMasterStepBuilder transactionManager(org.springframework.transaction.PlatformTransactionManager transactionManager)
```
    Overrides:
    transactionManager in class StepBuilderHelper<PartitionStepBuilder>
  - partitioner
```
public RemotePartitioningMasterStepBuilder partitioner(java.lang.String slaveStepName,
                                                       Partitioner partitioner)
```
    Description copied from class: PartitionStepBuilder
    Add a partitioner which can be used to create a StepExecutionSplitter. Use either this or an explicit PartitionStepBuilder.splitter(StepExecutionSplitter) but not both.
    Overrides:
    partitioner in class PartitionStepBuilder
    Parameters:
    slaveStepName - the name of the slave step (used to construct step execution names)
    partitioner - a partitioner to use
    Returns:
    this for fluent chaining
  - gridSize
```
public RemotePartitioningMasterStepBuilder gridSize(int gridSize)
```
    Description copied from class: PartitionStepBuilder
    A hint to the PartitionStepBuilder.splitter(StepExecutionSplitter) about how many step executions are required. If running locally or remotely through a PartitionStepBuilder.taskExecutor(TaskExecutor) determines precisely the number of step executions in the first attempt at a partition step execution.
    Overrides:
    gridSize in class PartitionStepBuilder
    Parameters:
    gridSize - the grid size
    Returns:
    this for fluent chaining
  - step
```
public RemotePartitioningMasterStepBuilder step(Step step)
```
    Description copied from class: PartitionStepBuilder
    Provide an actual step instance to execute in parallel. If an explicit PartitionStepBuilder.partitionHandler(PartitionHandler) is provided, the step is optional and is only used to extract configuration data (name and other basic properties of a step).
    Overrides:
    step in class PartitionStepBuilder
    Parameters:
    step - a step to execute in parallel
    Returns:
    this for fluent chaining
  - splitter
```
public RemotePartitioningMasterStepBuilder splitter(StepExecutionSplitter splitter)
```
    Description copied from class: PartitionStepBuilder
    Provide an explicit StepExecutionSplitter instead of having one build from the PartitionStepBuilder.partitioner(String, Partitioner). Useful if you need more control over the splitting.
    Overrides:
    splitter in class PartitionStepBuilder
    Parameters:
    splitter - a step execution splitter
    Returns:
    this for fluent chaining
  - aggregator
```
public RemotePartitioningMasterStepBuilder aggregator(StepExecutionAggregator aggregator)
```
    Description copied from class: PartitionStepBuilder
    Provide a step execution aggregator for aggregating partitioned step executions into a single result for the PartitionStep itself. Default is a simple implementation that works in most cases.
    Overrides:
    aggregator in class PartitionStepBuilder
    Parameters:
    aggregator - a step execution aggregator
    Returns:
    this for fluent chaining
  - startLimit
```
public RemotePartitioningMasterStepBuilder startLimit(int startLimit)
```
    Overrides:
    startLimit in class StepBuilderHelper<PartitionStepBuilder>
  - listener
```
public RemotePartitioningMasterStepBuilder listener(java.lang.Object listener)
```
    Description copied from class: StepBuilderHelper
    Registers objects using the annotation based listener configuration.
    Overrides:
    listener in class StepBuilderHelper<PartitionStepBuilder>
    Parameters:
    listener - the object that has a method configured with listener annotation
    Returns:
    this for fluent chaining
  - listener
```
public RemotePartitioningMasterStepBuilder listener(StepExecutionListener listener)
```
    Overrides:
    listener in class StepBuilderHelper<PartitionStepBuilder>
  - allowStartIfComplete
```
public RemotePartitioningMasterStepBuilder allowStartIfComplete(boolean allowStartIfComplete)
```
    Overrides:
    allowStartIfComplete in class StepBuilderHelper<PartitionStepBuilder>
  - partitionHandler
```
public RemotePartitioningMasterStepBuilder partitionHandler(PartitionHandler partitionHandler)
                                                     throws java.lang.UnsupportedOperationException
```
    This method will throw a UnsupportedOperationException since the partition handler of the master step will be automatically set to an instance of MessageChannelPartitionHandler. When building a master step for remote partitioning using this builder, no partition handler must be provided.
    Overrides:
    partitionHandler in class PartitionStepBuilder
    Parameters:
    partitionHandler - a partition handler
    Returns:
    this builder instance for fluent chaining
    Throws:
    java.lang.UnsupportedOperationException - if a partition handler is provided
    See Also:
    for setting up a default handler that works with a local or remote Step

Class RemotePartitioningMasterStepBuilder

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.StepBuilderHelper

Constructor Summary

Method Summary

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

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

Methods inherited from class java.lang.Object

Constructor Detail

RemotePartitioningMasterStepBuilder

Method Detail

inputChannel

outputChannel

messagingTemplate

jobExplorer

pollInterval

timeout

beanFactory

build

repository

transactionManager

partitioner

gridSize

step

splitter

aggregator

startLimit

listener

listener

allowStartIfComplete

partitionHandler