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 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.assertFalse;
 
 /**
  * @author Dave Syer
@@ -107,6 +110,17 @@ public void parentReturnTypeRecoverMethod() {
 
 	}
 
+	@Test
+	public void genericReturnTypeRecover() {
+		RecoverAnnotationRecoveryHandler<?> handler = new RecoverAnnotationRecoveryHandler<List<String>>(
+				new GenericReturnTypeRecover(),
+				ReflectionUtils.findMethod(GenericReturnTypeRecover.class, "foo", String.class));
+		List<String> recoverResponse = (List<String>) handler.recover(new Object[] { "Aldo" },
+				new RuntimeException("Planned"));
+		assertFalse(CollectionUtils.isEmpty(recoverResponse));
+		assertEquals("fooRecover", recoverResponse.get(0));
+	}
+
 	@Test
 	public void multipleQualifyingRecoverMethods() {
 		Method foo = ReflectionUtils.findMethod(MultipleQualifyingRecovers.class, "foo", String.class);
@@ -293,6 +307,38 @@ 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 List<String> foo(String name) {
+			return Collections.singletonList("foo");
+		}
+
+		@Retryable
+		public List<One> bar(String name) {
+			return Collections.singletonList(new One("bar"));
+		}
+
+		@Recover
+		public List<String> fooRecover(String name) {
+			return Collections.singletonList("fooRecover");
+		}
+
+		@Recover
+		public List<One> barRecover(String name) {
+			return Collections.singletonList(new One("barRecover"));
+		}
+	}
+
 	protected static class MultipleQualifyingRecoversNoThrowable {
 
 		@Retryable