GH-4016: Fix @RetryableTopic includeNames/excludeNames for SpEL

Fixes: #4016

Previously, the `includeNames` and `excludeNames` attributes of
`@RetryableTopic` were not processed through the configured
`BeanExpressionResolver` and `BeanExpressionContext`.

This change ensures proper resolution from property placeholders
`(${...})` and SpEL expressions `(#{...})`, consistent with the
documentation and behavior of similar annotations like `@KafkaListener`.

Signed-off-by: Dimitri Tugo <tugo@zamati.com>

[artem.bilan@broadcom.com: Improve comint message]

The Javadoc of the `@RetryableTopic` includes the statement:

>  All String properties can be resolved from property placeholders `${...}` or SpEL expressions `#{...}`.

While `includeNames` and `excludeNames` are technically `String[]` rather than `String`, it’s a reasonable and common expectation that this applies to all string-valued attributes — including arrays.
This interpretation is also consistent with how similar annotations behave, such as `@KafkaListener`, where array properties like topics support both property placeholders and SpEL expressions on a per-element basis.

Enabling resolution here improves consistency with `@KafkaListener`, reduces potential surprises, and allows for cleaner externalization of retryable or non-retryable exception lists.

Signed-off-by: Artem Bilan <artem.bilan@broadcom.com>
(cherry picked from commit d4925d6)

Author: NipponSunrise

spring-kafka/src/main/java/org/springframework/kafka/annotation/RetryableTopicAnnotationProcessor.java

@@ -19,6 +19,7 @@
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
@@ -131,10 +132,15 @@ public RetryTopicConfiguration processAnnotation(String[] topics, Class<?> clazz
 		if (resolvedTimeout != null) {
 			timeout = resolvedTimeout;
 		}
-		List<Class<? extends Throwable>> includes = resolveClasses(annotation.include(), annotation.includeNames(),
+
+		String[] resolvedIncludeNames = resolveToStringArray(annotation.includeNames());
+		List<Class<? extends Throwable>> includes = resolveClasses(annotation.include(), resolvedIncludeNames,
 				"include");
-		List<Class<? extends Throwable>> excludes = resolveClasses(annotation.exclude(), annotation.excludeNames(),
+
+		String[] resolvedExcludeNames = resolveToStringArray(annotation.excludeNames());
+		List<Class<? extends Throwable>> excludes = resolveClasses(annotation.exclude(), resolvedExcludeNames,
 				"exclude");
+
 		boolean traverse = false;
 		if (StringUtils.hasText(annotation.traversingCauses())) {
 			Boolean traverseResolved = resolveExpressionAsBoolean(annotation.traversingCauses(), "traversingCauses");
@@ -422,4 +428,25 @@ private String resolve(String value) {
 		return value;
 	}
 
+	private String[] resolveToStringArray(String[] values) {
+		List<String> result = new ArrayList<>();
+		for (String value : values) {
+			Object resolved = resolveExpression(value);
+			if (resolved instanceof String[] strings) {
+				Collections.addAll(result, strings);
+			}
+			else if (resolved instanceof Collection<?> coll) {
+				for (Object item : coll) {
+					result.add(item.toString());
+				}
+			}
+			else if (resolved instanceof String str) {
+				result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(str)));
+			}
+			else if (resolved != null) {
+				result.add(resolved.toString());
+			}
+		}
+		return result.toArray(new String[0]);
+	}
 }