Package 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 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, Mahmoud Ben Hassine
See Also:

  • Field Details

    • jobRepository

      protected JobRepository jobRepository

    • observationRegistry

      protected io.micrometer.observation.ObservationRegistry observationRegistry

    • logger

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

  • Constructor Details

  • Method Details

    • 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(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 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 StepListeners.
      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).

    • setObservationRegistry

      public void setObservationRegistry(io.micrometer.observation.ObservationRegistry observationRegistry)
      Public setter for ObservationRegistry.
      Parameters:
      observationRegistry - is an optional dependency (defaults to ObservationRegistry.NOOP).

    • 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 Exception
      Create a Step from the configuration provided.
      Specified by:
      getObject in interface org.springframework.beans.factory.FactoryBean<T>
      Throws:
      Exception
      See Also:
      • FactoryBean.getObject()

    • createBuilder

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

    • getObjectType

      public Class<TaskletStep> getObjectType()
      Specified by:
      getObjectType in interface org.springframework.beans.factory.FactoryBean<T>

    • 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<T>
      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

      @Deprecated(since="5.0", forRemoval=true) public void setThrottleLimit(int throttleLimit)
      Deprecated, for removal: This API element is subject to removal in a future version.
      since 5.0, scheduled for removal in 6.0. Use a pooled TaskExecutor implementation with a limited capacity of its task queue instead.
      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)