Package org.springframework.batch.core.configuration.xml

Class StepParserStepFactoryBean<I,O>

java.lang.Object
org.springframework.batch.core.configuration.xml.StepParserStepFactoryBean<I,O>
All Implemented Interfaces:
org.springframework.beans.factory.Aware, org.springframework.beans.factory.BeanNameAware, org.springframework.beans.factory.FactoryBean<Step>
public class StepParserStepFactoryBean<I,O> extends Object implements org.springframework.beans.factory.FactoryBean<Step>, org.springframework.beans.factory.BeanNameAware
This FactoryBean is used by the batch namespace parser to create Step objects. Stores all of the properties that are configurable on the <step/> (and its inner <tasklet/>). Based on which properties are configured, the getObject() method will delegate to the appropriate class for generating the Step.
Since:
2.0
Author:
Dan Garrette, Josh Long, Michael Minella, Chris Schaefer, Mahmoud Ben Hassine
See Also:

  • Constructor Details

    • StepParserStepFactoryBean

      public StepParserStepFactoryBean()

  • Method Details

    • getObject

      public Step getObject() throws Exception
      Create a Step from the configuration provided.
      Specified by:
      getObject in interface org.springframework.beans.factory.FactoryBean<I>
      Throws:
      Exception
      See Also:
      • FactoryBean.getObject()

    • requiresTransactionManager

      public boolean requiresTransactionManager()

    • enhanceCommonStep

      protected void enhanceCommonStep(StepBuilderHelper<?> builder)
      Parameters:
      builder - StepBuilderHelper representing the step to be enhanced

    • createPartitionStep

      protected Step createPartitionStep()

    • createFaultTolerantStep

      protected Step createFaultTolerantStep()

    • getFaultTolerantStepBuilder

      protected FaultTolerantStepBuilder<I,O> getFaultTolerantStepBuilder(String stepName)

    • registerItemListeners

      protected void registerItemListeners(SimpleStepBuilder<I,O> builder)

    • createSimpleStep

      protected Step createSimpleStep()

    • setChunk

      protected void setChunk(SimpleStepBuilder<I,O> builder)

    • getCompletionPolicy

      protected CompletionPolicy getCompletionPolicy()

    • getSimpleStepBuilder

      protected SimpleStepBuilder<I,O> getSimpleStepBuilder(String stepName)

    • createTaskletStep

      protected TaskletStep createTaskletStep()
      Returns:
      a new TaskletStep

    • enhanceTaskletStepBuilder

      protected void enhanceTaskletStepBuilder(AbstractTaskletStepBuilder<?> builder)

    • createFlowStep

      protected Step createFlowStep()

    • validateFaultTolerantSettings

      protected void validateFaultTolerantSettings()
      Validates that all components required to build a fault tolerant step are set

    • isFaultTolerant

      protected boolean isFaultTolerant()
      Returns:
      true if the step is configured with any components that require fault tolerance

    • getObjectType

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

    • isSingleton

      public boolean isSingleton()
      Specified by:
      isSingleton in interface org.springframework.beans.factory.FactoryBean<I>

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

    • setName

      public void setName(String name)
      Parameters:
      name - the name to set

    • getName

      public String getName()

    • setFlow

      public void setFlow(Flow flow)
      Parameters:
      flow - the flow to set

    • setJob

      public void setJob(Job job)

    • setJobParametersExtractor

      public void setJobParametersExtractor(JobParametersExtractor jobParametersExtractor)

    • setJobLauncher

      public void setJobLauncher(JobLauncher jobLauncher)

    • setPartitioner

      public void setPartitioner(Partitioner partitioner)
      Parameters:
      partitioner - the partitioner to set

    • setStepExecutionAggregator

      public void setStepExecutionAggregator(StepExecutionAggregator stepExecutionAggregator)
      Parameters:
      stepExecutionAggregator - the stepExecutionAggregator to set

    • getStepExecutionAggergator

      protected StepExecutionAggregator getStepExecutionAggergator()
      Returns:
      stepExecutionAggregator the current step's StepExecutionAggregator

    • setPartitionHandler

      public void setPartitionHandler(PartitionHandler partitionHandler)
      Parameters:
      partitionHandler - the partitionHandler to set

    • getPartitionHandler

      protected PartitionHandler getPartitionHandler()
      Returns:
      partitionHandler the current step's PartitionHandler

    • setGridSize

      public void setGridSize(int gridSize)
      Parameters:
      gridSize - the gridSize to set

    • setStep

      public void setStep(Step step)
      Parameters:
      step - the step 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

    • getJobRepository

      public JobRepository getJobRepository()
      Returns:
      jobRepository

    • setJobRepository

      public void setJobRepository(JobRepository jobRepository)
      Public setter for JobRepository.
      Parameters:
      jobRepository - JobRepository instance to be used by the step.

    • setStartLimit

      public void setStartLimit(int startLimit)
      The number of times that the step should be allowed to start
      Parameters:
      startLimit - int containing the number of times a step should be allowed to start.

    • setTasklet

      public void setTasklet(Tasklet tasklet)
      A preconfigured Tasklet to use.
      Parameters:
      tasklet - Tasklet instance to be used by step.

    • getTasklet

      protected Tasklet getTasklet()

    • getTransactionManager

      public org.springframework.transaction.PlatformTransactionManager getTransactionManager()
      Returns:
      transactionManager instance of PlatformTransactionManager used by the step.

    • setTransactionManager

      public void setTransactionManager(org.springframework.transaction.PlatformTransactionManager transactionManager)
      Parameters:
      transactionManager - the transaction manager to set

    • setListeners

      public void setListeners(Object[] 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

    • setNoRollbackExceptionClasses

      public void setNoRollbackExceptionClasses(Collection<Class<? extends Throwable>> noRollbackExceptionClasses)
      Exception classes that may not cause a rollback if encountered in the right place.
      Parameters:
      noRollbackExceptionClasses - the noRollbackExceptionClasses to set

    • setTransactionTimeout

      public void setTransactionTimeout(int transactionTimeout)
      Parameters:
      transactionTimeout - the transactionTimeout to set

    • setIsolation

      public void setIsolation(org.springframework.transaction.annotation.Isolation isolation)
      Parameters:
      isolation - the isolation to set

    • setPropagation

      public void setPropagation(org.springframework.transaction.annotation.Propagation propagation)
      Parameters:
      propagation - the propagation to set

    • setBackOffPolicy

      public void setBackOffPolicy(org.springframework.retry.backoff.BackOffPolicy backOffPolicy)
      A backoff policy to be applied to retry process.
      Parameters:
      backOffPolicy - the BackOffPolicy to set

    • setRetryPolicy

      public void setRetryPolicy(org.springframework.retry.RetryPolicy retryPolicy)
      A retry policy to apply when exceptions occur. If this is specified then the retry limit and retryable exceptions will be ignored.
      Parameters:
      retryPolicy - the RetryPolicy to set

    • setRetryContextCache

      public void setRetryContextCache(org.springframework.retry.policy.RetryContextCache retryContextCache)
      Parameters:
      retryContextCache - the RetryContextCache to set

    • setKeyGenerator

      public void setKeyGenerator(KeyGenerator keyGenerator)
      A key generator that can be used to compare items with previously recorded items in a retry. Only used if the reader is a transactional queue.
      Parameters:
      keyGenerator - the KeyGenerator to set

    • setCacheCapacity

      public void setCacheCapacity(int cacheCapacity)
      Public setter for the capacity of the cache in the retry policy. If more items than this fail without being skipped or recovered an exception will be thrown. This is to guard against inadvertent infinite loops generated by item identity problems.

      The default value should be high enough and more for most purposes. To breach the limit in a single-threaded step typically you have to have this many failures in a single transaction. Defaults to the value in the MapRetryContextCache.
      Parameters:
      cacheCapacity - the cache capacity to set (greater than 0 else ignored)

    • 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

    • setCommitInterval

      public void setCommitInterval(int commitInterval)
      Set the commit interval. Either set this or the chunkCompletionPolicy but not both.
      Parameters:
      commitInterval - 1 by default

    • getCommitInterval

      protected Integer getCommitInterval()

    • 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

    • setProcessorTransactional

      public void setProcessorTransactional(Boolean processorTransactional)
      Flag to signal that the processor is transactional, in which case it should be called for every item in every transaction. If false then we can cache the processor results between transactions in the case of a rollback.
      Parameters:
      processorTransactional - the value to set

    • setRetryLimit

      public void setRetryLimit(int retryLimit)
      Public setter for the retry limit. Each item can be retried up to this limit. Note this limit includes the initial attempt to process the item, therefore retryLimit == 1 by default.
      Parameters:
      retryLimit - the retry limit to set, must be greater or equal to 1.

    • setSkipLimit

      public void setSkipLimit(int skipLimit)
      Public setter for a limit that determines skip policy. If this value is positive then an exception in chunk processing will cause the item to be skipped and no exception propagated until the limit is reached. If it is zero then all exceptions will be propagated from the chunk and cause the step to abort.
      Parameters:
      skipLimit - the value to set. Default is 0 (never skip).

    • setSkipPolicy

      public void setSkipPolicy(SkipPolicy skipPolicy)
      Public setter for a skip policy. If this value is set then the skip limit and skippable exceptions are ignored.
      Parameters:
      skipPolicy - the SkipPolicy to set

    • 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

    • setThrottleLimit

      public void setThrottleLimit(Integer 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.

    • setItemReader

      public void setItemReader(ItemReader<? extends I> itemReader)
      Parameters:
      itemReader - the ItemReader to set

    • setItemProcessor

      public void setItemProcessor(ItemProcessor<? super I,? extends O> itemProcessor)
      Parameters:
      itemProcessor - the ItemProcessor to set

    • setItemWriter

      public void setItemWriter(ItemWriter<? super O> itemWriter)
      Parameters:
      itemWriter - the ItemWriter to set

    • setRetryListeners

      public void setRetryListeners(org.springframework.retry.RetryListener... retryListeners)
      Public setter for the RetryListeners.
      Parameters:
      retryListeners - the RetryListeners to set

    • setSkippableExceptionClasses

      public void setSkippableExceptionClasses(Map<Class<? extends Throwable>,Boolean> exceptionClasses)
      Public setter for exception classes that when raised won't crash the job but will result in transaction rollback and the item which handling caused the exception will be skipped.
      Parameters:
      exceptionClasses - Map containing the Throwables as the keys and the values are Booleans, that if true the item is skipped.

    • setRetryableExceptionClasses

      public void setRetryableExceptionClasses(Map<Class<? extends Throwable>,Boolean> retryableExceptionClasses)
      Public setter for exception classes that will retry the item when raised.
      Parameters:
      retryableExceptionClasses - the retryableExceptionClasses 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

    • setHasChunkElement

      public void setHasChunkElement(boolean hasChunkElement)
      Parameters:
      hasChunkElement - true if step has <chunk/> element.

    • hasChunkElement

      protected boolean hasChunkElement()
      Returns:
      true if the defined step has a <chunk/> element

    • hasTasklet

      protected boolean hasTasklet()
      Returns:
      true if the defined step has a <tasklet/> element

    • hasPartitionElement

      protected boolean hasPartitionElement()
      Returns:
      true if the defined step has a <partition/> element