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,java.util.concurrent.Future<O>>, org.springframework.beans.factory.InitializingBean

      public class AsyncItemProcessor<I,O>
      extends java.lang.Object
      implements ItemProcessor<I,java.util.concurrent.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 and Description
    `AsyncItemProcessor()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `afterPropertiesSet()` Check mandatory properties (the `setDelegate(ItemProcessor)`).
    `java.util.concurrent.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 Detail

    - #### AsyncItemProcessor

          public AsyncItemProcessor()

  - ### Method Detail

    - #### afterPropertiesSet

          public void afterPropertiesSet()
                                  throws java.lang.Exception

      Check mandatory properties (the `setDelegate(ItemProcessor)`).
      Specified by:
        `afterPropertiesSet` in interface `org.springframework.beans.factory.InitializingBean`
      Throws:
        `java.lang.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 java.util.concurrent.Future<O> process(I item)
                                                           throws java.lang.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,java.util.concurrent.Future<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:
        `java.lang.Exception` - thrown if exception occurs during processing.
      See Also:
        `ItemProcessor.process(Object)`