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. It stores all of the properties that are configurable on the <step/> (and its inner <tasklet/>). Based on which properties are configured, the getObject() method delegates 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()
      Currently, all step implementations other than TaskletStep are instances of AbstractStep and do not require a transaction manager.

    • enhanceCommonStep

      protected void enhanceCommonStep(StepBuilderHelper<?> builder)
      Enhances a step with attributes from the provided StepBuilderHelper.
      Parameters:
      builder - StepBuilderHelper representing the step to be enhanced

    • createPartitionStep

      protected Step createPartitionStep()
      Create a partition Step.
      Returns:
      the Step.

    • createFaultTolerantStep

      protected Step createFaultTolerantStep()
      Creates a fault tolerant Step.
      Returns:
      the Step.

    • getFaultTolerantStepBuilder

      protected FaultTolerantStepBuilder<I,O> getFaultTolerantStepBuilder(String stepName)
      Creates a new FaultTolerantStepBuilder.
      Parameters:
      stepName - The name of the step used by the created builder.
      Returns:
      the FaultTolerantStepBuilder.

    • registerItemListeners

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

    • createSimpleStep

      protected Step createSimpleStep()
      Creates a new TaskletStep.
      Returns:
      the TaskletStep.

    • setChunk

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

    • getCompletionPolicy

      protected CompletionPolicy getCompletionPolicy()

    • getSimpleStepBuilder

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

    • createTaskletStep

      protected TaskletStep createTaskletStep()
      Create a new TaskletStep.
      Returns:
      a new TaskletStep

    • enhanceTaskletStepBuilder

      protected void enhanceTaskletStepBuilder(AbstractTaskletStepBuilder<?> builder)
      Set the state of the AbstractTaskletStepBuilder using the values that were established for the factory bean.
      Parameters:
      builder - The AbstractTaskletStepBuilder to be modified.

    • createFlowStep

      protected Step createFlowStep()
      Create a new FlowStep.
      Returns:
      the FlowStep.

    • validateFaultTolerantSettings

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

    • isFaultTolerant

      protected boolean isFaultTolerant()
      Indicates whether the step has any components that require fault tolerance.
      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:
      The current step's StepExecutionAggregator

    • setPartitionHandler

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

    • getPartitionHandler

      protected PartitionHandler getPartitionHandler()
      Returns:
      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:
      The 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:
      An 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 then receives 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 the 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. Used only 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 there are more items than the specified capacity, the the step fails without being skipped or recovered, and an exception is thrown. This guards against inadvertent infinite loops generated by item identity problems.

      The default value should be high enough for most purposes. To breach the limit in a single-threaded step, you typically 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 that applies to the chunk level. A transaction is 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. Set either this or the chunkCompletionPolicy but not both.
      Parameters:
      commitInterval - 1 by default

    • getCommitInterval

      protected Integer getCommitInterval()
      Returns:
      The commit interval.

    • 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 that case, it should be called for every item in every transaction. If false, 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 that this limit includes the initial attempt to process the item. Therefore, by default, retryLimit == 1.
      Parameters:
      retryLimit - The retry limit to set. Must be greater than or equal to 1.

    • setSkipLimit

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

    • setSkipPolicy

      public void setSkipPolicy(SkipPolicy skipPolicy)
      Public setter for a skip policy. If this value is set, 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, it is 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 RetryListener instances.
      Parameters:
      retryListeners - The RetryListener instances to set.

    • setSkippableExceptionClasses

      public void setSkippableExceptionClasses(Map<Class<? extends Throwable>,Boolean> exceptionClasses)
      Public setter for exception classes that, when raised, do not crash the job but result in transaction rollback. The item for which handling caused the exception is skipped.
      Parameters:
      exceptionClasses - A Map containing the Throwable instances as the keys and the Boolean instances as the values. If true, the item is skipped.

    • setRetryableExceptionClasses

      public void setRetryableExceptionClasses(Map<Class<? extends Throwable>,Boolean> retryableExceptionClasses)
      Public setter for exception classes that retries 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 it then receives 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.