Package org.springframework.batch.integration.async

# Class AsyncItemProcessor<I,O>

java.lang.Object
org.springframework.batch.integration.async.AsyncItemProcessor<I,O>

Type Parameters:
  `I` - the input object type
  `O` - the output object type (will be wrapped in a Future)

All Implemented Interfaces:
  `ItemProcessor<I,Future<O>>`, `org.springframework.beans.factory.InitializingBean`

public class AsyncItemProcessor<I,O> extends Object implements ItemProcessor<I,Future<O>>, org.springframework.beans.factory.InitializingBean
An `ItemProcessor` that delegates to a nested processor and in the background. To allow for background processing the return value from the processor is a `Future` which needs to be unpacked before the item can be used by a client. Because the `Future` is typically unwrapped in the `ItemWriter`, there are lifecycle and stats limitations (since the framework doesn't know what the result of the processor is). While not an exhaustive list, things like `StepExecution.filterCount` will not reflect the number of filtered items and `ItemProcessListener.onProcessError(Object, Exception)` will not be called.

Author:
  Dave Syer
See Also:
  - `AsyncItemWriter`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `AsyncItemProcessor()`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `afterPropertiesSet()`
  Check mandatory properties (the `setDelegate(ItemProcessor)`).
  `Future<O>`
  `process(I item)`
  Transform the input by delegating to the provided item processor.
  `void`
  `setDelegate(ItemProcessor<I,O> delegate)`
  The `ItemProcessor` to use to delegate processing to in a background thread.
  `void`
  `setTaskExecutor(org.springframework.core.task.TaskExecutor taskExecutor)`
  The `TaskExecutor` to use to allow the item processing to proceed in the background.

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

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

- ## Constructor Details

  - ### AsyncItemProcessor

    public AsyncItemProcessor()

- ## Method Details

  - ### afterPropertiesSet

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

  - ### setDelegate

    public void setDelegate(ItemProcessor<I,O> delegate)
    The `ItemProcessor` to use to delegate processing to in a background thread.
    Parameters:
      `delegate` - the `ItemProcessor` to use as a delegate

  - ### setTaskExecutor

    public void setTaskExecutor(org.springframework.core.task.TaskExecutor taskExecutor)
    The `TaskExecutor` to use to allow the item processing to proceed in the background. Defaults to a `SyncTaskExecutor` so no threads are created unless this is overridden.
    Parameters:
      `taskExecutor` - a `TaskExecutor`

  - ### process

    @Nullable public Future<O> process(I item) throws Exception
    Transform the input by delegating to the provided item processor. The return value is wrapped in a `Future` so that clients can unpack it later.
    Specified by:
      `process` in interface `ItemProcessor<I,O>`
    Parameters:
      `item` - to be processed, never `null`.
    Returns:
      potentially modified or new item for continued processing, `null` if processing of the provided item should not continue.
    Throws:
      `Exception` - thrown if exception occurs during processing.
    See Also:
      - `ItemProcessor.process(Object)`