Address code review

- Add specific retry exception
- Add RetryCallback interface with a logical name for diagnostics purpose
- Improve RetryPolicy with ability to specify which exceptions to retry

Author: fmbenhassine

spring-core/src/main/java/org/springframework/core/retry/RetryCallback.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2002-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.
+ * 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.core.retry;
+
+/**
+ * Callback interface for a retryable piece of code. Used in conjunction with {@link RetryOperations}.
+ *
+ * @author Mahmoud Ben Hassine
+ * @since 7.0
+ * @param <R> the type of the result
+ * @see RetryOperations
+ */
+public interface RetryCallback<R> {
+
+	/**
+	 * Method to execute and retry if needed.
+	 * @return the result of the callback
+	 * @throws Exception if an error occurs during the execution of the callback
+	 */
+	R run() throws Exception;
+
+	/**
+	 * A unique logical name for this callback to distinguish retries around
+	 * business operations.
+	 * @return the name of the callback
+	 */
+	String getName();
+}

spring-core/src/main/java/org/springframework/core/retry/RetryException.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2002-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.
+ * 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.core.retry;
+
+import java.io.Serial;
+
+/**
+ * Exception class for exhausted retries.
+ *
+ * @author Mahmoud Ben Hassine
+ * @since 7.0
+ * @see RetryOperations
+ */
+public class RetryException extends Exception {
+
+	@Serial
+	private static final long serialVersionUID = 5439915454935047936L;
+
+	/**
+	 * Create a new exception with a message.
+	 * @param message the exception's message
+	 */
+	public RetryException(String message) {
+		super(message);
+	}
+
+	/**
+	 * Create a new exception with a message and a cause.
+	 * @param message the exception's message
+	 * @param cause the exception's cause
+	 */
+	public RetryException(String message, Throwable cause) {
+		super(message, cause);
+	}
+
+}

spring-core/src/main/java/org/springframework/core/retry/RetryOperations.java

@@ -16,8 +16,6 @@
 
 package org.springframework.core.retry;
 
-import java.util.concurrent.Callable;
-
 import org.jspecify.annotations.Nullable;
 
 /**
@@ -28,6 +26,7 @@
  *
  * @author Mahmoud Ben Hassine
  * @since 7.0
+ * @see RetryTemplate
  */
 public interface RetryOperations {
 
@@ -37,9 +36,9 @@ public interface RetryOperations {
 	 * @param retryCallback the callback to call initially and retry if needed
 	 * @param <R> the type of the callback's result
 	 * @return the callback's result
-	 * @throws Exception if the retry policy is exhausted
+	 * @throws RetryException if the retry policy is exhausted
 	 */
-	<R> @Nullable R execute(Callable<R> retryCallback) throws Exception;
+	<R> @Nullable R execute(RetryCallback<R> retryCallback) throws RetryException;
 
 }
 

spring-core/src/main/java/org/springframework/core/retry/RetryPolicy.java

@@ -16,8 +16,11 @@
 
 package org.springframework.core.retry;
 
+import java.util.function.Predicate;
+
 /**
- * Strategy interface to define how to calculate the maximum number of retry attempts.
+ * Strategy interface to define how to calculate the maximum number of retry attempts
+ * and which exceptions to retry.
  *
  * @author Mahmoud Ben Hassine
  * @since 7.0
@@ -30,4 +33,13 @@ public interface RetryPolicy {
 	 */
 	int getMaxAttempts();
 
+	/**
+	 * Return a predicate that specifies which exceptions to retry. Defaults to a
+	 * predicate that retries all exceptions.
+	 * @return a predicate that specifies which exceptions to retry
+	 */
+	default Predicate<Exception> retryOn() {
+		return exception -> true;
+	}
+
 }

spring-core/src/main/java/org/springframework/core/retry/RetryTemplate.java

