org.springframework.batch.core.resource

## Class StepExecutionSimpleCompletionPolicy

- java.lang.Object
- - org.springframework.batch.core.listener.StepExecutionListenerSupport
  - - org.springframework.batch.core.resource.StepExecutionSimpleCompletionPolicy

- All Implemented Interfaces:
    StepExecutionListener, StepListener, CompletionPolicy

      public class StepExecutionSimpleCompletionPolicy
      extends StepExecutionListenerSupport
      implements CompletionPolicy

  A `CompletionPolicy` that picks up a commit interval from `JobParameters` by listening to the start of a step. Use anywhere that a `CompletionPolicy` can be used (usually at the chunk level in a step), and inject as a `StepExecutionListener` into the surrounding step. N.B. only after the step has started will the completion policy be usable.

  It is easier and probably preferable to simply declare the chunk with a commit-interval that is a late-binding expression (e.g. `#{jobParameters['commit.interval']}`). That feature is available from of Spring Batch 2.1.7.

  Author:
    Dave Syer
  See Also:
    `CompletionPolicy`

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `StepExecutionSimpleCompletionPolicy()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `beforeStep(StepExecution stepExecution)` Set up a `SimpleCompletionPolicy` with a commit interval taken from the `JobParameters`.
    `boolean` | `isComplete(RepeatContext context)` Allow policy to signal completion according to internal state, without having to wait for the callback to complete.
    `boolean` | `isComplete(RepeatContext context, RepeatStatus result)` Determine whether a batch is complete given the latest result from the callback.
    `void` | `setKeyName(java.lang.String keyName)` Public setter for the key name of a Long value in the `JobParameters` that will contain a commit interval.
    `RepeatContext` | `start(RepeatContext parent)` Create a new context for the execution of a batch.
    `java.lang.String` | `toString()` Delegates to the wrapped `CompletionPolicy` if set, otherwise returns the value of `setKeyName(String)`.
    `void` | `update(RepeatContext context)` Give implementations the opportunity to update the state of the current batch.

    - ### Methods inherited from class org.springframework.batch.core.listener.StepExecutionListenerSupport

      `afterStep`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### StepExecutionSimpleCompletionPolicy

          public StepExecutionSimpleCompletionPolicy()

  - ### Method Detail

    - #### setKeyName

          public void setKeyName(java.lang.String keyName)

      Public setter for the key name of a Long value in the `JobParameters` that will contain a commit interval. Defaults to "commit.interval".
      Parameters:
        `keyName` - the keyName to set

    - #### beforeStep

          public void beforeStep(StepExecution stepExecution)

      Set up a `SimpleCompletionPolicy` with a commit interval taken from the `JobParameters`. If there is a Long parameter with the given key name, the intValue of this parameter is used. If not an exception will be thrown.
      Specified by:
        `beforeStep` in interface `StepExecutionListener`
      Overrides:
        `beforeStep` in class `StepExecutionListenerSupport`
      Parameters:
        `stepExecution` - instance of `StepExecution`.
      See Also:
        `StepExecutionListenerSupport.beforeStep(org.springframework.batch.core.StepExecution)`

    - #### isComplete

          public boolean isComplete(RepeatContext context,
                                    RepeatStatus result)

      Description copied from interface: `CompletionPolicy`
      Determine whether a batch is complete given the latest result from the callback. If this method returns true then `CompletionPolicy.isComplete(RepeatContext)` should also (but not necessarily vice versa, since the answer here depends on the result).
      Specified by:
        `isComplete` in interface `CompletionPolicy`
      Parameters:
        `context` - the current batch context.
        `result` - the result of the latest batch item processing.
      Returns:
        true if the commit interval has been reached or the result indicates completion
      See Also:
        `CompletionPolicy.isComplete(RepeatContext, RepeatStatus)`

    - #### isComplete

          public boolean isComplete(RepeatContext context)

      Description copied from interface: `CompletionPolicy`
      Allow policy to signal completion according to internal state, without having to wait for the callback to complete.
      Specified by:
        `isComplete` in interface `CompletionPolicy`
      Parameters:
        `context` - the current batch context.
      Returns:
        if the commit interval has been reached
      See Also:
        `CompletionPolicy.isComplete(org.springframework.batch.repeat.RepeatContext)`

    - #### start

          public RepeatContext start(RepeatContext parent)

      Description copied from interface: `CompletionPolicy`
      Create a new context for the execution of a batch. N.B. implementations should not return the parent from this method - they must create a new context to meet the specific needs of the policy. The best way to do this might be to override an existing implementation and use the `RepeatContext` to store state in its attributes.
      Specified by:
        `start` in interface `CompletionPolicy`
      Parameters:
        `parent` - the current context if one is already in progress.
      Returns:
        a new `RepeatContext`
      See Also:
        `CompletionPolicy.start(org.springframework.batch.repeat.RepeatContext)`

    - #### update

          public void update(RepeatContext context)

      Description copied from interface: `CompletionPolicy`
      Give implementations the opportunity to update the state of the current batch. Will be called once per callback, after it has been launched, but not necessarily after it completes (if the batch is asynchronous).
      Specified by:
        `update` in interface `CompletionPolicy`
      Parameters:
        `context` - the value returned by start.
      See Also:
        `CompletionPolicy.update(org.springframework.batch.repeat.RepeatContext)`

    - #### toString

          public java.lang.String toString()

      Delegates to the wrapped `CompletionPolicy` if set, otherwise returns the value of `setKeyName(String)`.
      Overrides:
        `toString` in class `java.lang.Object`