GH-10345: Migrate to Spring Core Retry (#10401)

* GH-10345: Migrate to Spring Core Retry

Fixes: #10345

* Remove `spring-retry` dependency since all its usage have been replaced with Spring Core Retry and some custom internal implementations
* Rework the `RequestHandlerRetryAdvice` to be based on the Spring Core Retry:
 - accept only `RetryPolicy` and use `RetryTemplate` internally just for stateless behavior
 - Expose `stateKeyFunction`, `newMessagePredicate` and `stateCacheSize` for stateful behavior.
 - Since there is no any stateful utility in Spring Core, implement its algorithm internally in the `RequestHandlerRetryAdvice`
* Remove `RetryStateGenerator` and `SpelExpressionRetryStateGenerator` since they are based on `RetryState` from Spring Retry.
And now they are replaced by the mentioned functions above as options on the `RequestHandlerRetryAdvice`
* Rework `RetryAdviceParser` according to a new state of the `RequestHandlerRetryAdvice`.
In addition, expose an `exponential-back-off/jitter` XML attribute
* Fix `ErrorMessageStrategy` Javadoc to point to a general `AttributeAccessor` interface from Spring Core
* Remove `ErrorMessageSendingRecoverer.RetryExceptionNotAvailableException`
and the logic around it since this is not a case anymore with a new `RequestHandlerRetryAdvice` logic
* Rework failing tests according to the new API and logic of the target classes
* Document breaking change in the `whats-new.adoc`
* Rework `retry` section in the `handler-advice/classes.adoc` to reflect new reality for the `RequestHandlerRetryAdvice`
* Rework the configuration samples in the `retry` section to Java

* Fix typos and language in the docs and Javadocs
* Use a proper `retryStateKey` for cache entry removal on successful retry execution

Author: artembilan

build.gradle

@@ -104,7 +104,6 @@ ext {
     springDataVersion = '2025.1.0-M5'
     springGraphqlVersion = '2.0.0-SNAPSHOT'
     springKafkaVersion = '4.0.0-SNAPSHOT'
-    springRetryVersion = '2.0.12'
     springSecurityVersion = '7.0.0-SNAPSHOT'
     springVersion = '7.0.0-SNAPSHOT'
     springWsVersion = '5.0.0-SNAPSHOT'
@@ -485,9 +484,6 @@ project('spring-integration-core') {
         api 'org.springframework:spring-context'
         api 'org.springframework:spring-messaging'
         api 'org.springframework:spring-tx'
-        api("org.springframework.retry:spring-retry:$springRetryVersion") {
-            exclude group: 'org.springframework'
-        }
         api 'io.projectreactor:reactor-core'
         api 'io.micrometer:micrometer-observation'
 

spring-integration-core/src/main/java/org/springframework/integration/config/xml/RetryAdviceParser.java

@@ -16,6 +16,8 @@
 
 package org.springframework.integration.config.xml;
 
+import java.util.Set;
+
 import org.w3c.dom.Element;
 
 import org.springframework.beans.factory.support.AbstractBeanDefinition;
@@ -24,11 +26,9 @@
 import org.springframework.beans.factory.xml.ParserContext;
 import org.springframework.integration.handler.advice.ErrorMessageSendingRecoverer;
 import org.springframework.integration.handler.advice.RequestHandlerRetryAdvice;
-import org.springframework.retry.backoff.ExponentialBackOffPolicy;
-import org.springframework.retry.backoff.FixedBackOffPolicy;
-import org.springframework.retry.policy.SimpleRetryPolicy;
-import org.springframework.retry.support.RetryTemplate;
 import org.springframework.util.StringUtils;
+import org.springframework.util.backoff.ExponentialBackOff;
+import org.springframework.util.backoff.FixedBackOff;
 import org.springframework.util.xml.DomUtils;
 
 /**
@@ -43,42 +43,41 @@ public class RetryAdviceParser extends AbstractBeanDefinitionParser {
 	@Override
 	protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
 		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(RequestHandlerRetryAdvice.class);
-		BeanDefinitionBuilder retryTemplateBuilder = BeanDefinitionBuilder.genericBeanDefinition(RetryTemplate.class);
-		boolean customTemplate = false;
+
+		String maxAttempts = element.getAttribute("max-attempts");
+
+		// Default to 3 attempts and no delay in between.
+		BeanDefinitionBuilder backOffBuilder =
+				BeanDefinitionBuilder.genericBeanDefinition(FixedBackOff.class)
+						.addConstructorArgValue(0)
+						.addConstructorArgValue(maxAttempts);
+
 		Element backOffPolicyEle = DomUtils.getChildElementByTagName(element, "fixed-back-off");
-		BeanDefinitionBuilder backOffBuilder = null;
 		if (backOffPolicyEle != null) {
-			backOffBuilder = BeanDefinitionBuilder.genericBeanDefinition(ParsedFixedBackOffPolicy.class);
-			IntegrationNamespaceUtils.setValueIfAttributeDefined(
-					backOffBuilder, backOffPolicyEle, "interval", "backOffPeriodSimple");
+			backOffBuilder = BeanDefinitionBuilder.genericBeanDefinition(FixedBackOff.class)
+					.addConstructorArgValue(backOffPolicyEle.getAttribute("interval"))
+					.addConstructorArgValue(maxAttempts);
 		}
 		else {
 			backOffPolicyEle = DomUtils.getChildElementByTagName(element, "exponential-back-off");
 			if (backOffPolicyEle != null) {
-				backOffBuilder = BeanDefinitionBuilder.genericBeanDefinition(ParsedExponentialBackOffPolicy.class);
-				IntegrationNamespaceUtils.setValueIfAttributeDefined(backOffBuilder, backOffPolicyEle, "initial",
-						"initialIntervalSimple");
-				IntegrationNamespaceUtils.setValueIfAttributeDefined(backOffBuilder, backOffPolicyEle,
-						"multiplier", "multiplierSimple");
-				IntegrationNamespaceUtils.setValueIfAttributeDefined(backOffBuilder, backOffPolicyEle, "maximum",
-						"maxIntervalSimple");
+				backOffBuilder = BeanDefinitionBuilder.genericBeanDefinition(ExponentialBackOff.class)
+						.addPropertyValue("maxAttempts", maxAttempts)
+						.addPropertyValue("multiplier", backOffPolicyEle.getAttribute("multiplier"))
+						.addPropertyValue("initialInterval", backOffPolicyEle.getAttribute("initial"))
+						.addPropertyValue("maxInterval", backOffPolicyEle.getAttribute("maximum"))
+						.addPropertyValue("jitter", backOffPolicyEle.getAttribute("jitter"));
 			}
 		}
-		if (backOffBuilder != null) {
-			retryTemplateBuilder.addPropertyValue("backOffPolicy", backOffBuilder.getBeanDefinition());
-			customTemplate = true;
-		}
-		String maxAttemptsAttr = element.getAttribute("max-attempts");
-		if (StringUtils.hasText(maxAttemptsAttr)) {
-			BeanDefinitionBuilder retryPolicyBuilder =
-					BeanDefinitionBuilder.genericBeanDefinition(SimpleRetryPolicy.class)
-							.addConstructorArgValue(element.getAttribute("max-attempts"));
-			retryTemplateBuilder.addPropertyValue("retryPolicy", retryPolicyBuilder.getBeanDefinition());
-			customTemplate = true;
-		}
-		if (customTemplate) {
-			builder.addPropertyValue("retryTemplate", retryTemplateBuilder.getBeanDefinition());
-		}
+
+		BeanDefinitionBuilder retryPolicyBuilder =
+				BeanDefinitionBuilder.genericBeanDefinition("org.springframework.core.retry.DefaultRetryPolicy")
+						.addConstructorArgValue(Set.of())
+						.addConstructorArgValue(Set.of())
+						.addConstructorArgValue(null)
+						.addConstructorArgValue(backOffBuilder.getBeanDefinition());
+
+		builder.addPropertyValue("retryPolicy", retryPolicyBuilder.getBeanDefinition());
 		String recoveryChannelAttr = element.getAttribute("recovery-channel");
 		if (StringUtils.hasText(recoveryChannelAttr)) {
 			BeanDefinitionBuilder emsrBuilder =
@@ -90,34 +89,4 @@ protected AbstractBeanDefinition parseInternal(Element element, ParserContext pa
 		return builder.getBeanDefinition();
 	}
 
-	private static final class ParsedFixedBackOffPolicy extends FixedBackOffPolicy {
-
-		ParsedFixedBackOffPolicy() {
-		}
-
-		public void setBackOffPeriodSimple(long backOffPeriod) {
-			setBackOffPeriod(backOffPeriod);
-		}
-
-	}
-
-	private static final class ParsedExponentialBackOffPolicy extends ExponentialBackOffPolicy {
-
-		ParsedExponentialBackOffPolicy() {
-		}
-
-		public void setInitialIntervalSimple(long initialInterval) {
-			setInitialInterval(initialInterval);
-		}
-
-		public void setMultiplierSimple(double multiplier) {
-			setMultiplier(multiplier);
-		}
-
-		public void setMaxIntervalSimple(long maxInterval) {
-			setMaxInterval(maxInterval);
-		}
-
-	}
-
 }

spring-integration-core/src/main/java/org/springframework/integration/handler/advice/ErrorMessageSendingRecoverer.java

@@ -16,19 +16,14 @@
 
 package org.springframework.integration.handler.advice;
 
-import java.io.Serial;
-
 import org.jspecify.annotations.Nullable;
 
 import org.springframework.core.AttributeAccessor;
 import org.springframework.integration.core.ErrorMessagePublisher;
 import org.springframework.integration.core.RecoveryCallback;
 import org.springframework.integration.support.DefaultErrorMessageStrategy;
 import org.springframework.integration.support.ErrorMessageStrategy;
-import org.springframework.integration.support.ErrorMessageUtils;
-import org.springframework.messaging.Message;
 import org.springframework.messaging.MessageChannel;
-import org.springframework.messaging.MessagingException;
 
 /**
  * A {@link RecoveryCallback} that sends the final throwable as an
@@ -85,31 +80,4 @@ public ErrorMessageSendingRecoverer(MessageChannel channel, ErrorMessageStrategy
 		return null;
 	}
 
-	@Override
-	protected Throwable payloadWhenNull(AttributeAccessor context) {
-		Message<?> message = (Message<?>) context.getAttribute(ErrorMessageUtils.FAILED_MESSAGE_CONTEXT_KEY);
-		String description = "No retry exception available; " +
-				"this can occur, for example, if the RetryPolicy allowed zero attempts " +
-				"to execute the handler; " +
-				"RetryContext: " + context;
-		return message == null
-				? new RetryExceptionNotAvailableException(description)
-				: new RetryExceptionNotAvailableException(message, description);
-	}
-
-	public static class RetryExceptionNotAvailableException extends MessagingException {
-
-		@Serial
-		private static final long serialVersionUID = 1L;
-
-		RetryExceptionNotAvailableException(String description) {
-			super(description);
-		}
-
-		public RetryExceptionNotAvailableException(Message<?> message, String description) {
-			super(message, description);
-		}
-
-	}
-
 }