org.springframework.batch.core.step.factory

## Class SimpleStepFactoryBean<T,S>

- java.lang.Object
- - org.springframework.batch.core.step.factory.SimpleStepFactoryBean<T,S>

- All Implemented Interfaces:
    org.springframework.beans.factory.Aware, org.springframework.beans.factory.BeanNameAware, org.springframework.beans.factory.FactoryBean<Step>
  Direct Known Subclasses:
    FaultTolerantStepFactoryBean

      public class SimpleStepFactoryBean<T,S>
      extends java.lang.Object
      implements org.springframework.beans.factory.FactoryBean<Step>, org.springframework.beans.factory.BeanNameAware

  Most common configuration options for simple steps should be found here. Use this factory bean instead of creating a `Step` implementation manually. This factory does not support configuration of fault-tolerant behavior, use appropriate subclass of this factory bean to configure skip or retry.
  Author:
    Dave Syer, Robert Kasanicky
  See Also:
    `FaultTolerantStepFactoryBean`

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected org.apache.commons.logging.Log` | `logger`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `SimpleStepFactoryBean()` Default constructor for `SimpleStepFactoryBean`.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | `applyConfiguration(SimpleStepBuilder<T,S> builder)`
    `protected SimpleStepBuilder<T,S>` | `createBuilder(java.lang.String name)`
    `protected RepeatOperations` | `getChunkOperations()` Protected getter for the chunk operations to make them available in subclasses.
    `protected ExceptionHandler` | `getExceptionHandler()` Protected getter for the `ExceptionHandler`.
    `protected ItemProcessor<? super T,? extends S>` | `getItemProcessor()` Protected getter for the `ItemProcessor` for subclasses to use
    `protected ItemReader<? extends T>` | `getItemReader()` Protected getter for the `ItemReader` for subclasses to use.
    `protected ItemWriter<? super S>` | `getItemWriter()` Protected getter for the `ItemWriter` for subclasses to use
    `protected StepListener[]` | `getListeners()` Protected getter for the `StepListener`s.
    `java.lang.String` | `getName()` Public getter for the name of the step.
    `Step` | `getObject()` Create a `Step` from the configuration provided.
    `java.lang.Class<TaskletStep>` | `getObjectType()`
    `protected RepeatOperations` | `getStepOperations()` Protected getter for the step operations to make them available in subclasses.
    `protected org.springframework.core.task.TaskExecutor` | `getTaskExecutor()` Make the `TaskExecutor` available to subclasses
    `protected org.springframework.transaction.interceptor.TransactionAttribute` | `getTransactionAttribute()` Getter for the `TransactionAttribute` for subclasses only.
    `protected boolean` | `isReaderTransactionalQueue()` Convenience method for subclasses.
    `boolean` | `isSingleton()` Returns true by default, but in most cases a `Step` should not be treated as thread-safe.
    `void` | `setAllowStartIfComplete(boolean allowStartIfComplete)` Public setter for the flag to indicate that the step should be replayed on a restart, even if successful the first time.
    `void` | `setBeanName(java.lang.String name)` Set the bean name property, which will become the name of the `Step` when it is created.
    `void` | `setChunkCompletionPolicy(CompletionPolicy chunkCompletionPolicy)` Public setter for the `CompletionPolicy` applying to the chunk level.
    `void` | `setChunkOperations(RepeatOperations chunkOperations)` Public setter for the chunkOperations.
    `void` | `setCommitInterval(int commitInterval)` Set the commit interval.
    `void` | `setExceptionHandler(ExceptionHandler exceptionHandler)` Public setter for the `ExceptionHandler`.
    `void` | `setIsolation(org.springframework.transaction.annotation.Isolation isolation)`
    `void` | `setIsReaderTransactionalQueue(boolean isReaderTransactionalQueue)` Flag to signal that the reader is transactional (usually a JMS consumer) so that items are re-presented after a rollback.
    `void` | `setItemProcessor(ItemProcessor<? super T,? extends S> itemProcessor)`
    `void` | `setItemReader(ItemReader<? extends T> itemReader)`
    `void` | `setItemWriter(ItemWriter<? super S> itemWriter)`
    `void` | `setJobRepository(JobRepository jobRepository)` Public setter for `JobRepository`.
    `void` | `setListeners(StepListener[] listeners)` The listeners to inject into the `Step`.
    `void` | `setPropagation(org.springframework.transaction.annotation.Propagation propagation)`
    `void` | `setSingleton(boolean singleton)` Public setter for the singleton flag.
    `void` | `setStartLimit(int startLimit)` Public setter for the start limit for the step.
    `void` | `setStepOperations(RepeatOperations stepOperations)` Public setter for the stepOperations.
    `void` | `setStreams(ItemStream[] streams)` The streams to inject into the `Step`.
    `void` | `setTaskExecutor(org.springframework.core.task.TaskExecutor taskExecutor)` Public setter for the `TaskExecutor`.
    `void` | `setThrottleLimit(int throttleLimit)` Public setter for the throttle limit.
    `void` | `setTransactionManager(org.springframework.transaction.PlatformTransactionManager transactionManager)` Public setter for the `PlatformTransactionManager`.
    `void` | `setTransactionTimeout(int transactionTimeout)` The timeout for an individual transaction in the step.

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

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

- - ### Field Detail

    - #### logger

          protected final org.apache.commons.logging.Log logger

  - ### Constructor Detail

    - #### SimpleStepFactoryBean

          public SimpleStepFactoryBean()

      Default constructor for `SimpleStepFactoryBean`.

  - ### Method Detail

    - #### setIsReaderTransactionalQueue

          public void setIsReaderTransactionalQueue(boolean isReaderTransactionalQueue)

      Flag to signal that the reader is transactional (usually a JMS consumer) so that items are re-presented after a rollback. The default is false and readers are assumed to be forward-only.
      Parameters:
        `isReaderTransactionalQueue` - the value of the flag

    - #### isReaderTransactionalQueue

          protected boolean isReaderTransactionalQueue()

      Convenience method for subclasses.
      Returns:
        true if the flag is set (default false)

    - #### setBeanName

          public void setBeanName(java.lang.String name)

      Set the bean name property, which will become the name of the `Step` when it is created.
      Specified by:
        `setBeanName` in interface `org.springframework.beans.factory.BeanNameAware`
      See Also:
        `BeanNameAware.setBeanName(java.lang.String)`

    - #### getName

          public java.lang.String getName()

      Public getter for the name of the step.
      Returns:
        the name

    - #### setTransactionTimeout

          public void setTransactionTimeout(int transactionTimeout)

      The timeout for an individual transaction in the step.
      Parameters:
        `transactionTimeout` - the transaction timeout to set, defaults to infinite

    - #### setPropagation

          public void setPropagation(org.springframework.transaction.annotation.Propagation propagation)

      Parameters:
        `propagation` - the propagation to set for business transactions

    - #### setIsolation

          public void setIsolation(org.springframework.transaction.annotation.Isolation isolation)

      Parameters:
        `isolation` - the isolation to set for business transactions

    - #### setStartLimit

          public void setStartLimit(int startLimit)

      Public setter for the start limit for the step.
      Parameters:
        `startLimit` - the startLimit to set

    - #### setAllowStartIfComplete

          public void setAllowStartIfComplete(boolean allowStartIfComplete)

      Public setter for the flag to indicate that the step should be replayed on a restart, even if successful the first time.
      Parameters:
        `allowStartIfComplete` - the shouldAllowStartIfComplete to set

    - #### setItemReader

          public void setItemReader(ItemReader<? extends T> itemReader)

      Parameters:
        `itemReader` - the `ItemReader` to set

    - #### setItemWriter

          public void setItemWriter(ItemWriter<? super S> itemWriter)

      Parameters:
        `itemWriter` - the `ItemWriter` to set

    - #### setItemProcessor

          public void setItemProcessor(ItemProcessor<? super T,? extends S> itemProcessor)

      Parameters:
        `itemProcessor` - the `ItemProcessor` to set

    - #### setStreams

          public void setStreams(ItemStream[] streams)

      The streams to inject into the `Step`. Any instance of `ItemStream` can be used, and will then receive callbacks at the appropriate stage in the step.
      Parameters:
        `streams` - an array of listeners

    - #### setListeners

          public void setListeners(StepListener[] listeners)

      The listeners to inject into the `Step`. Any instance of `StepListener` can be used, and will then receive callbacks at the appropriate stage in the step.
      Parameters:
        `listeners` - an array of listeners

    - #### getListeners

          protected StepListener[] getListeners()

      Protected getter for the `StepListener`s.
      Returns:
        the listeners

    - #### getItemReader

          protected ItemReader<? extends T> getItemReader()

      Protected getter for the `ItemReader` for subclasses to use.
      Returns:
        the itemReader

    - #### getItemWriter

          protected ItemWriter<? super S> getItemWriter()

      Protected getter for the `ItemWriter` for subclasses to use
      Returns:
        the itemWriter

    - #### getItemProcessor

          protected ItemProcessor<? super T,? extends S> getItemProcessor()

      Protected getter for the `ItemProcessor` for subclasses to use
      Returns:
        the itemProcessor

    - #### setJobRepository

          public void setJobRepository(JobRepository jobRepository)

      Public setter for `JobRepository`.
      Parameters:
        `jobRepository` - is a mandatory dependence (no default).

    - #### setTransactionManager

          public void setTransactionManager(org.springframework.transaction.PlatformTransactionManager transactionManager)

      Public setter for the `PlatformTransactionManager`.
      Parameters:
        `transactionManager` - the transaction manager to set

    - #### getTransactionAttribute

          protected org.springframework.transaction.interceptor.TransactionAttribute getTransactionAttribute()

      Getter for the `TransactionAttribute` for subclasses only.
      Returns:
        the transactionAttribute

    - #### getObject

          public final Step getObject()
                               throws java.lang.Exception

      Create a `Step` from the configuration provided.
      Specified by:
        `getObject` in interface `org.springframework.beans.factory.FactoryBean<Step>`
      Throws:
        `java.lang.Exception`
      See Also:
        `FactoryBean.getObject()`

    - #### createBuilder

          protected SimpleStepBuilder<T,S> createBuilder(java.lang.String name)

    - #### getObjectType

          public java.lang.Class<TaskletStep> getObjectType()

      Specified by:
        `getObjectType` in interface `org.springframework.beans.factory.FactoryBean<Step>`

    - #### isSingleton

          public boolean isSingleton()

      Returns true by default, but in most cases a `Step` should not be treated as thread-safe. Clients are recommended to create a new step for each job execution.
      Specified by:
        `isSingleton` in interface `org.springframework.beans.factory.FactoryBean<Step>`
      See Also:
        `FactoryBean.isSingleton()`

    - #### setSingleton

          public void setSingleton(boolean singleton)

      Public setter for the singleton flag.
      Parameters:
        `singleton` - the value to set. Defaults to true.

    - #### setCommitInterval

          public void setCommitInterval(int commitInterval)

      Set the commit interval. Either set this or the chunkCompletionPolicy but not both.
      Parameters:
        `commitInterval` - 1 by default

    - #### setChunkCompletionPolicy

          public void setChunkCompletionPolicy(CompletionPolicy chunkCompletionPolicy)

      Public setter for the `CompletionPolicy` applying to the chunk level. A transaction will be committed when this policy decides to complete. Defaults to a `SimpleCompletionPolicy` with chunk size equal to the commitInterval property.
      Parameters:
        `chunkCompletionPolicy` - the chunkCompletionPolicy to set

    - #### getStepOperations

          protected RepeatOperations getStepOperations()

      Protected getter for the step operations to make them available in subclasses.
      Returns:
        the step operations

    - #### setStepOperations

          public void setStepOperations(RepeatOperations stepOperations)

      Public setter for the stepOperations.
      Parameters:
        `stepOperations` - the stepOperations to set

    - #### setChunkOperations

          public void setChunkOperations(RepeatOperations chunkOperations)

      Public setter for the chunkOperations.
      Parameters:
        `chunkOperations` - the chunkOperations to set

    - #### getChunkOperations

          protected RepeatOperations getChunkOperations()

      Protected getter for the chunk operations to make them available in subclasses.
      Returns:
        the step operations

    - #### setExceptionHandler

          public void setExceptionHandler(ExceptionHandler exceptionHandler)

      Public setter for the `ExceptionHandler`.
      Parameters:
        `exceptionHandler` - the exceptionHandler to set

    - #### getExceptionHandler

          protected ExceptionHandler getExceptionHandler()

      Protected getter for the `ExceptionHandler`.
      Returns:
        the `ExceptionHandler`

    - #### setTaskExecutor

          public void setTaskExecutor(org.springframework.core.task.TaskExecutor taskExecutor)

      Public setter for the `TaskExecutor`. If this is set, then it will be used to execute the chunk processing inside the `Step`.
      Parameters:
        `taskExecutor` - the taskExecutor to set

    - #### getTaskExecutor

          protected org.springframework.core.task.TaskExecutor getTaskExecutor()

      Make the `TaskExecutor` available to subclasses
      Returns:
        the taskExecutor to be used to execute chunks

    - #### setThrottleLimit

          public void setThrottleLimit(int throttleLimit)

      Public setter for the throttle limit. This limits the number of tasks queued for concurrent processing to prevent thread pools from being overwhelmed. Defaults to `TaskExecutorRepeatTemplate.DEFAULT_THROTTLE_LIMIT`.
      Parameters:
        `throttleLimit` - the throttle limit to set.

    - #### applyConfiguration

          protected void applyConfiguration(SimpleStepBuilder<T,S> builder)