@@ -59,6 +59,32 @@ public class RetryTemplate implements RetryOperations {
 	private RetryListener retryListener = new RetryListener() {
 	};
 
+	/**
+	 * Create a new retry template with default settings.
+	 */
+	public RetryTemplate() {
+	}
+
+	/**
+	 * Create a new retry template with a custom {@link RetryPolicy}.
+	 * @param retryPolicy the retry policy to use
+	 */
+	public RetryTemplate(RetryPolicy retryPolicy) {
+		Assert.notNull(retryPolicy, "Retry policy must not be null");
+		this.retryPolicy = retryPolicy;
+	}
+
+	/**
+	 * Create a new retry template with a custom {@link RetryPolicy} and {@link BackOffPolicy}.
+	 * @param retryPolicy the retry policy to use
+	 * @param backOffPolicy the backoff policy to use
+	 */
+	public RetryTemplate(RetryPolicy retryPolicy, BackOffPolicy backOffPolicy) {
+		this(retryPolicy);
+		Assert.notNull(backOffPolicy, "BackOff policy must not be null");
+		this.backOffPolicy = backOffPolicy;
+	}
+
 	/**
 	 * Set the {@link RetryPolicy} to use. Defaults to <code>MaxAttemptsRetryPolicy(3)</code>.
 	 * @param retryPolicy the retry policy to use. Must not be <code>null</code>.
@@ -92,41 +118,50 @@ public void setRetryListener(RetryListener retryListener) {
 	 * If the callback succeeds, its result is returned. Otherwise, the last exception will
 	 * be propagated to the caller.
 	 * @param retryCallback the callback to call initially and retry if needed
-	 * @param <R>           the type of the result
+	 * @param <R> the type of the result
 	 * @return the result of the callback if any
-	 * @throws Exception thrown if the retry policy is exhausted
+	 * @throws RetryException thrown if the retry policy is exhausted
 	 */
 	@Override
-	public <R> @Nullable R execute(Callable<R> retryCallback) throws Exception {
+	public <R> @Nullable R execute(RetryCallback<R> retryCallback) throws RetryException {
 		Assert.notNull(retryCallback, "Retry Callback must not be null");
 		int attempts = 0;
 		int maxAttempts = this.retryPolicy.getMaxAttempts();
 		while (attempts++ <= maxAttempts) {
+			String callbackName = retryCallback.getName();
 			if (logger.isDebugEnabled()) {
-				logger.debug("Retry attempt #" + attempts);
+				logger.debug("Retry callback '" + callbackName + "'  attempt #" + attempts);
 			}
 			try {
 				this.retryListener.beforeRetry();
-				R result = retryCallback.call();
+				R result = retryCallback.run();
 				this.retryListener.onSuccess(result);
 				if (logger.isDebugEnabled()) {
-					logger.debug("Retry attempt #" + attempts + " succeeded");
+					logger.debug("Retry callback '" + callbackName + "' attempt #" + attempts + " succeeded");
 				}
 				return result;
 			}
 			catch (Exception exception) {
+				if (!this.retryPolicy.retryOn().test(exception)) {
+					if (logger.isDebugEnabled()) {
+						logger.debug("Retry callback '" + callbackName + "' aborted on " + exception.getMessage(), exception);
+					}
+					break;
+				}
 				this.retryListener.onFailure(exception);
 				Duration duration = this.backOffPolicy.backOff();
-				Thread.sleep(duration.toMillis());
 				if (logger.isDebugEnabled()) {
-					logger.debug("Attempt #" + attempts + " failed, backing off for " + duration.toMillis() + "ms");
+					logger.debug("Retry callback '" + callbackName + "' attempt #" + attempts + " failed, backing off for " + duration.toMillis() + "ms");
+				}
+				try {
+					Thread.sleep(duration.toMillis());
+				}
+				catch (InterruptedException interruptedException) {
+					throw new RetryException("Unable to backoff for retry callback '" + callbackName + "'", interruptedException);
 				}
 				if (attempts >= maxAttempts) {
-					if (logger.isDebugEnabled()) {
-						logger.debug("Maximum retry attempts " + attempts + " exhausted, aborting execution");
-					}
 					this.retryListener.onMaxAttempts(exception);
-					throw exception;
+					throw new RetryException("Retry callback '" + callbackName + "' exceeded maximum retry attempts " + attempts + ", aborting execution", exception);
 				}
 			}
 		}

spring-core/src/test/java/org/springframework/core/retry/RetryTemplateTests.java

@@ -17,7 +17,7 @@
 package org.springframework.core.retry;
 
 import java.time.Duration;
-import java.util.concurrent.Callable;
+import java.util.function.Predicate;
 
 import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
 import org.junit.jupiter.api.Test;
@@ -37,44 +37,98 @@ class RetryTemplateTests {
 
 	@Test
 	void testRetryWithSuccess() throws Exception {
-		// given some unreliable code
-		Callable<String> callable = new Callable<>() {
+		// given
+		RetryCallback<String> retryCallback = new RetryCallback<>() {
 			int failure;
 			@Override
-			public String call() throws Exception {
+			public String run() throws Exception {
 				if (failure++ < 2) {
-					throw new Exception("Error while invoking service");
+					throw new Exception("Error while invoking greeting service");
 				}
 				return "hello world";
 			}
+
+			@Override
+			public String getName() {
+				return "greeting service";
+			}
 		};
-		// and a configured retry template
 		RetryTemplate retryTemplate = new RetryTemplate();
 		retryTemplate.setRetryPolicy(new MaxAttemptsRetryPolicy(3));
 		retryTemplate.setBackOffPolicy(new FixedBackOffPolicy(Duration.ofMillis(100)));
 
 		// when
-		String result = retryTemplate.execute(callable);
+		String result = retryTemplate.execute(retryCallback);
 
 		// then
 		assertThat(result).isEqualTo("hello world");
 	}
 
 	@Test
 	void testRetryWithFailure() {
-		// given some unreliable code
-		Callable<String> callable = () -> {
-			throw new Exception("Error while invoking service");
+		// given
+		RetryCallback<String> retryCallback = new RetryCallback<>() {
+			@Override
+			public String run() throws Exception {
+				throw new Exception("Error while invoking greeting service");
+			}
+
+			@Override
+			public String getName() {
+				return "greeting service";
+			}
 		};
-		// and a configured retry template
 		RetryTemplate retryTemplate = new RetryTemplate();
 		retryTemplate.setRetryPolicy(new MaxAttemptsRetryPolicy(3));
 		retryTemplate.setBackOffPolicy(new FixedBackOffPolicy(Duration.ofMillis(100)));
 
 		// when
-		ThrowingCallable throwingCallable = () -> retryTemplate.execute(callable);
+		ThrowingCallable throwingCallable = () -> retryTemplate.execute(retryCallback);
+
+		// then
+		assertThatThrownBy(throwingCallable)
+				.isInstanceOf(RetryException.class)
+				.hasMessage("Retry callback 'greeting service' exceeded maximum retry attempts 3, aborting execution")
+				.cause().isInstanceOf(Exception.class).hasMessage("Error while invoking greeting service");
+	}
+
+	@Test
+	void testRetrySpecificException() {
+		// given
+		class TechnicalException extends Exception {
+			public TechnicalException(String message) {
+				super(message);
+			}
+		}
+		RetryCallback<String> retryCallback = new RetryCallback<>() {
+			@Override
+			public String run() throws TechnicalException {
+				throw new TechnicalException("Error while invoking greeting service");
+			}
+
+			@Override
+			public String getName() {
+				return "greeting service";
+			}
+		};
+		MaxAttemptsRetryPolicy retryPolicy = new MaxAttemptsRetryPolicy(3) {
+			@Override
+			public Predicate<Exception> retryOn() {
+				return exception -> exception instanceof TechnicalException;
+			}
+		};
+		RetryTemplate retryTemplate = new RetryTemplate();
+		retryTemplate.setRetryPolicy(retryPolicy);
+		retryTemplate.setBackOffPolicy(new FixedBackOffPolicy(Duration.ofMillis(100)));
+
+		// when
+		ThrowingCallable throwingCallable = () -> retryTemplate.execute(retryCallback);
 
 		// then
-		assertThatThrownBy(throwingCallable).hasMessage("Error while invoking service");
+		assertThatThrownBy(throwingCallable)
+				.isInstanceOf(RetryException.class)
+				.cause().isInstanceOf(TechnicalException.class)
+				.hasMessage("Error while invoking greeting service");
 	}
+
 }