Package org.springframework.batch.core.step.item

Class SimpleChunkProcessor<I,O>

java.lang.Object
org.springframework.batch.core.step.item.SimpleChunkProcessor<I,O>
All Implemented Interfaces:
ChunkProcessor<I>, org.springframework.beans.factory.InitializingBean
Direct Known Subclasses:
FaultTolerantChunkProcessor
public class SimpleChunkProcessor<I,O> extends Object implements ChunkProcessor<I>, org.springframework.beans.factory.InitializingBean
Simple implementation of the ChunkProcessor interface that handles basic item writing and processing. Any exceptions encountered will be rethrown.
See Also:

  • Field Details

    • meterRegistry

      protected io.micrometer.core.instrument.MeterRegistry meterRegistry

  • Constructor Details

    • SimpleChunkProcessor

      public SimpleChunkProcessor(@Nullable ItemProcessor<? super I,? extends O> itemProcessor, ItemWriter<? super O> itemWriter)

    • SimpleChunkProcessor

      public SimpleChunkProcessor(ItemWriter<? super O> itemWriter)

  • Method Details

    • 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

    • setMeterRegistry

      public void setMeterRegistry(io.micrometer.core.instrument.MeterRegistry meterRegistry)
      Set the meter registry to use for metrics.
      Parameters:
      meterRegistry - the meter registry
      Since:
      5.0

    • afterPropertiesSet

      public void afterPropertiesSet() throws Exception
      Check mandatory properties.
      Specified by:
      afterPropertiesSet in interface org.springframework.beans.factory.InitializingBean
      Throws:
      Exception
      See Also:
      • InitializingBean.afterPropertiesSet()

    • setListeners

      public void setListeners(List<? extends StepListener> listeners)
      Register some StepListeners with the handler. Each will get the callbacks in the order specified at the correct stage.
      Parameters:
      listeners - list of StepListener instances.

    • registerListener

      public void registerListener(StepListener listener)
      Register a listener for callbacks at the appropriate stages in a process.
      Parameters:
      listener - a StepListener

    • getListener

      protected MulticasterBatchListener<I,O> getListener()
      Returns:
      the listener

    • doProcess

      protected final O doProcess(I item) throws Exception
      Parameters:
      item - the input item
      Returns:
      the result of the processing
      Throws:
      Exception - thrown if error occurs.

    • doWrite

      protected final void doWrite(Chunk<O> items) throws Exception
      Surrounds the actual write call with listener callbacks.
      Parameters:
      items - list of items to be written.
      Throws:
      Exception - thrown if error occurs.

    • doAfterWrite

      protected final void doAfterWrite(Chunk<O> items)
      Call the listener's after write method.
      Parameters:
      items - list of items that were just written.

    • doOnWriteError

      protected final void doOnWriteError(Exception e, Chunk<O> items)
      Call listener's writerError method.
      Parameters:
      e - exception that occurred.
      items - list of items that failed to be written.

    • writeItems

      protected void writeItems(Chunk<O> items) throws Exception
      Parameters:
      items - list of items to be written.
      Throws:
      Exception - thrown if error occurs.

    • process

      public final void process(StepContribution contribution, Chunk<I> inputs) throws Exception
      Specified by:
      process in interface ChunkProcessor<I>
      Throws:
      Exception

    • initializeUserData

      protected void initializeUserData(Chunk<I> inputs)
      Extension point for subclasses to allow them to memorise the contents of the inputs, in case they are needed for accounting purposes later. The default implementation sets up some user data to remember the original size of the inputs. If this method is overridden then some or all of isComplete(Chunk), getFilterCount(Chunk, Chunk) and getAdjustedOutputs(Chunk, Chunk) might also need to be, to ensure that the user data is handled consistently.
      Parameters:
      inputs - the inputs for the process

    • getFilterCount

      protected int getFilterCount(Chunk<I> inputs, Chunk<O> outputs)
      Extension point for subclasses to calculate the filter count. Defaults to the difference between input size and output size.
      Parameters:
      inputs - the inputs after transformation
      outputs - the outputs after transformation
      Returns:
      the difference in sizes
      See Also:

    • isComplete

      protected boolean isComplete(Chunk<I> inputs)
      Extension point for subclasses that want to store additional data in the inputs. Default just checks if inputs are empty.
      Parameters:
      inputs - the input chunk
      Returns:
      true if it is empty
      See Also:

    • getAdjustedOutputs

      protected Chunk<O> getAdjustedOutputs(Chunk<I> inputs, Chunk<O> outputs)
      Extension point for subclasses that want to adjust the outputs based on additional saved data in the inputs. Default implementation just returns the outputs unchanged.
      Parameters:
      inputs - the inputs for the transformation
      outputs - the result of the transformation
      Returns:
      the outputs unchanged
      See Also:

    • write

      protected void write(StepContribution contribution, Chunk<I> inputs, Chunk<O> outputs) throws Exception
      Simple implementation delegates to the doWrite(Chunk) method and increments the write count in the contribution. Subclasses can handle more complicated scenarios, e.g.with fault tolerance. If output items are skipped they should be removed from the inputs as well.
      Parameters:
      contribution - the current step contribution
      inputs - the inputs that gave rise to the outputs
      outputs - the outputs to write
      Throws:
      Exception - if there is a problem

    • transform

      protected Chunk<O> transform(StepContribution contribution, Chunk<I> inputs) throws Exception
      Throws:
      Exception

    • stopTimer

      protected void stopTimer(io.micrometer.core.instrument.Timer.Sample sample, StepExecution stepExecution, String metricName, String status, String description)