Replace Spring Retry usage to core retry

This commit replaces Spring Retry by the core retry support introduced
in Spring Framework 7. This is a breaking change mostly in configuration
that is detailed below.

Some of the features used from Spring Retry have no equivalent in Spring
Framework, and a tailored solution for Spring AMQP has been implemented
in this commit. This leads to the change in the following hook points:

* `AbstractAdaptableMessageListener` can be configured by the newly
introduced `MessageRecoveryCallback` instead of Spring Retry's
`MethodInvocationRecoverer`. The new callback directly provides the
Message, replyTo Address, and Exception.
* The `RecoveryCallback` in `RabbitTemplate` is replaced by an interface
with the same name.
* `AbstractRetryOperationsInterceptorFactoryBean` should be configured
with a `RetryPolicy`, rather than a `RetryTemplate`.

Spring AMQP uses stateless and stateful retry interceptors from Spring
Retry. These are replaced by:

* `StatelessRetryOperationsInterceptor` that invokes recovery if
provided.
* `StatefulRetryOperationsInterceptor` provides a similar interceptor
as the Spring Retry equivalent, except that it is configured with
Spring AMQP-specify callbacks.

These interceptors are configured with a `RetryPolicy`, rather than
a `RetryTemplate`. The new `RetryTemplate` in Spring Framework is
operating on a `RetryPolicy` can can't be further configured. This
has an impact on `RetryInterceptorBuilder` where a custom `BackOff`
can no longer be specified. Instead, a consumer of the
`RetryPolicy.Builder` is provided that offers configuration for it and
more.

Using dedicated callbacks also shows inconsistencies with the
Null-safety support. The most annoying example is MessageKeyGenerator
that should be nullable despite its contract stating that it should not.
Spring AMQP has actually a code path to deal with stateful retries when
the key is null.

A major difference in default is that Spring Retry has a default
policy of 3 attempts: the initial invocation and 2 retries. Spring
Framework has a default RetryPolicy of 3 attempts, that does not
include the initial invocation. With 4 attempts in total, there is an
off-by-one change in `AmqpAppender` and tests to configure a retry
policy with 2 attempts.

With Spring Retry being completely removed, this commit also removes
the dependency and any further references to it.

Signed-off-by: Stéphane Nicoll <[email protected]>

Author: snicoll

build.gradle

