org.springframework.batch.integration.partition

## Class RemotePartitioningWorkerStepBuilder

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

-     public class RemotePartitioningWorkerStepBuilder
      extends StepBuilder

  Builder for a worker step in a remote partitioning setup. This builder creates an `IntegrationFlow` that:
  - listens to `StepExecutionRequest`s coming from the master on the input channel
  - invokes the `StepExecutionRequestHandler` to execute the worker step for each incoming request. The worker step is located using the provided `StepLocator`. If no `StepLocator` is provided, a `BeanFactoryStepLocator` configured with the current `BeanFactory` will be used
  - replies to the master on the output channel (when the master step is configured to aggregate replies from workers). If no output channel is provided, a `NullChannel` will be used (assuming the master side is configured to poll the job repository for workers status)
  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

      `properties`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `RemotePartitioningWorkerStepBuilder(java.lang.String name)` Initialize a step builder for a step with the given name.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `RemotePartitioningWorkerStepBuilder` | `allowStartIfComplete(boolean allowStartIfComplete)`
    `RemotePartitioningWorkerStepBuilder` | `beanFactory(org.springframework.beans.factory.BeanFactory beanFactory)` Set the bean factory.
    `<I,O> SimpleStepBuilder<I,O>` | `chunk(CompletionPolicy completionPolicy)` Build a step that processes items in chunks with the completion policy provided.
    `<I,O> SimpleStepBuilder<I,O>` | `chunk(int chunkSize)` Build a step that processes items in chunks with the size provided.
    `FlowStepBuilder` | `flow(Flow flow)` Create a new step builder that will execute a flow.
    `RemotePartitioningWorkerStepBuilder` | `inputChannel(org.springframework.messaging.MessageChannel inputChannel)` Set the input channel on which step execution requests sent by the master are received.
    `JobStepBuilder` | `job(Job job)` Create a new step builder that will execute a job.
    `RemotePartitioningWorkerStepBuilder` | `jobExplorer(JobExplorer jobExplorer)` Set the job explorer.
    `RemotePartitioningWorkerStepBuilder` | `listener(java.lang.Object listener)` Registers objects using the annotation based listener configuration.
    `RemotePartitioningWorkerStepBuilder` | `listener(StepExecutionListener listener)`
    `RemotePartitioningWorkerStepBuilder` | `outputChannel(org.springframework.messaging.MessageChannel outputChannel)` Set the output channel on which replies will be sent to the master step.
    `PartitionStepBuilder` | `partitioner(Step step)` Create a partition step builder for a remote (or local) step.
    `PartitionStepBuilder` | `partitioner(java.lang.String stepName, Partitioner partitioner)` Create a partition step builder for a remote (or local) step.
    `RemotePartitioningWorkerStepBuilder` | `repository(JobRepository jobRepository)`
    `RemotePartitioningWorkerStepBuilder` | `startLimit(int startLimit)`
    `RemotePartitioningWorkerStepBuilder` | `stepLocator(StepLocator stepLocator)` Set the step locator used to locate the worker step to execute.
    `TaskletStepBuilder` | `tasklet(Tasklet tasklet)` Build a step with a custom tasklet, not necessarily item processing.
    `RemotePartitioningWorkerStepBuilder` | `transactionManager(org.springframework.transaction.PlatformTransactionManager transactionManager)`

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

    - #### RemotePartitioningWorkerStepBuilder

          public RemotePartitioningWorkerStepBuilder(java.lang.String name)

      Initialize a step builder for a step with the given name.
      Parameters:
        `name` - the name of the step

  - ### Method Detail

    - #### inputChannel

          public RemotePartitioningWorkerStepBuilder inputChannel(org.springframework.messaging.MessageChannel inputChannel)

      Set the input channel on which step execution requests sent by the master are received.
      Parameters:
        `inputChannel` - the input channel
      Returns:
        this builder instance for fluent chaining

    - #### outputChannel

          public RemotePartitioningWorkerStepBuilder outputChannel(org.springframework.messaging.MessageChannel outputChannel)

      Set the output channel on which replies will be sent to the master step.
      Parameters:
        `outputChannel` - the input channel
      Returns:
        this builder instance for fluent chaining

    - #### jobExplorer

          public RemotePartitioningWorkerStepBuilder jobExplorer(JobExplorer jobExplorer)

      Set the job explorer.
      Parameters:
        `jobExplorer` - the job explorer to use
      Returns:
        this builder instance for fluent chaining

    - #### stepLocator

          public RemotePartitioningWorkerStepBuilder stepLocator(StepLocator stepLocator)

      Set the step locator used to locate the worker step to execute.
      Parameters:
        `stepLocator` - the step locator to use
      Returns:
        this builder instance for fluent chaining

    - #### beanFactory

          public RemotePartitioningWorkerStepBuilder beanFactory(org.springframework.beans.factory.BeanFactory beanFactory)

      Set the bean factory.
      Parameters:
        `beanFactory` - the bean factory
      Returns:
        this builder instance for fluent chaining

    - #### repository

          public RemotePartitioningWorkerStepBuilder repository(JobRepository jobRepository)

      Overrides:
        `repository` in class `StepBuilderHelper<StepBuilder>`

    - #### transactionManager

          public RemotePartitioningWorkerStepBuilder transactionManager(org.springframework.transaction.PlatformTransactionManager transactionManager)

      Overrides:
        `transactionManager` in class `StepBuilderHelper<StepBuilder>`

    - #### startLimit

          public RemotePartitioningWorkerStepBuilder startLimit(int startLimit)

      Overrides:
        `startLimit` in class `StepBuilderHelper<StepBuilder>`

    - #### listener

          public RemotePartitioningWorkerStepBuilder listener(java.lang.Object listener)

      Description copied from class: `StepBuilderHelper`
      Registers objects using the annotation based listener configuration.
      Overrides:
        `listener` in class `StepBuilderHelper<StepBuilder>`
      Parameters:
        `listener` - the object that has a method configured with listener annotation
      Returns:
        this for fluent chaining

    - #### listener

          public RemotePartitioningWorkerStepBuilder listener(StepExecutionListener listener)

      Overrides:
        `listener` in class `StepBuilderHelper<StepBuilder>`

    - #### allowStartIfComplete

          public RemotePartitioningWorkerStepBuilder allowStartIfComplete(boolean allowStartIfComplete)

      Overrides:
        `allowStartIfComplete` in class `StepBuilderHelper<StepBuilder>`

    - #### tasklet

          public TaskletStepBuilder tasklet(Tasklet tasklet)

      Description copied from class: `StepBuilder`
      Build a step with a custom tasklet, not necessarily item processing.
      Overrides:
        `tasklet` in class `StepBuilder`
      Parameters:
        `tasklet` - a tasklet
      Returns:
        a `TaskletStepBuilder`

    - #### chunk

          public <I,O> SimpleStepBuilder<I,O> chunk(int chunkSize)

      Description copied from class: `StepBuilder`
      Build a step that processes items in chunks with the size provided. To extend the step to being fault tolerant, call the `SimpleStepBuilder.faultTolerant()` method on the builder. In most cases you will want to parameterize your call to this method, to preserve the type safety of your readers and writers, e.g.

           new StepBuilder("step1").<Order, Ledger> chunk(100).reader(new OrderReader()).writer(new LedgerWriter())
           // ... etc.

      Overrides:
        `chunk` in class `StepBuilder`
      Type Parameters:
        `I` - the type of item to be processed as input
        `O` - the type of item to be output
      Parameters:
        `chunkSize` - the chunk size (commit interval)
      Returns:
        a `SimpleStepBuilder`

    - #### chunk

          public <I,O> SimpleStepBuilder<I,O> chunk(CompletionPolicy completionPolicy)

      Description copied from class: `StepBuilder`
      Build a step that processes items in chunks with the completion policy provided. To extend the step to being fault tolerant, call the `SimpleStepBuilder.faultTolerant()` method on the builder. In most cases you will want to parameterize your call to this method, to preserve the type safety of your readers and writers, e.g.

           new StepBuilder("step1").<Order, Ledger> chunk(100).reader(new OrderReader()).writer(new LedgerWriter())
           // ... etc.

      Overrides:
        `chunk` in class `StepBuilder`
      Type Parameters:
        `I` - the type of item to be processed as input
        `O` - the type of item to be output *
      Parameters:
        `completionPolicy` - the completion policy to use to control chunk processing
      Returns:
        a `SimpleStepBuilder`

    - #### partitioner

          public PartitionStepBuilder partitioner(java.lang.String stepName,
                                                  Partitioner partitioner)

      Description copied from class: `StepBuilder`
      Create a partition step builder for a remote (or local) step.
      Overrides:
        `partitioner` in class `StepBuilder`
      Parameters:
        `stepName` - the name of the remote or delegate step
        `partitioner` - a partitioner to be used to construct new step executions
      Returns:
        a `PartitionStepBuilder`

    - #### partitioner

          public PartitionStepBuilder partitioner(Step step)

      Description copied from class: `StepBuilder`
      Create a partition step builder for a remote (or local) step.
      Overrides:
        `partitioner` in class `StepBuilder`
      Parameters:
        `step` - the step to execute in parallel
      Returns:
        a PartitionStepBuilder

    - #### job

          public JobStepBuilder job(Job job)

      Description copied from class: `StepBuilder`
      Create a new step builder that will execute a job.
      Overrides:
        `job` in class `StepBuilder`
      Parameters:
        `job` - a job to execute
      Returns:
        a `JobStepBuilder`

    - #### flow

          public FlowStepBuilder flow(Flow flow)

      Description copied from class: `StepBuilder`
      Create a new step builder that will execute a flow.
      Overrides:
        `flow` in class `StepBuilder`
      Parameters:
        `flow` - a flow to execute
      Returns:
        a `FlowStepBuilder`