Clarify ChunkListener changes in v6

Resolves #5226

Author: fmbenhassine

spring-batch-core/src/main/java/org/springframework/batch/core/listener/ChunkListener.java

@@ -81,16 +81,16 @@ default void afterChunkError(ChunkContext context) {
 	}
 
 	/**
-	 * Callback before the chunk is processed, inside the transaction. This method is not
-	 * called in concurrent steps.
+	 * Callback after a chunk is read but before it is processed, inside the transaction.
+	 * <strong>This method is not called in concurrent steps.</strong>
 	 * @since 6.0
 	 */
 	default void beforeChunk(Chunk<I> chunk) {
 	}
 
 	/**
-	 * Callback after the chunk is written, inside the transaction. This method is not
-	 * called in concurrent steps.
+	 * Callback after the chunk is written, inside the transaction. <strong>This method is
+	 * not called in concurrent steps.</strong>
 	 * @since 6.0
 	 */
 	default void afterChunk(Chunk<O> chunk) {
@@ -100,7 +100,7 @@ default void afterChunk(Chunk<O> chunk) {
 	 * Callback if an exception occurs while processing or writing a chunk, inside the
 	 * transaction, which is about to be rolled back. <em>As a result, you should use
 	 * {@code PROPAGATION_REQUIRES_NEW} for any transactional operation that is called
-	 * here</em>. This method is not called in concurrent steps.
+	 * here</em>. <strong>This method is not called in concurrent steps.</strong>
 	 * @param exception the exception that caused the underlying rollback.
 	 * @param chunk the processed chunk
 	 * @since 6.0

spring-batch-docs/modules/ROOT/pages/step/chunk-oriented-processing/intercepting-execution.adoc

@@ -103,33 +103,31 @@ The annotations corresponding to this interface are:
 A "`chunk`" is defined as the items processed within the scope of a transaction. Committing a
 transaction, at each commit interval, commits a chunk. You can use a `ChunkListener` to
 perform logic before a chunk begins processing or after a chunk has completed
-successfully, as the following interface definition shows:
+successfully or in failure, as the following interface definition shows:
 
 [source, java]
 ----
-public interface ChunkListener extends StepListener {
+public interface ChunkListener<I, O> extends StepListener {
 
-    void beforeChunk(ChunkContext context);
-    void afterChunk(ChunkContext context);
-    void afterChunkError(ChunkContext context);
+    void beforeChunk(Chunk<I> chunk);
+    void afterChunk(Chunk<O> chunk);
+    void afterChunkError(Exception exception, Chunk<O> chunk);
 
 }
 ----
 
-The beforeChunk method is called after the transaction is started but before reading begins
-on the `ItemReader`. Conversely, `afterChunk` is called after the chunk has been
-committed (or not at all if there is a rollback).
+The `beforeChunk` method is called after the transaction is started after reading a chunk
+of items but before processing start. Conversely, `afterChunk` is called after the chunk
+is written but before the transaction is committed or rolled back.
+
+NOTE: The `ChunkListener` listener interface is not called in concurrent steps
 
 The annotations corresponding to this interface are:
 
 * `@BeforeChunk`
 * `@AfterChunk`
 * `@AfterChunkError`
 
-You can apply a `ChunkListener` when there is no chunk declaration. The `TaskletStep` is
-responsible for calling the `ChunkListener`, so it applies to a non-item-oriented tasklet
-as well (it is called before and after the tasklet).
-
 A `ChunkListener` is not designed to throw checked exceptions. Errors must be handled in the
 implementation or the step will terminate.