@@ -55,7 +55,6 @@ ext {
 	rabbitmqVersion = '5.26.0'
 	reactorVersion = '2025.0.0-M6'
 	springDataVersion = '2025.1.0-SNAPSHOT'
-	springRetryVersion = '2.0.12'
 	springVersion = '7.0.0-SNAPSHOT'
 	testcontainersVersion = '1.21.3'
 
@@ -365,7 +364,6 @@ project('spring-rabbit') {
 		api 'org.springframework:spring-messaging'
 		api 'org.springframework:spring-tx'
 		api 'io.micrometer:micrometer-observation'
-		api "org.springframework.retry:spring-retry:$springRetryVersion"
 
 		optionalApi 'org.springframework:spring-aop'
 		optionalApi 'org.springframework:spring-webflux'
@@ -708,10 +706,9 @@ def generateAttributes() {
 		'project-version': project.version,
 		'spring-integration-docs': "$springDocs/spring-integration/reference".toString(),
 		'spring-framework-docs': "$springDocs/spring-framework/reference/${generateVersionWithoutPatch(springVersion)}".toString(),
-		'spring-retry-java-docs': "$springDocs/spring-retry/docs/$springRetryVersion/apidocs".toString(),
+		'spring-framework-javadoc': "$springDocs/spring-framework/docs/$springVersion/javadoc-api".toString(),
 		'javadoc-location-org-springframework-transaction': "$springDocs/spring-framework/docs/$springVersion/javadoc-api".toString(),
 		'javadoc-location-org-springframework-amqp': "$springDocs/spring-amqp/docs/$project.version/api".toString(),
-		'javadoc-location-org-springframework-retry': "{spring-retry-java-docs}",
 		'micrometer-docs': "$micrometerDocsPrefix/micrometer/reference/${generateVersionWithoutPatch(micrometerVersion)}".toString(),
 		'micrometer-tracing-docs': "$micrometerDocsPrefix/tracing/reference/${generateVersionWithoutPatch(micrometerTracingVersion)}".toString()
 	]

spring-rabbit-stream/src/main/java/org/springframework/rabbit/stream/retry/StreamRetryOperationsInterceptorFactoryBean.java

@@ -18,49 +18,49 @@
 
 import com.rabbitmq.stream.Message;
 import com.rabbitmq.stream.MessageHandler.Context;
+import org.jspecify.annotations.Nullable;
 
 import org.springframework.amqp.rabbit.config.StatelessRetryOperationsInterceptorFactoryBean;
 import org.springframework.amqp.rabbit.retry.MessageRecoverer;
+import org.springframework.core.retry.RetryOperations;
 import org.springframework.rabbit.stream.listener.StreamListenerContainer;
-import org.springframework.retry.RetryOperations;
-import org.springframework.retry.interceptor.MethodInvocationRecoverer;
-import org.springframework.retry.support.RetryTemplate;
+import org.springframework.util.Assert;
 
 /**
  * Convenient factory bean for creating a stateless retry interceptor for use in a
  * {@link StreamListenerContainer} when consuming native stream messages, giving you a
  * large amount of control over the behavior of a container when a listener fails. To
  * control the number of retry attempt or the backoff in between attempts, supply a
- * customized {@link RetryTemplate}. Stateless retry is appropriate if your listener can
+ * customized {@link RetryOperations}. Stateless retry is appropriate if your listener can
  * be called repeatedly between failures with no side effects. The semantics of stateless
  * retry mean that a listener exception is not propagated to the container until the retry
  * attempts are exhausted. When the retry attempts are exhausted it can be processed using
  * a {@link StreamMessageRecoverer} if one is provided.
  *
  * @author Gary Russell
- *
- * @see RetryOperations#execute(org.springframework.retry.RetryCallback,org.springframework.retry.RecoveryCallback)
  */
 public class StreamRetryOperationsInterceptorFactoryBean extends StatelessRetryOperationsInterceptorFactoryBean {
 
 	@Override
-	protected MethodInvocationRecoverer<?> createRecoverer() {
-		return (args, cause) -> {
-			StreamMessageRecoverer messageRecoverer = (StreamMessageRecoverer) getMessageRecoverer();
-			Object arg = args[0];
-			if (arg instanceof org.springframework.amqp.core.Message) {
-				return super.recover(args, cause);
+	protected @Nullable Object recover(@Nullable Object[] args, Throwable cause) {
+		StreamMessageRecoverer messageRecoverer = (StreamMessageRecoverer) getMessageRecoverer();
+		Object arg = args[0];
+		if (arg instanceof org.springframework.amqp.core.Message) {
+			return super.recover(args, cause);
+		}
+		else {
+			if (messageRecoverer == null) {
+				this.logger.warn("Message(s) dropped on recovery: " + arg, cause);
 			}
 			else {
-				if (messageRecoverer == null) {
-					this.logger.warn("Message(s) dropped on recovery: " + arg, cause);
-				}
-				else {
-					messageRecoverer.recover((Message) arg, (Context) args[1], cause);
-				}
-				return null;
+				Message message = (Message) arg;
+				Context context = (Context) args[1];
+				Assert.notNull(message, "Message must not be null");
+				Assert.notNull(context, "Context must not be null");
+				messageRecoverer.recover(message, context, cause);
 			}
-		};
+			return null;
+		}
 	}
 
 	/**

spring-rabbit-stream/src/test/java/org/springframework/rabbit/stream/listener/RabbitListenerTests.java

@@ -45,6 +45,7 @@
 import org.springframework.amqp.rabbit.annotation.EnableRabbit;
 import org.springframework.amqp.rabbit.annotation.RabbitListener;
 import org.springframework.amqp.rabbit.config.RetryInterceptorBuilder;
+import org.springframework.amqp.rabbit.config.StatelessRetryOperationsInterceptor;
 import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
 import org.springframework.amqp.rabbit.core.RabbitAdmin;
 import org.springframework.amqp.rabbit.core.RabbitTemplate;
@@ -62,7 +63,6 @@
 import org.springframework.rabbit.stream.retry.StreamRetryOperationsInterceptorFactoryBean;
 import org.springframework.rabbit.stream.support.StreamAdmin;
 import org.springframework.rabbit.stream.support.StreamMessageProperties;
-import org.springframework.retry.interceptor.RetryOperationsInterceptor;
 import org.springframework.test.annotation.DirtiesContext;
 import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
 import org.springframework.web.reactive.function.client.ExchangeFilterFunctions;
@@ -306,7 +306,7 @@ public StreamRetryOperationsInterceptorFactoryBean sfb() {
 		@Bean
 		@DependsOn("sfb")
 		RabbitListenerContainerFactory<StreamListenerContainer> nativeFactory(Environment env,
-				RetryOperationsInterceptor retry) {
+				StatelessRetryOperationsInterceptor retry) {
 
 			StreamRabbitListenerContainerFactory factory = new StreamRabbitListenerContainerFactory(env);
 			factory.setNativeListener(true);
@@ -323,8 +323,7 @@ RabbitListenerContainerFactory<StreamListenerContainer> nativeFactory(Environmen
 		}
 
 		@Bean
-		RabbitListenerContainerFactory<StreamListenerContainer> nativeObsFactory(Environment env,
-				RetryOperationsInterceptor retry) {
+		RabbitListenerContainerFactory<StreamListenerContainer> nativeObsFactory(Environment env) {
 
 			StreamRabbitListenerContainerFactory factory = new StreamRabbitListenerContainerFactory(env);
 			factory.setNativeListener(true);

spring-rabbit/src/main/java/org/springframework/amqp/rabbit/config/AbstractRetryOperationsInterceptorFactoryBean.java

@@ -21,7 +21,7 @@
 
 import org.springframework.amqp.rabbit.retry.MessageRecoverer;
 import org.springframework.beans.factory.FactoryBean;
-import org.springframework.retry.RetryOperations;
+import org.springframework.core.retry.RetryPolicy;
 
 /**
  * Convenient base class for interceptor factories.
@@ -33,18 +33,18 @@ public abstract class AbstractRetryOperationsInterceptorFactoryBean implements F
 
 	private @Nullable MessageRecoverer messageRecoverer;
 
-	private @Nullable RetryOperations retryTemplate;
+	private @Nullable RetryPolicy retryPolicy;
 
-	public void setRetryOperations(RetryOperations retryTemplate) {
-		this.retryTemplate = retryTemplate;
+	public void setRetryPolicy(RetryPolicy retryPolicy) {
+		this.retryPolicy = retryPolicy;
 	}
 
 	public void setMessageRecoverer(MessageRecoverer messageRecoverer) {
 		this.messageRecoverer = messageRecoverer;
 	}
 
-	protected @Nullable RetryOperations getRetryOperations() {
-		return this.retryTemplate;
+	protected @Nullable RetryPolicy getRetryPolicy() {
+		return this.retryPolicy;
 	}
 
 	protected @Nullable MessageRecoverer getMessageRecoverer() {

spring-rabbit/src/main/java/org/springframework/amqp/rabbit/config/BaseRabbitListenerContainerFactory.java

@@ -29,12 +29,12 @@
 import org.springframework.amqp.rabbit.listener.RabbitListenerEndpoint;
 import org.springframework.amqp.rabbit.listener.adapter.AbstractAdaptableMessageListener;
 import org.springframework.amqp.rabbit.listener.adapter.ReplyPostProcessor;
+import org.springframework.amqp.rabbit.retry.MessageRecoveryCallback;
 import org.springframework.amqp.utils.JavaUtils;
 import org.springframework.beans.BeansException;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
-import org.springframework.retry.RecoveryCallback;
-import org.springframework.retry.support.RetryTemplate;
+import org.springframework.core.retry.RetryTemplate;
 import org.springframework.util.Assert;
 
 /**
@@ -58,7 +58,7 @@ public abstract class BaseRabbitListenerContainerFactory<C extends MessageListen
 
 	private @Nullable RetryTemplate retryTemplate;
 
-	private @Nullable RecoveryCallback<?> recoveryCallback;
+	private @Nullable MessageRecoveryCallback recoveryCallback;
 
 	private Advice @Nullable [] adviceChain;
 
@@ -108,22 +108,22 @@ public void setBeforeSendReplyPostProcessors(MessagePostProcessor... postProcess
 	 * Set a {@link RetryTemplate} to use when sending replies; added to each message
 	 * listener adapter.
 	 * @param retryTemplate the template.
-	 * @see #setReplyRecoveryCallback(RecoveryCallback)
+	 * @see #setReplyRecoveryCallback(MessageRecoveryCallback)
 	 * @see AbstractAdaptableMessageListener#setRetryTemplate(RetryTemplate)
 	 */
 	public void setRetryTemplate(RetryTemplate retryTemplate) {
 		this.retryTemplate = retryTemplate;
 	}
 
 	/**
-	 * Set a {@link RecoveryCallback} to invoke when retries are exhausted. Added to each
-	 * message listener adapter. Only used if a {@link #setRetryTemplate(RetryTemplate)
+	 * Set a {@link MessageRecoveryCallback} to invoke when retries are exhausted. Added to
+	 * each message listener adapter. Only used if a {@link #setRetryTemplate(RetryTemplate)
 	 * retryTemplate} is provided.
 	 * @param recoveryCallback the recovery callback.
 	 * @see #setRetryTemplate(RetryTemplate)
-	 * @see AbstractAdaptableMessageListener#setRecoveryCallback(RecoveryCallback)
+	 * @see AbstractAdaptableMessageListener#setRecoveryCallback(MessageRecoveryCallback)
 	 */
-	public void setReplyRecoveryCallback(RecoveryCallback<?> recoveryCallback) {
+	public void setReplyRecoveryCallback(MessageRecoveryCallback recoveryCallback) {
 		this.recoveryCallback = recoveryCallback;
 	}