Add generic check for function return type

Fixes: [#215](#215)
Signed-off-by: deepesh-verma <[email protected]>

Author: deepesh-verma

src/main/java/org/springframework/retry/annotation/RecoverAnnotationRecoveryHandler.java

@@ -17,6 +17,7 @@
 package org.springframework.retry.annotation;
 
 import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -173,27 +174,34 @@ public void doWith(Method method) throws IllegalArgumentException, IllegalAccess
 				if (recover == null) {
 					recover = findAnnotationOnTarget(target, method);
 				}
-				if (recover != null && method.getReturnType().isAssignableFrom(failingMethod.getReturnType())) {
-					Class<?>[] parameterTypes = method.getParameterTypes();
-					if (parameterTypes.length > 0 && Throwable.class.isAssignableFrom(parameterTypes[0])) {
-						@SuppressWarnings("unchecked")
-						Class<? extends Throwable> type = (Class<? extends Throwable>) parameterTypes[0];
-						types.put(type, method);
-						RecoverAnnotationRecoveryHandler.this.methods.put(method,
-								new SimpleMetadata(parameterTypes.length, type));
-					}
-					else {
-						RecoverAnnotationRecoveryHandler.this.classifier.setDefaultValue(method);
-						RecoverAnnotationRecoveryHandler.this.methods.put(method,
-								new SimpleMetadata(parameterTypes.length, null));
+				if (recover != null && failingMethod.getGenericReturnType() instanceof ParameterizedType) {
+					if (method.getGenericReturnType().equals(failingMethod.getGenericReturnType())) {
+						putToMethodsMap(method, types);
 					}
 				}
+				else if (recover != null && method.getReturnType().isAssignableFrom(failingMethod.getReturnType())) {
+					putToMethodsMap(method, types);
+				}
 			}
 		});
 		this.classifier.setTypeMap(types);
 		optionallyFilterMethodsBy(failingMethod.getReturnType());
 	}
 
+	private void putToMethodsMap(Method method, Map<Class<? extends Throwable>, Method> types) {
+		Class<?>[] parameterTypes = method.getParameterTypes();
+		if (parameterTypes.length > 0 && Throwable.class.isAssignableFrom(parameterTypes[0])) {
+			@SuppressWarnings("unchecked")
+			Class<? extends Throwable> type = (Class<? extends Throwable>) parameterTypes[0];
+			types.put(type, method);
+			RecoverAnnotationRecoveryHandler.this.methods.put(method, new SimpleMetadata(parameterTypes.length, type));
+		}
+		else {
+			RecoverAnnotationRecoveryHandler.this.classifier.setDefaultValue(method);
+			RecoverAnnotationRecoveryHandler.this.methods.put(method, new SimpleMetadata(parameterTypes.length, null));
+		}
+	}
+
 	private Recover findAnnotationOnTarget(Object target, Method method) {
 		try {
 			Method targetMethod = target.getClass().getMethod(method.getName(), method.getParameterTypes());

src/test/java/org/springframework/retry/annotation/RecoverAnnotationRecoveryHandlerTests.java

@@ -18,16 +18,19 @@
 
 import java.lang.reflect.Method;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 
 import org.springframework.retry.ExhaustedRetryException;
+import org.springframework.util.CollectionUtils;
 import org.springframework.util.ReflectionUtils;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.*;
 
 /**
  * @author Dave Syer
@@ -107,6 +110,49 @@ public void parentReturnTypeRecoverMethod() {
 
 	}
 
+	@Test
+	public void genericReturnStringValueTypeParentThrowableRecoverMethod() {
+
+		RecoverAnnotationRecoveryHandler<?> handler = new RecoverAnnotationRecoveryHandler<List<String>>(
+				new GenericReturnTypeRecover(),
+				ReflectionUtils.findMethod(GenericReturnTypeRecover.class, "foo", String.class));
+
+		@SuppressWarnings("unchecked")
+		Map<String, String> recoverResponseMap = (Map<String, String>) handler.recover(new Object[] { "Aldo" },
+				new RuntimeException("Planned"));
+		assertFalse(CollectionUtils.isEmpty(recoverResponseMap));
+		assertEquals("fooRecoverValue1", recoverResponseMap.get("foo"));
+	}
+
+	@Test
+	public void genericReturnStringValueTypeChildThrowableRecoverMethod() {
+
+		RecoverAnnotationRecoveryHandler<?> handler = new RecoverAnnotationRecoveryHandler<List<String>>(
+				new GenericReturnTypeRecover(),
+				ReflectionUtils.findMethod(GenericReturnTypeRecover.class, "foo", String.class));
+
+		@SuppressWarnings("unchecked")
+		Map<String, String> recoverResponseMap = (Map<String, String>) handler.recover(new Object[] { "Aldo" },
+				new IllegalStateException("Planned"));
+		assertFalse(CollectionUtils.isEmpty(recoverResponseMap));
+		assertEquals("fooRecoverValue2", recoverResponseMap.get("foo"));
+	}
+
+	@Test
+	public void genericReturnOneValueTypeRecoverMethod() {
+
+		RecoverAnnotationRecoveryHandler<?> handler = new RecoverAnnotationRecoveryHandler<List<String>>(
+				new GenericReturnTypeRecover(),
+				ReflectionUtils.findMethod(GenericReturnTypeRecover.class, "bar", String.class));
+
+		@SuppressWarnings("unchecked")
+		Map<String, GenericReturnTypeRecover.One> recoverResponseMap = (Map<String, GenericReturnTypeRecover.One>) handler
+				.recover(new Object[] { "Aldo" }, new RuntimeException("Planned"));
+		assertFalse(CollectionUtils.isEmpty(recoverResponseMap));
+		assertNotNull(recoverResponseMap.get("bar"));
+		assertEquals("barRecoverValue", recoverResponseMap.get("bar").name);
+	}
+
 	@Test
 	public void multipleQualifyingRecoverMethods() {
 		Method foo = ReflectionUtils.findMethod(MultipleQualifyingRecovers.class, "foo", String.class);
@@ -293,6 +339,45 @@ public Number quux(RuntimeException re, String name) {
 
 	}
 
+	protected static class GenericReturnTypeRecover {
+
+		private static class One {
+
+			String name;
+
+			public One(String name) {
+				this.name = name;
+			}
+
+		}
+
+		@Retryable
+		public Map<String, String> foo(String name) {
+			return Collections.singletonMap("foo", "fooValue");
+		}
+
+		@Retryable
+		public Map<String, One> bar(String name) {
+			return Collections.singletonMap("bar", new One("barValue"));
+		}
+
+		@Recover
+		public Map<String, String> fooRecoverRe(RuntimeException re, String name) {
+			return Collections.singletonMap("foo", "fooRecoverValue1");
+		}
+
+		@Recover
+		public Map<String, String> fooRecoverIe(IllegalStateException re, String name) {
+			return Collections.singletonMap("foo", "fooRecoverValue2");
+		}
+
+		@Recover
+		public Map<String, One> barRecover(RuntimeException re, String name) {
+			return Collections.singletonMap("bar", new One("barRecoverValue"));
+		}
+
+	}
+
 	protected static class MultipleQualifyingRecoversNoThrowable {
 
 		@Retryable