org.springframework.batch.core.jsr.partition

## Class PartitionCollectorAdapter

- java.lang.Object
- - org.springframework.batch.core.jsr.partition.PartitionCollectorAdapter

- All Implemented Interfaces:
    ChunkListener, StepListener

      public class PartitionCollectorAdapter
      extends java.lang.Object
      implements ChunkListener

  Adapter class used to wrap a `PartitionCollector` so that it can be consumed as a `ChunkListener`. A thread-safe `Queue` is required along with the `PartitionCollector`. The `Queue` is where the result of the call to the PartitionCollector will be placed.
  Since:
    3.0
  Author:
    Michael Minella, Mahmoud Ben Hassine

- - ### Field Summary

    - ### Fields inherited from interface org.springframework.batch.core.ChunkListener

      `ROLLBACK_EXCEPTION_KEY`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `PartitionCollectorAdapter(java.util.Queue<java.io.Serializable> queue, javax.batch.api.partition.PartitionCollector collector)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `afterChunk(ChunkContext context)` Callback after the chunk is executed, outside the transaction.
    `void` | `afterChunkError(ChunkContext context)` Callback after a chunk has been marked for rollback.
    `void` | `beforeChunk(ChunkContext context)` Callback before the chunk is executed, but inside the transaction.
    `void` | `setPartitionLock(java.util.concurrent.locks.ReentrantLock lock)`

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

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

- - ### Constructor Detail

    - #### PartitionCollectorAdapter

          public PartitionCollectorAdapter(java.util.Queue<java.io.Serializable> queue,
                                           javax.batch.api.partition.PartitionCollector collector)

  - ### Method Detail

    - #### setPartitionLock

          public void setPartitionLock(java.util.concurrent.locks.ReentrantLock lock)

    - #### beforeChunk

          public void beforeChunk(ChunkContext context)

      Description copied from interface: `ChunkListener`
      Callback before the chunk is executed, but inside the transaction.
      Specified by:
        `beforeChunk` in interface `ChunkListener`
      Parameters:
        `context` - The current `ChunkContext`

    - #### afterChunk

          public void afterChunk(ChunkContext context)

      Description copied from interface: `ChunkListener`
      Callback after the chunk is executed, outside the transaction.
      Specified by:
        `afterChunk` in interface `ChunkListener`
      Parameters:
        `context` - The current `ChunkContext`

    - #### afterChunkError

          public void afterChunkError(ChunkContext context)

      Description copied from interface: `ChunkListener`
      Callback after a chunk has been marked for rollback. It is invoked after transaction rollback. While the rollback will have occurred, transactional resources might still be active and accessible. Due to this, data access code within this callback will still "participate" in the original transaction unless it declares that it runs in its own transaction. Hence: Use PROPAGATION_REQUIRES_NEW for any transactional operation that is called from here.
      Specified by:
        `afterChunkError` in interface `ChunkListener`
      Parameters:
        `context` - the chunk context containing the exception that caused the underlying rollback.