Rename ChunkHandler to ChunkRequestHandler

Resolves #4964

Author: fmbenhassine

spring-batch-docs/modules/ROOT/pages/faq.adoc

@@ -63,4 +63,4 @@ and message-oriented middleware (JMS, AQ, MQ, Tibco etc.) gives us a lot of resi
 a system where there is feedback between downstream and upstream stages, so the number of consumers can be adjusted to account for the amount of demand.
 So how does this fit into Spring Batch? The spring-batch-integration project has this pattern implemented in Spring Integration,
 and can be used to scale up the remote processing of any step with many items to process.
-See in particular the "chunk" package, and the `ItemWriter` and `ChunkHandler` implementations in there.
+See in particular the "chunk" package, and the `ItemWriter` and `ChunkRequestHandler` implementations in there.

spring-batch-docs/modules/ROOT/pages/spring-batch-integration/sub-elements.adoc

@@ -545,7 +545,7 @@ XML::
 The following example shows the worker configuration in XML:
 +
 .XML Configuration
-[source, xml]
+[source,xml]
 ----
 <bean id="connectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
   <property name="brokerURL" value="tcp://localhost:61616"/>
@@ -570,7 +570,7 @@ The following example shows the worker configuration in XML:
     method="handleChunk"/>
 
 <bean id="chunkProcessorChunkHandler"
-    class="org.springframework.batch.integration.chunk.ChunkProcessorChunkHandler">
+    class="org.springframework.batch.integration.chunk.ChunkProcessorChunkRequestHandler">
   <property name="chunkProcessor">
     <bean class="org.springframework.batch.core.step.item.SimpleChunkProcessor">
       <property name="itemWriter">
@@ -593,7 +593,7 @@ manager configuration. Workers do not need access to
 the Spring Batch `JobRepository` nor
 to the actual job configuration file. The main bean of interest
 is the `chunkProcessorChunkHandler`. The
-`chunkProcessor` property of `ChunkProcessorChunkHandler` takes a
+`chunkProcessor` property of `ChunkProcessorChunkRequestHandler` takes a
 configured `SimpleChunkProcessor`, which is where you would provide a reference to your
 `ItemWriter` (and, optionally, your
 `ItemProcessor`) that will run on the worker
