org.springframework.batch.core.step.builder

## Class PartitionStepBuilder

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

- Direct Known Subclasses:
    JsrPartitionStepBuilder

      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

- - ### 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 and 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 and 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 execution sin 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()