Package 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:
  `RemotePartitioningManagerStepBuilder`

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

  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 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(String workerStepName, 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 Details

  - ### 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 Details

  - ### partitioner

    public PartitionStepBuilder partitioner(String workerStepName, 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:
      `workerStepName` - the name of the worker 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 String getStepName()