Introduce SpringRetryTemplateAdapter

Since Spring Retry is sunsetting, we should consider migration to Core Retry from Spring Framework.
To support existing applications and smooth a little bit a migration from Spring Retry,
the `SpringRetryTemplateAdapter` is introduced.
This class is an extension of the `org.springframework.core.retry.RetryTemplate`,
accepts fully configured `org.springframework.retry.support.RetryTemplate`,
and optional `RecoveryCallback`.
The `super` is initialized with "no retry" policy since all the retry logic is performed
by the provided `org.springframework.retry.support.RetryTemplate`
The `RabbitAdmin` was modified to demonstrate `SpringRetryTemplateAdapter`.
The `RabbitAdminTests.testRetry()` is marked with `@SuppressWarnings("removal")`
to prove that `SpringRetryTemplateAdapter` performs delegation properly.

Author: artembilan

spring-rabbit/src/main/java/org/springframework/amqp/rabbit/core/RabbitAdmin.java

@@ -17,6 +17,7 @@
 package org.springframework.amqp.rabbit.core;
 
 import java.io.IOException;
+import java.time.Duration;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -54,20 +55,22 @@
 import org.springframework.amqp.rabbit.connection.CachingConnectionFactory.CacheMode;
 import org.springframework.amqp.rabbit.connection.ChannelProxy;
 import org.springframework.amqp.rabbit.connection.ConnectionFactory;
+import org.springframework.amqp.rabbit.retry.SpringRetryTemplateAdapter;
 import org.springframework.beans.factory.BeanNameAware;
 import org.springframework.beans.factory.InitializingBean;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.context.ApplicationEventPublisherAware;
+import org.springframework.core.retry.RetryException;
+import org.springframework.core.retry.RetryPolicy;
+import org.springframework.core.retry.RetryTemplate;
 import org.springframework.core.task.SimpleAsyncTaskExecutor;
 import org.springframework.core.task.TaskExecutor;
 import org.springframework.jmx.export.annotation.ManagedOperation;
 import org.springframework.jmx.export.annotation.ManagedResource;
-import org.springframework.retry.backoff.ExponentialBackOffPolicy;
-import org.springframework.retry.policy.SimpleRetryPolicy;
-import org.springframework.retry.support.RetryTemplate;
 import org.springframework.util.Assert;
