GH-3001: Add consume batch support to RabbitAmqpListenerContainer

Fixes: #3001

* Expose batch related options for `RabbitAmqpListenerContainer` and `RabbitAmqpListenerContainerFactory`, respectively
* `batchSize` - the indicator that `RabbitAmqpListenerContainer` (and `RabbitAmqpMessageListenerAdapter`) has to work in batch mode
* `batchReceiveTimeout` - how long to wait for batch to be fulfilled or release whatever was gathered so far, even if just only one message
* `taskScheduler` - schedule "force batch release" after `batchReceiveTimeout`
* Make `MessagingMessageListenerAdapter` `final` properties as `protected` to avoid undesired copy-paste burden

Author: artembilan

spring-rabbit/src/main/java/org/springframework/amqp/rabbit/listener/adapter/BatchMessagingMessageListenerAdapter.java

@@ -49,23 +49,20 @@
 public class BatchMessagingMessageListenerAdapter extends MessagingMessageListenerAdapter
 		implements ChannelAwareBatchMessageListener {
 
-	private final MessagingMessageConverterAdapter converterAdapter;
-
 	private final BatchingStrategy batchingStrategy;
 
 	@SuppressWarnings("this-escape")
 	public BatchMessagingMessageListenerAdapter(@Nullable Object bean, @Nullable Method method, boolean returnExceptions,
 			@Nullable RabbitListenerErrorHandler errorHandler, @Nullable BatchingStrategy batchingStrategy) {
 
 		super(bean, method, returnExceptions, errorHandler, true);
-		this.converterAdapter = (MessagingMessageConverterAdapter) getMessagingMessageConverter();
 		this.batchingStrategy = batchingStrategy == null ? new SimpleBatchingStrategy(0, 0, 0L) : batchingStrategy;
 	}
 
 	@Override
 	public void onMessageBatch(List<org.springframework.amqp.core.Message> messages, @Nullable Channel channel) {
 		Message<?> converted;
-		if (this.converterAdapter.isAmqpMessageList()) {
+		if (this.messagingMessageConverter.isAmqpMessageList()) {
 			converted = new GenericMessage<>(messages);
 		}
 		else {
@@ -87,7 +84,7 @@ public void onMessageBatch(List<org.springframework.amqp.core.Message> messages,
 					}
 				}
 			}
-			if (this.converterAdapter.isMessageList()) {
+			if (this.messagingMessageConverter.isMessageList()) {
 				converted = new GenericMessage<>(messagingMessages);
 			}
 			else {
@@ -178,17 +175,17 @@ private void asyncFailure(List<org.springframework.amqp.core.Message> requests,
 	protected Message<?> toMessagingMessage(org.springframework.amqp.core.Message amqpMessage) {
 		if (this.batchingStrategy.canDebatch(amqpMessage.getMessageProperties())) {
 
-			if (this.converterAdapter.isMessageList()) {
+			if (this.messagingMessageConverter.isMessageList()) {
 				List<Message<?>> messages = new ArrayList<>();
 				this.batchingStrategy.deBatch(amqpMessage, fragment -> messages.add(super.toMessagingMessage(fragment)));
 				return new GenericMessage<>(messages);
 			}
 			else {
 				List<Object> list = new ArrayList<>();
 				this.batchingStrategy.deBatch(amqpMessage, fragment ->
-						list.add(this.converterAdapter.extractPayload(fragment)));
+						list.add(this.messagingMessageConverter.extractPayload(fragment)));
 				return MessageBuilder.withPayload(list)
-						.copyHeaders(this.converterAdapter
+						.copyHeaders(this.messagingMessageConverter
 								.getHeaderMapper()
 								.toHeaders(amqpMessage.getMessageProperties()))
 						.build();

spring-rabbit/src/main/java/org/springframework/amqp/rabbit/listener/adapter/MessagingMessageListenerAdapter.java

@@ -69,11 +69,11 @@
  */
 public class MessagingMessageListenerAdapter extends AbstractAdaptableMessageListener {
 
-	private final MessagingMessageConverterAdapter messagingMessageConverter;
+	protected final MessagingMessageConverterAdapter messagingMessageConverter;
 
-	private final boolean returnExceptions;
+	protected final boolean returnExceptions;
 
-	private final @Nullable RabbitListenerErrorHandler errorHandler;
+	protected final @Nullable RabbitListenerErrorHandler errorHandler;
 
 	private @Nullable HandlerAdapter handlerAdapter;
 
@@ -364,15 +364,15 @@ protected final class MessagingMessageConverterAdapter extends MessagingMessageC
 			}
 		}
 
-		protected boolean isMessageList() {
+		public boolean isMessageList() {
 			return this.isMessageList;
 		}
 
-		protected boolean isAmqpMessageList() {
+		public boolean isAmqpMessageList() {
 			return this.isAmqpMessageList;
 		}
 
-		protected @Nullable Method getMethod() {
+		public @Nullable Method getMethod() {
 			return this.method;
 		}
 

spring-rabbitmq-client/src/main/java/org/springframework/amqp/rabbitmq/client/config/RabbitAmqpListenerContainerFactory.java

@@ -16,17 +16,21 @@
 
 package org.springframework.amqp.rabbitmq.client.config;
 
+import java.util.Arrays;
+
 import com.rabbitmq.client.amqp.Connection;
-import org.aopalliance.aop.Advice;
 import org.jspecify.annotations.Nullable;
 
+import org.springframework.amqp.core.MessageListener;
+import org.springframework.amqp.core.MessagePostProcessor;
 import org.springframework.amqp.rabbit.config.BaseRabbitListenerContainerFactory;
 import org.springframework.amqp.rabbit.config.ContainerCustomizer;
 import org.springframework.amqp.rabbit.listener.MethodRabbitListenerEndpoint;
 import org.springframework.amqp.rabbit.listener.RabbitListenerEndpoint;
 import org.springframework.amqp.rabbitmq.client.listener.RabbitAmqpListenerContainer;
 import org.springframework.amqp.rabbitmq.client.listener.RabbitAmqpMessageListenerAdapter;
 import org.springframework.amqp.utils.JavaUtils;
+import org.springframework.scheduling.TaskScheduler;
 
 /**
  * Factory for {@link RabbitAmqpListenerContainer}.
@@ -45,6 +49,14 @@ public class RabbitAmqpListenerContainerFactory
 
 	private @Nullable ContainerCustomizer<RabbitAmqpListenerContainer> containerCustomizer;
 
+	private MessagePostProcessor @Nullable [] afterReceivePostProcessors;
+
+	private @Nullable Integer batchSize;
+
+	private @Nullable Long batchReceiveTimeout;
+
+	private @Nullable TaskScheduler taskScheduler;
+
 	/**
 	 * Construct an instance using the provided amqpConnection.
 	 * @param amqpConnection the connection.
@@ -62,18 +74,69 @@ public void setContainerCustomizer(ContainerCustomizer<RabbitAmqpListenerContain
 		this.containerCustomizer = containerCustomizer;
 	}
 
+	/**
+	 * Set {@link MessagePostProcessor}s that will be applied after message reception, before
+	 * invoking the {@link MessageListener}. Often used to decompress data.  Processors are invoked in order,
+	 * depending on {@code PriorityOrder}, {@code Order} and finally unordered.
+	 * @param afterReceivePostProcessors the post processor.
+	 */
+	public void setAfterReceivePostProcessors(MessagePostProcessor... afterReceivePostProcessors) {
+		this.afterReceivePostProcessors = Arrays.copyOf(afterReceivePostProcessors, afterReceivePostProcessors.length);
+	}
+
+	/**
+	 * The size of the batch of messages to process.
+	 * This is only option (if {@code batchSize > 1}) which turns the target listener container into a batch mode.
+	 * @param batchSize the batch size.
+	 * @see RabbitAmqpListenerContainer#setBatchSize
+	 * @see #setBatchReceiveTimeout(Long)
+	 */
+	public void setBatchSize(Integer batchSize) {
+		this.batchSize = batchSize;
+	}
+
+	/**
+	 * The number of milliseconds of timeout for gathering batch messages.
+	 * It limits the time to wait to fill batchSize.
+	 * Default is 30 seconds.
+	 * @param batchReceiveTimeout the timeout for gathering batch messages.
+	 * @see RabbitAmqpListenerContainer#setBatchReceiveTimeout
+	 * @see #setBatchSize(Integer)
+	 */
+	public void setBatchReceiveTimeout(Long batchReceiveTimeout) {
+		this.batchReceiveTimeout = batchReceiveTimeout;
+	}
+
+	/**
+	 * Configure a {@link TaskScheduler} to release not fulfilled batches after timeout.
+	 * @param taskScheduler the {@link TaskScheduler} to use.
+	 * @see RabbitAmqpListenerContainer#setTaskScheduler(TaskScheduler)
+	 * @see #setBatchReceiveTimeout(Long)
+	 */
+	public void setTaskScheduler(TaskScheduler taskScheduler) {
+		this.taskScheduler = taskScheduler;
+	}
+
 	@Override
 	public RabbitAmqpListenerContainer createListenerContainer(@Nullable RabbitListenerEndpoint endpoint) {
 		if (endpoint instanceof MethodRabbitListenerEndpoint methodRabbitListenerEndpoint) {
+			JavaUtils.INSTANCE
+					.acceptIfCondition(this.batchSize != null && this.batchSize > 1,
+							true,
+							methodRabbitListenerEndpoint::setBatchListener);
+
 			methodRabbitListenerEndpoint.setAdapterProvider(
 					(batch, bean, method, returnExceptions, errorHandler, batchingStrategy) ->
-							new RabbitAmqpMessageListenerAdapter(bean, method, returnExceptions, errorHandler));
+							new RabbitAmqpMessageListenerAdapter(bean, method, returnExceptions, errorHandler, batch));
 		}
 		RabbitAmqpListenerContainer container = createContainerInstance();
-		Advice[] adviceChain = getAdviceChain();
 		JavaUtils.INSTANCE
-				.acceptIfNotNull(adviceChain, container::setAdviceChain)
-				.acceptIfNotNull(getDefaultRequeueRejected(), container::setDefaultRequeue);
+				.acceptIfNotNull(getAdviceChain(), container::setAdviceChain)
+				.acceptIfNotNull(getDefaultRequeueRejected(), container::setDefaultRequeue)
+				.acceptIfNotNull(this.afterReceivePostProcessors, container::setAfterReceivePostProcessors)
+				.acceptIfNotNull(this.batchSize, container::setBatchSize)
+				.acceptIfNotNull(this.batchReceiveTimeout, container::setBatchReceiveTimeout)
+				.acceptIfNotNull(this.taskScheduler, container::setTaskScheduler);
 
 		applyCommonOverrides(endpoint, container);