@@ -627,12 +627,12 @@ You need not explicitly configure `ChunkMessageChannelItemWriter` and the `Messa
 On the worker side, the `RemoteChunkingWorkerBuilder` lets you configure a worker to:
 
 * Listen to requests sent by the manager on the input channel ("`Incoming requests`")
-* Call the `handleChunk` method of `ChunkProcessorChunkHandler` for each request
+* Call the `handleChunk` method of `ChunkProcessorChunkRequestHandler` for each request
 with the configured `ItemProcessor` and `ItemWriter`
 * Send replies on the output channel ("`Outgoing replies`") to the manager
 
 You need not explicitly configure the `SimpleChunkProcessor`
-and the `ChunkProcessorChunkHandler`. (You can still explicitly configure them if you find
+and the `ChunkProcessorChunkRequestHandler`. (You can still explicitly configure them if you find
    a reason to do so).
 
 The following example shows how to use these APIs:

spring-batch-integration/src/main/java/org/springframework/batch/integration/chunk/ChunkProcessorChunkHandler.java renamed to spring-batch-integration/src/main/java/org/springframework/batch/integration/chunk/ChunkProcessorChunkRequestHandler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2006-2023 the original author or authors.
+ * Copyright 2006-2025 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -33,20 +33,20 @@
 import org.springframework.util.Assert;
 
 /**
- * A {@link ChunkHandler} based on a {@link ChunkProcessor}. Knows how to distinguish
- * between a processor that is fault tolerant, and one that is not. If the processor is
- * fault tolerant then exceptions can be propagated on the assumption that there will be a
- * roll back and the request will be re-delivered.
+ * A {@link ChunkRequestHandler} based on a {@link ChunkProcessor}. Knows how to
+ * distinguish between a processor that is fault tolerant, and one that is not. If the
+ * processor is fault tolerant then exceptions can be propagated on the assumption that
+ * there will be a roll back and the request will be re-delivered.
  *
  * @author Dave Syer
  * @author Michael Minella
  * @author Mahmoud Ben Hassine
  * @param <S> the type of the items in the chunk to be handled
  */
 @MessageEndpoint
-public class ChunkProcessorChunkHandler<S> implements ChunkHandler<S>, InitializingBean {
+public class ChunkProcessorChunkRequestHandler<S> implements ChunkRequestHandler<S>, InitializingBean {
 
-	private static final Log logger = LogFactory.getLog(ChunkProcessorChunkHandler.class);
+	private static final Log logger = LogFactory.getLog(ChunkProcessorChunkRequestHandler.class);
 
 	private ChunkProcessor<S> chunkProcessor;
 
@@ -65,11 +65,11 @@ public void setChunkProcessor(ChunkProcessor<S> chunkProcessor) {
 
 	/**
 	 *
-	 * @see ChunkHandler#handleChunk(ChunkRequest)
+	 * @see ChunkRequestHandler#handle(ChunkRequest)
 	 */
 	@Override
 	@ServiceActivator
-	public ChunkResponse handleChunk(ChunkRequest<S> chunkRequest) throws Exception {
+	public ChunkResponse handle(ChunkRequest<S> chunkRequest) throws Exception {
 
 		if (logger.isDebugEnabled()) {
 			logger.debug("Handling chunk: " + chunkRequest);

spring-batch-integration/src/main/java/org/springframework/batch/integration/chunk/ChunkHandler.java renamed to spring-batch-integration/src/main/java/org/springframework/batch/integration/chunk/ChunkRequestHandler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2006-2007 the original author or authors.
+ * Copyright 2006-2025 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,22 +22,23 @@
  * response needs to be generated containing a summary of the result.
  *
  * @author Dave Syer
+ * @author Mahmoud Ben Hassine
  * @param <T> the type of the items to be processed (it is recommended to use a Memento
  * like a primary key)
  */
-public interface ChunkHandler<T> {
+public interface ChunkRequestHandler<T> {
 
 	/**
-	 * Handle the chunk, processing all the items and returning a response summarising the
-	 * result. If the result is a failure then the response should say so. The handler
-	 * only throws an exception if it needs to roll back a transaction and knows that the
-	 * request will be re-delivered (if not to the same handler then to one processing the
-	 * same Step).
+	 * Handle the chunk request, processing all the items and returning a response
+	 * summarising the result. If the result is a failure then the response should say so.
+	 * The handler only throws an exception if it needs to roll back a transaction and
+	 * knows that the request will be re-delivered (if not to the same handler then to one
+	 * processing the same Step).
 	 * @param chunk a request containing the chunk to process
 	 * @return a response summarising the result
 	 * @throws Exception if the handler needs to roll back a transaction and have the
 	 * chunk re-delivered
 	 */
-	ChunkResponse handleChunk(ChunkRequest<T> chunk) throws Exception;
+	ChunkResponse handle(ChunkRequest<T> chunk) throws Exception;
 
 }

spring-batch-integration/src/main/java/org/springframework/batch/integration/chunk/RemoteChunkHandlerFactoryBean.java

@@ -49,7 +49,7 @@
  * @author Mahmoud Ben Hassine
  *
  */
-public class RemoteChunkHandlerFactoryBean<T> implements FactoryBean<ChunkHandler<T>> {
+public class RemoteChunkHandlerFactoryBean<T> implements FactoryBean<ChunkRequestHandler<T>> {
 
 	private static final Log logger = LogFactory.getLog(RemoteChunkHandlerFactoryBean.class);
 
@@ -87,13 +87,14 @@ public void setStepContributionSource(StepContributionSource stepContributionSou
 	}
 
 	/**
-	 * The type of object created by this factory. Returns {@link ChunkHandler} class.
+	 * The type of object created by this factory. Returns {@link ChunkRequestHandler}
+	 * class.
 	 *
 	 * @see FactoryBean#getObjectType()
 	 */
 	@Override
 	public Class<?> getObjectType() {
-		return ChunkHandler.class;
+		return ChunkRequestHandler.class;
 	}
 
 	/**
@@ -107,14 +108,15 @@ public boolean isSingleton() {
 	}
 
 	/**
-	 * Builds a {@link ChunkHandler} from the {@link ChunkProcessor} extracted from the
-	 * {@link #setStep(TaskletStep) step} provided. Also modifies the step to send chunks
-	 * to the chunk handler via the {@link #setChunkWriter(ItemWriter) chunk writer}.
+	 * Builds a {@link ChunkRequestHandler} from the {@link ChunkProcessor} extracted from
+	 * the {@link #setStep(TaskletStep) step} provided. Also modifies the step to send
+	 * chunks to the chunk handler via the {@link #setChunkWriter(ItemWriter) chunk
+	 * writer}.
 	 *
 	 * @see FactoryBean#getObject()
 	 */
 	@Override
-	public ChunkHandler<T> getObject() throws Exception {
+	public ChunkRequestHandler<T> getObject() throws Exception {
 
 		if (stepContributionSource == null) {
 			Assert.state(chunkWriter instanceof StepContributionSource,
@@ -143,7 +145,7 @@ public ChunkHandler<T> getObject() throws Exception {
 			step.registerStepExecutionListener(stepExecutionListener);
 		}
 
-		ChunkProcessorChunkHandler<T> handler = new ChunkProcessorChunkHandler<>();
+		ChunkProcessorChunkRequestHandler<T> handler = new ChunkProcessorChunkRequestHandler<>();
 		setNonBuffering(chunkProcessor);
 		handler.setChunkProcessor(chunkProcessor);
 		// TODO: create step context for the processor in case it has

spring-batch-integration/src/main/java/org/springframework/batch/integration/chunk/RemoteChunkingWorkerBuilder.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2018-2022 the original author or authors.
+ * Copyright 2018-2025 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,12 +27,13 @@
  * Builder for a worker in a remote chunking setup. This builder:
  *
  * <ul>
- * <li>creates a {@link ChunkProcessorChunkHandler} with the provided item processor and
- * writer. If no item processor is provided, a {@link PassThroughItemProcessor} will be
- * used</li>
- * <li>creates an {@link IntegrationFlow} with the {@link ChunkProcessorChunkHandler} as a
- * service activator which listens to incoming requests on <code>inputChannel</code> and
- * sends replies on <code>outputChannel</code></li>
+ * <li>creates a {@link ChunkProcessorChunkRequestHandler} with the provided item
+ * processor and writer. If no item processor is provided, a
+ * {@link PassThroughItemProcessor} will be used</li>
+ * <li>creates an {@link IntegrationFlow} with the
+ * {@link ChunkProcessorChunkRequestHandler} as a service activator which listens to
+ * incoming requests on <code>inputChannel</code> and sends replies on
+ * <code>outputChannel</code></li>
  * </ul>
  *
  * @param <I> type of input items
@@ -42,7 +43,7 @@
  */
 public class RemoteChunkingWorkerBuilder<I, O> {
 
-	private static final String SERVICE_ACTIVATOR_METHOD_NAME = "handleChunk";
+	private static final String SERVICE_ACTIVATOR_METHOD_NAME = "handle";
 
 	private ItemProcessor<I, O> itemProcessor;
 
@@ -97,7 +98,7 @@ public RemoteChunkingWorkerBuilder<I, O> outputChannel(MessageChannel outputChan
 	}
 
 	/**
-	 * Create an {@link IntegrationFlow} with a {@link ChunkProcessorChunkHandler}
+	 * Create an {@link IntegrationFlow} with a {@link ChunkProcessorChunkRequestHandler}
 	 * configured as a service activator listening to the input channel and replying on
 	 * the output channel.
 	 * @return the integration flow
@@ -113,11 +114,11 @@ public IntegrationFlow build() {
 		}
 		SimpleChunkProcessor<I, O> chunkProcessor = new SimpleChunkProcessor<>(this.itemProcessor, this.itemWriter);
 
-		ChunkProcessorChunkHandler<I> chunkProcessorChunkHandler = new ChunkProcessorChunkHandler<>();
-		chunkProcessorChunkHandler.setChunkProcessor(chunkProcessor);
+		ChunkProcessorChunkRequestHandler<I> chunkProcessorChunkRequestHandler = new ChunkProcessorChunkRequestHandler<>();
+		chunkProcessorChunkRequestHandler.setChunkProcessor(chunkProcessor);
 
 		return IntegrationFlow.from(this.inputChannel)
-			.handle(chunkProcessorChunkHandler, SERVICE_ACTIVATOR_METHOD_NAME)
+			.handle(chunkProcessorChunkRequestHandler, SERVICE_ACTIVATOR_METHOD_NAME)
 			.channel(this.outputChannel)
 			.get();
 	}

spring-batch-integration/src/main/java/org/springframework/batch/integration/config/xml/RemoteChunkingWorkerParser.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2014-2023 the original author or authors.
+ * Copyright 2014-2025 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,7 +18,7 @@
 import org.w3c.dom.Element;
 
 import org.springframework.batch.core.step.item.SimpleChunkProcessor;
-import org.springframework.batch.integration.chunk.ChunkProcessorChunkHandler;
+import org.springframework.batch.integration.chunk.ChunkProcessorChunkRequestHandler;
 import org.springframework.batch.item.support.PassThroughItemProcessor;
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.config.RuntimeBeanReference;
@@ -60,7 +60,7 @@ public class RemoteChunkingWorkerParser extends AbstractBeanDefinitionParser {
 
 	private static final String CHUNK_PROCESSOR_PROPERTY_NAME = "chunkProcessor";
 
-	private static final String CHUNK_PROCESSOR_CHUNK_HANDLER_BEAN_NAME_PREFIX = "chunkProcessorChunkHandler_";
+	private static final String CHUNK_PROCESSOR_CHUNK_HANDLER_BEAN_NAME_PREFIX = "chunkProcessorChunkRequestHandler_";
 
 	@Override
 	protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
@@ -92,7 +92,7 @@ protected AbstractBeanDefinition parseInternal(Element element, ParserContext pa
 		}
 
 		BeanDefinition chunkProcessorChunkHandler = BeanDefinitionBuilder
-			.genericBeanDefinition(ChunkProcessorChunkHandler.class)
+			.genericBeanDefinition(ChunkProcessorChunkRequestHandler.class)
 			.addPropertyValue(CHUNK_PROCESSOR_PROPERTY_NAME, chunkProcessorBuilder.getBeanDefinition())
 			.getBeanDefinition();
 
@@ -110,9 +110,9 @@ private static class ServiceActivatorParser extends AbstractConsumerEndpointPars
 
 		private static final String TARGET_OBJECT_PROPERTY_NAME = "targetObject";
 
-		private static final String HANDLE_CHUNK_METHOD_NAME = "handleChunk";
+		private static final String HANDLE_CHUNK_METHOD_NAME = "handle";
 
-		private static final String CHUNK_PROCESSOR_CHUNK_HANDLER_BEAN_NAME_PREFIX = "chunkProcessorChunkHandler_";
+		private static final String CHUNK_PROCESSOR_CHUNK_HANDLER_BEAN_NAME_PREFIX = "chunkProcessorChunkRequestHandler_";
 
 		private final String id;
 

spring-batch-integration/src/test/java/org/springframework/batch/integration/chunk/ChunkProcessorChunkHandlerTests.java renamed to spring-batch-integration/src/test/java/org/springframework/batch/integration/chunk/ChunkProcessorChunkRequestHandlerTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2008-2023 the original author or authors.
+ * Copyright 2008-2025 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -24,9 +24,9 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
-class ChunkProcessorChunkHandlerTests {
+class ChunkProcessorChunkRequestHandlerTests {
 
-	private final ChunkProcessorChunkHandler<Object> handler = new ChunkProcessorChunkHandler<>();
+	private final ChunkProcessorChunkRequestHandler<Object> handler = new ChunkProcessorChunkRequestHandler<>();
 
 	protected int count = 0;
 
@@ -39,7 +39,7 @@ void testVanillaHandleChunk() throws Exception {
 		ChunkRequest chunkRequest = new ChunkRequest<>(0, items, 12L, stepContribution);
 
 		// when
-		ChunkResponse response = handler.handleChunk(chunkRequest);
+		ChunkResponse response = handler.handle(chunkRequest);
 
 		// then
 		assertEquals(stepContribution, response.getStepContribution());

spring-batch-integration/src/test/java/org/springframework/batch/integration/config/xml/RemoteChunkingParserTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2014-2022 the original author or authors.
+ * Copyright 2014-2025 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,9 +19,9 @@
 
 import org.springframework.batch.core.step.item.ChunkProcessor;
 import org.springframework.batch.core.step.item.SimpleChunkProcessor;
-import org.springframework.batch.integration.chunk.ChunkHandler;
+import org.springframework.batch.integration.chunk.ChunkRequestHandler;
 import org.springframework.batch.integration.chunk.ChunkMessageChannelItemWriter;
-import org.springframework.batch.integration.chunk.ChunkProcessorChunkHandler;
+import org.springframework.batch.integration.chunk.ChunkProcessorChunkRequestHandler;
 import org.springframework.batch.integration.chunk.RemoteChunkHandlerFactoryBean;
 import org.springframework.batch.item.Chunk;
 import org.springframework.batch.item.ItemProcessor;
@@ -60,8 +60,8 @@ void testRemoteChunkingWorkerParserWithProcessorDefined() {
 		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
 				"/org/springframework/batch/integration/config/xml/RemoteChunkingWorkerParserTests.xml");
 
-		ChunkHandler chunkHandler = applicationContext.getBean(ChunkProcessorChunkHandler.class);
-		ChunkProcessor chunkProcessor = (SimpleChunkProcessor) TestUtils.getPropertyValue(chunkHandler,
+		ChunkRequestHandler chunkRequestHandler = applicationContext.getBean(ChunkProcessorChunkRequestHandler.class);
+		ChunkProcessor chunkProcessor = (SimpleChunkProcessor) TestUtils.getPropertyValue(chunkRequestHandler,
 				"chunkProcessor");
 		assertNotNull(chunkProcessor, "ChunkProcessor must not be null");
 
@@ -84,10 +84,9 @@ void testRemoteChunkingWorkerParserWithProcessorDefined() {
 
 		String targetMethodName = (String) TestUtils.getPropertyValue(serviceActivatorFactoryBean, "targetMethodName");
 		assertNotNull(targetMethodName, "Target method name must not be null");
-		assertEquals("handleChunk", targetMethodName,
-				"Target method name must be handleChunk, got: " + targetMethodName);
+		assertEquals("handle", targetMethodName, "Target method name must be handle, got: " + targetMethodName);
 
-		ChunkHandler targetObject = (ChunkHandler) TestUtils.getPropertyValue(serviceActivatorFactoryBean,
+		ChunkRequestHandler targetObject = (ChunkRequestHandler) TestUtils.getPropertyValue(serviceActivatorFactoryBean,
 				"targetObject");
 		assertNotNull(targetObject, "Target object must not be null");
 	}
@@ -98,8 +97,8 @@ void testRemoteChunkingWorkerParserWithProcessorNotDefined() {
 		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
 				"/org/springframework/batch/integration/config/xml/RemoteChunkingWorkerParserNoProcessorTests.xml");
 
-		ChunkHandler chunkHandler = applicationContext.getBean(ChunkProcessorChunkHandler.class);
-		ChunkProcessor chunkProcessor = (SimpleChunkProcessor) TestUtils.getPropertyValue(chunkHandler,
+		ChunkRequestHandler chunkRequestHandler = applicationContext.getBean(ChunkProcessorChunkRequestHandler.class);
+		ChunkProcessor chunkProcessor = (SimpleChunkProcessor) TestUtils.getPropertyValue(chunkRequestHandler,
 				"chunkProcessor");
 		assertNotNull(chunkProcessor, "ChunkProcessor must not be null");
 
@@ -120,7 +119,7 @@ void testRemoteChunkingManagerParser() {
 				"Messaging template must not be null");
 		assertNotNull(TestUtils.getPropertyValue(itemWriter, "replyChannel"), "Reply channel must not be null");
 
-		FactoryBean<ChunkHandler> remoteChunkingHandlerFactoryBean = applicationContext
+		FactoryBean<ChunkRequestHandler> remoteChunkingHandlerFactoryBean = applicationContext
 			.getBean(RemoteChunkHandlerFactoryBean.class);
 		assertNotNull(TestUtils.getPropertyValue(remoteChunkingHandlerFactoryBean, "chunkWriter"),
 				"Chunk writer must not be null");