+import org.springframework.util.ReflectionUtils;
 import org.springframework.util.StringUtils;
 
 /**
@@ -90,9 +93,9 @@ public class RabbitAdmin implements AmqpAdmin, ApplicationContextAware, Applicat
 
 	private static final int DECLARE_MAX_ATTEMPTS = 5;
 
-	private static final int DECLARE_INITIAL_RETRY_INTERVAL = 1000;
+	private static final Duration DECLARE_INITIAL_RETRY_DELAY = Duration.ofSeconds(1);
 
-	private static final int DECLARE_MAX_RETRY_INTERVAL = 5000;
+	private static final Duration DECLARE_MAX_RETRY_DELAY = Duration.ofSeconds(5);
 
 	private static final double DECLARE_RETRY_MULTIPLIER = 2.0;
 
@@ -547,9 +550,34 @@ public void setRedeclareManualDeclarations(boolean redeclareManualDeclarations)
 	 * of 5 seconds. To disable retry, set the argument to {@code null}. Note that this
 	 * retry is at the macro level - all declarations will be retried within the scope of
 	 * this template. If you supplied a {@link RabbitTemplate} that is configured with a
-	 * {@link RetryTemplate}, its template will retry each individual declaration.
+	 * {@link org.springframework.retry.support.RetryTemplate},
+	 * its template will retry each individual declaration.
 	 * @param retryTemplate the retry template.
 	 * @since 1.7.8
+	 * @deprecated since 4.0 in favor of
+	 */
+	@Deprecated(since = "4.0", forRemoval = true)
+	public void setRetryTemplate(org.springframework.retry.support.@Nullable RetryTemplate retryTemplate) {
+		if (retryTemplate != null) {
+			setRetryTemplate(new SpringRetryTemplateAdapter(retryTemplate));
+		}
+		else {
+			this.retryDisabled = true;
+		}
+	}
+
+	/**
+	 * Set a retry template for auto declarations. There is a race condition with
+	 * auto-delete, exclusive queues in that the queue might still exist for a short time,
+	 * preventing the redeclaration. The default retry configuration will try 5 times with
+	 * an exponential backOff starting at 1 second a multiplier of 2.0 and a max interval
+	 * of 5 seconds. To disable retry, set the argument to {@code null}. Note that this
+	 * retry is at the macro level - all declarations will be retried within the scope of
+	 * this template. If you supplied a {@link RabbitTemplate} that is configured with a
+	 * {@link RetryTemplate},
+	 * its template will retry each individual declaration.
+	 * @param retryTemplate the retry template.
+	 * @since 4.0
 	 */
 	public void setRetryTemplate(@Nullable RetryTemplate retryTemplate) {
 		this.retryTemplate = retryTemplate;
@@ -592,13 +620,14 @@ public void afterPropertiesSet() {
 			}
 
 			if (this.retryTemplate == null && !this.retryDisabled) {
-				this.retryTemplate = new RetryTemplate();
-				this.retryTemplate.setRetryPolicy(new SimpleRetryPolicy(DECLARE_MAX_ATTEMPTS));
-				ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
-				backOffPolicy.setInitialInterval(DECLARE_INITIAL_RETRY_INTERVAL);
-				backOffPolicy.setMultiplier(DECLARE_RETRY_MULTIPLIER);
-				backOffPolicy.setMaxInterval(DECLARE_MAX_RETRY_INTERVAL);
-				this.retryTemplate.setBackOffPolicy(backOffPolicy);
+				RetryPolicy retryPolicy =
+						RetryPolicy.builder()
+								.maxAttempts(DECLARE_MAX_ATTEMPTS)
+								.delay(DECLARE_INITIAL_RETRY_DELAY)
+								.multiplier(DECLARE_RETRY_MULTIPLIER)
+								.maxDelay(DECLARE_MAX_RETRY_DELAY)
+								.build();
+				this.retryTemplate = new RetryTemplate(retryPolicy);
 			}
 			if (this.connectionFactory instanceof CachingConnectionFactory ccf &&
 					ccf.getCacheMode() == CacheMode.CONNECTION) {
@@ -623,7 +652,7 @@ public void afterPropertiesSet() {
 					 * declared for every connection. If anyone has a problem with it: use auto-startup="false".
 					 */
 					if (this.retryTemplate != null) {
-						this.retryTemplate.execute(c -> {
+						this.retryTemplate.execute(() -> {
 							initialize();
 							return null;
 						});
@@ -632,6 +661,9 @@ public void afterPropertiesSet() {
 						initialize();
 					}
 				}
+				catch (RetryException ex) {
+					ReflectionUtils.rethrowRuntimeException(ex.getCause());
+				}
 				finally {
 					initializing.compareAndSet(true, false);
 				}

spring-rabbit/src/main/java/org/springframework/amqp/rabbit/retry/SpringRetryTemplateAdapter.java

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2025-present 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.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.amqp.rabbit.retry;
+
+import java.time.Duration;
+
+import org.jspecify.annotations.Nullable;
+
+import org.springframework.core.retry.RetryException;
+import org.springframework.core.retry.RetryPolicy;
+import org.springframework.core.retry.Retryable;
+import org.springframework.retry.RecoveryCallback;
+import org.springframework.retry.RetryCallback;
+import org.springframework.retry.support.RetryTemplate;
+
+/**
+ * The {@link org.springframework.core.retry.RetryTemplate} adapter for
+ * the {@link org.springframework.retry.support.RetryTemplate} instance.
+ * The goal of this class is to simplify a migration path for existing retry infrastructure.
+ * <p>
+ * The super {@link org.springframework.core.retry.RetryTemplate} is configured with "no retry" policy
+ * since all the retrying logic is delegated to the provided
+ * {@link org.springframework.retry.support.RetryTemplate}.
+ * <p>
+ * NOTE: only stateless operations are delegated with implementation at the moment.
+ *
+ * @author Artem Bilan
+ */
+public class SpringRetryTemplateAdapter extends org.springframework.core.retry.RetryTemplate {
+
+	private final RetryTemplate retryTemplate;
+
+	private @Nullable RecoveryCallback<?> recoveryCallback;
+
+	public SpringRetryTemplateAdapter(RetryTemplate retryTemplate) {
+		super(throwable -> false);
+		this.retryTemplate = retryTemplate;
+	}
+
+	@Override
+	public void setRetryPolicy(RetryPolicy retryPolicy) {
+		throw new UnsupportedOperationException(
+				"The 'org.springframework.retry.RetryPolicy' has to be used instead " +
+						"on the provided 'org.springframework.retry.support.RetryTemplate'");
+	}
+
+	/**
+	 * Set a {@link RecoveryCallback} to be used in the
+	 * {@link org.springframework.retry.support.RetryTemplate#execute(RetryCallback, RecoveryCallback)}
+	 * delegating operation.
+	 * This is exactly a {@link RecoveryCallback} used previously in the target service alongside with a
+	 * {@link org.springframework.retry.support.RetryTemplate}.
+	 * @param recoveryCallback the {@link RecoveryCallback} to use.
+	 */
+	public void setRecoveryCallback(RecoveryCallback<?> recoveryCallback) {
+		this.recoveryCallback = recoveryCallback;
+	}
+
+	@Override
+	@SuppressWarnings("unchecked")
+	public <R> @Nullable R execute(Retryable<? extends @Nullable R> retryable) throws RetryException {
+		SpringRetryTemplateRetryableDelegate<R> retryableDelegate =
+				new SpringRetryTemplateRetryableDelegate<>(retryable, this.retryTemplate,
+						(RecoveryCallback<R>) this.recoveryCallback);
+
+		return super.execute(retryableDelegate);
+	}
+
+	private record SpringRetryTemplateRetryableDelegate<R>(Retryable<? extends @Nullable R> retryable,
+														   RetryTemplate retryTemplate,
+														   @Nullable RecoveryCallback<R> recoveryCallback)
+			implements Retryable<R> {
+
+		@Override
+		@SuppressWarnings("NullAway")
+		public @Nullable R execute() throws Throwable {
+			return this.retryTemplate.execute((ctx) -> this.retryable.execute(), this.recoveryCallback);
+		}
+
+	}
+
+}

spring-rabbit/src/test/java/org/springframework/amqp/rabbit/core/RabbitAdminIntegrationTests.java

@@ -48,6 +48,7 @@
 import org.springframework.amqp.rabbit.junit.BrokerTestUtils;
 import org.springframework.amqp.rabbit.junit.RabbitAvailable;
 import org.springframework.context.support.GenericApplicationContext;
+import org.springframework.core.retry.RetryTemplate;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatNoException;
@@ -339,7 +340,7 @@ public void testSpringWithDefaultExchangeNonImplicitBinding() {
 		context.getBeanFactory().registerSingleton("bar", queue);
 		Binding binding = new Binding(queueName, DestinationType.QUEUE, exchange.getName(), "test.routingKey", null);
 		context.getBeanFactory().registerSingleton("baz", binding);
-		this.rabbitAdmin.setRetryTemplate(null);
+		this.rabbitAdmin.setRetryTemplate((RetryTemplate) null);
 		this.rabbitAdmin.afterPropertiesSet();
 
 		try {
@@ -368,7 +369,7 @@ public void testQueueDeclareBad() {
 	}
 
 	@Test
-	public void testDeclareDelayedExchange() throws Exception {
+	public void testDeclareDelayedExchange() {
 		DirectExchange exchange = new DirectExchange("test.delayed.exchange");
 		exchange.setDelayed(true);
 		Queue queue = new Queue(UUID.randomUUID().toString(), true, false, false);

spring-rabbit/src/test/java/org/springframework/amqp/rabbit/core/RabbitAdminTests.java

@@ -338,6 +338,7 @@ public void testWithinInvoke() throws Exception {
 	}
 
 	@Test
+	@SuppressWarnings("removal")
 	public void testRetry() throws Exception {
 		com.rabbitmq.client.ConnectionFactory rabbitConnectionFactory = mock(com.rabbitmq.client.ConnectionFactory.class);
 		com.rabbitmq.client.Connection connection = mock(com.rabbitmq.client.Connection.class);

spring-rabbit/src/test/java/org/springframework/amqp/rabbit/listener/ContainerInitializationTests.java

@@ -37,6 +37,7 @@
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.core.retry.RetryTemplate;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.fail;
@@ -47,7 +48,7 @@
  * @since 1.6
  *
  */
-@RabbitAvailable(queues = { ContainerInitializationTests.TEST_MISMATCH, ContainerInitializationTests.TEST_MISMATCH2 })
+@RabbitAvailable(queues = {ContainerInitializationTests.TEST_MISMATCH, ContainerInitializationTests.TEST_MISMATCH2})
 public class ContainerInitializationTests {
 
 	public static final String TEST_MISMATCH = "test.mismatch";
@@ -129,7 +130,7 @@ else if (RabbitUtils.isMismatchedQueueArgs(s)) {
 				mismatchLatch.countDown();
 			}
 		});
-		return new CountDownLatch[] { cancelLatch, mismatchLatch, preventContainerRedeclareQueueLatch };
+		return new CountDownLatch[] {cancelLatch, mismatchLatch, preventContainerRedeclareQueueLatch};
 	}
 
 	@Configuration
@@ -169,7 +170,7 @@ static class Config1 extends Config0 {
 		@Bean
 		public RabbitAdmin admin() {
 			RabbitAdmin admin = new RabbitAdmin(connectionFactory());
-			admin.setRetryTemplate(null);
+			admin.setRetryTemplate((RetryTemplate) null);
 			return admin;
 		}
 
@@ -189,7 +190,6 @@ public Queue queue() {
 	@Configuration
 	static class Config3 extends Config2 {
 
-
 		@Override
 		public SimpleMessageListenerContainer container() {
 			SimpleMessageListenerContainer container = super.container();