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

Direct Known Subclasses:
JsrPartitionStepBuilder, RemotePartitioningMasterStepBuilder
```
public class PartitionStepBuilder
extends StepBuilderHelper<PartitionStepBuilder>
```
Step builder for PartitionStep instances. A partition step executes the same step (possibly remotely) multiple times with different input parameters (in the form of execution context). Useful for parallelization.
Since:
2.2
Author:
Dave Syer, Mahmoud Ben Hassine, Dimitrios Liapis

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
PartitionStepBuilder(StepBuilderHelper<?> parent)
Create a new builder initialized with any properties in the parent.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`PartitionStepBuilder`	`aggregator(StepExecutionAggregator aggregator)`	Provide a step execution aggregator for aggregating partitioned step executions into a single result for the `PartitionStep` itself.
`Step`	`build()`
`protected StepExecutionAggregator`	`getAggregator()`
`protected int`	`getGridSize()`
`protected Partitioner`	`getPartitioner()`
`protected PartitionHandler`	`getPartitionHandler()`
`protected StepExecutionSplitter`	`getSplitter()`
`protected Step`	`getStep()`
`protected java.lang.String`	`getStepName()`
`protected org.springframework.core.task.TaskExecutor`	`getTaskExecutor()`
`PartitionStepBuilder`	`gridSize(int gridSize)`	A hint to the `splitter(StepExecutionSplitter)` about how many step executions are required.
`PartitionStepBuilder`	`partitioner(java.lang.String slaveStepName, Partitioner partitioner)`	Add a partitioner which can be used to create a `StepExecutionSplitter`.
`PartitionStepBuilder`	`partitionHandler(PartitionHandler partitionHandler)`	Provide an explicit partition handler that will carry out the work of the partition step.
`PartitionStepBuilder`	`splitter(StepExecutionSplitter splitter)`	Provide an explicit `StepExecutionSplitter` instead of having one build from the `partitioner(String, Partitioner)`.
`PartitionStepBuilder`	`step(Step step)`	Provide an actual step instance to execute in parallel.
`PartitionStepBuilder`	`taskExecutor(org.springframework.core.task.TaskExecutor taskExecutor)`	Provide a task executor to use when constructing a `PartitionHandler` from the `step(Step)`.

Methods inherited from class org.springframework.batch.core.step.builder.StepBuilderHelper
allowStartIfComplete, enhance, getJobRepository, getName, getTransactionManager, isAllowStartIfComplete, listener, listener, repository, startLimit, transactionManager

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

- Constructor Detail
  - PartitionStepBuilder
```
public PartitionStepBuilder(StepBuilderHelper<?> parent)
```
    Create a new builder initialized with any properties in the parent. The parent is copied, so it can be re-used.
    Parameters:
    parent - a parent helper containing common step properties
- Method Detail
  - partitioner
```
public PartitionStepBuilder partitioner(java.lang.String slaveStepName,
                                        Partitioner partitioner)
```
    Add a partitioner which can be used to create a StepExecutionSplitter. Use either this or an explicit splitter(StepExecutionSplitter) but not both.
    Parameters:
    slaveStepName - the name of the slave step (used to construct step execution names)
    partitioner - a partitioner to use
    Returns:
    this for fluent chaining
  - step
```
public PartitionStepBuilder step(Step step)
```
    Provide an actual step instance to execute in parallel. If an explicit partitionHandler(PartitionHandler) is provided, the step is optional and is only used to extract configuration data (name and other basic properties of a step).
    Parameters:
    step - a step to execute in parallel
    Returns:
    this for fluent chaining
  - taskExecutor
```
public PartitionStepBuilder taskExecutor(org.springframework.core.task.TaskExecutor taskExecutor)
```
    Provide a task executor to use when constructing a PartitionHandler from the step(Step). Mainly used for running a step locally in parallel, but can be used to execute remotely if the step is remote. Not used if an explicit partitionHandler(PartitionHandler) is provided.
    Parameters:
    taskExecutor - a task executor to use when executing steps in parallel
    Returns:
    this for fluent chaining
  - partitionHandler
```
public PartitionStepBuilder partitionHandler(PartitionHandler partitionHandler)
```
    Provide an explicit partition handler that will carry out the work of the partition step. The partition handler is the main SPI for adapting a partition step to a specific distributed computation environment. Optional if you only need local or remote processing through the Step interface.
    Parameters:
    partitionHandler - a partition handler
    Returns:
    this for fluent chaining
    See Also:
    for setting up a default handler that works with a local or remote Step
  - gridSize
```
public PartitionStepBuilder gridSize(int gridSize)
```
    A hint to the splitter(StepExecutionSplitter) about how many step executions are required. If running locally or remotely through a taskExecutor(TaskExecutor) determines precisely the number of step executions in the first attempt at a partition step execution.
    Parameters:
    gridSize - the grid size
    Returns:
    this for fluent chaining
  - splitter
```
public PartitionStepBuilder splitter(StepExecutionSplitter splitter)
```
    Provide an explicit StepExecutionSplitter instead of having one build from the partitioner(String, Partitioner). Useful if you need more control over the splitting.
    Parameters:
    splitter - a step execution splitter
    Returns:
    this for fluent chaining
  - aggregator
```
public PartitionStepBuilder aggregator(StepExecutionAggregator aggregator)
```
    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.
    Parameters:
    aggregator - a step execution aggregator
    Returns:
    this for fluent chaining
  - build
```
public Step build()
```
  - getTaskExecutor
```
protected org.springframework.core.task.TaskExecutor getTaskExecutor()
```
  - getPartitioner
```
protected Partitioner getPartitioner()
```
  - getStep
```
protected Step getStep()
```
  - getPartitionHandler
```
protected PartitionHandler getPartitionHandler()
```
  - getGridSize
```
protected int getGridSize()
```
  - getSplitter
```
protected StepExecutionSplitter getSplitter()
```
  - getAggregator
```
protected StepExecutionAggregator getAggregator()
```
  - getStepName
```
protected java.lang.String getStepName()
```

Class PartitionStepBuilder

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

Methods inherited from class java.lang.Object

Constructor Detail

PartitionStepBuilder

Method Detail

partitioner

step

taskExecutor

partitionHandler

gridSize

splitter

aggregator

build

getTaskExecutor

getPartitioner

getStep

getPartitionHandler

getGridSize

getSplitter

getAggregator

getStepName