GenericTypeResolver properly handles bound parameterized type

jhoeller · jhoeller · commit ea6525f15fa1 · 2013-08-20T19:36:57.000+02:00
Issue: SPR-10819
diff --git a/spring-core/src/main/java/org/springframework/core/GenericTypeResolver.java b/spring-core/src/main/java/org/springframework/core/GenericTypeResolver.java
@@ -305,7 +305,7 @@ else if (ifc != null && genericIfc.isAssignableFrom((Class) ifc)) {
 	}
 
 	/**
-	 * Extract a class instance from given Type.
+	 * Extract a Class from the given Type.
 	 */
 	private static Class<?> extractClass(Class<?> ownerClass, Type arg) {
 		if (arg instanceof ParameterizedType) {
@@ -322,9 +322,12 @@ else if (arg instanceof TypeVariable) {
 			arg = getTypeVariableMap(ownerClass).get(tv);
 			if (arg == null) {
 				arg = extractBoundForTypeVariable(tv);
+				if (arg instanceof ParameterizedType) {
+					return extractClass(ownerClass, ((ParameterizedType) arg).getRawType());
+				}
 			}
 			else {
-				arg = extractClass(ownerClass, arg);
+				return extractClass(ownerClass, arg);
 			}
 		}
 		return (arg instanceof Class ? (Class) arg : Object.class);
diff --git a/spring-core/src/test/java/org/springframework/core/GenericTypeResolverTests.java b/spring-core/src/test/java/org/springframework/core/GenericTypeResolverTests.java
@@ -19,15 +19,13 @@
 import java.lang.reflect.Method;
 import java.lang.reflect.Type;
 import java.lang.reflect.TypeVariable;
-
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
 
 import org.junit.Test;
 
 import static org.junit.Assert.*;
-
 import static org.springframework.core.GenericTypeResolver.*;
 import static org.springframework.util.ReflectionUtils.*;
 
@@ -79,7 +77,6 @@ public void methodReturnTypes() {
 	 */
 	@Test
 	public void genericMethodReturnTypes() {
-
 		Method notParameterized = findMethod(MyTypeWithMethods.class, "notParameterized", new Class[] {});
 		assertEquals(String.class, resolveReturnTypeForGenericMethod(notParameterized, new Object[] {}));
 
@@ -156,6 +153,11 @@ public void testResolveType() {
 		assertEquals(Integer[].class, resolveType(genericArrMessageMethodParam.getGenericParameterType(), varMap));
 	}
 
+	@Test
+	public void testBoundParameterizedType() {
+		assertEquals(B.class, resolveTypeArgument(TestImpl.class, ITest.class));
+	}
+
 
 	public interface MyInterfaceType<T> {
 	}
@@ -273,4 +275,13 @@ public static class MySimpleTypeWithMethods extends MyTypeWithMethods<Integer> {
 	static class GenericClass<T> {
 	}
 
+	class A{}
+
+	class B<T>{}
+
+	class ITest<T>{}
+
+	class TestImpl<I extends A, T extends B<I>> extends ITest<T>{
+	}
+
 }

Original file line number	Diff line number	Diff line change
`@@ -305,7 +305,7 @@ else if (ifc != null && genericIfc.isAssignableFrom((Class) ifc)) {`
`305`	`305`	`}`
`306`	`306`
`307`	`307`	`/**`
`308`		`- * Extract a class instance from given Type.`
	`308`	`+ * Extract a Class from the given Type.`
`309`	`309`	`*/`
`310`	`310`	`private static Class<?> extractClass(Class<?> ownerClass, Type arg) {`
`311`	`311`	`if (arg instanceof ParameterizedType) {`
`@@ -322,9 +322,12 @@ else if (arg instanceof TypeVariable) {`
`322`	`322`	`arg = getTypeVariableMap(ownerClass).get(tv);`
`323`	`323`	`if (arg == null) {`
`324`	`324`	`arg = extractBoundForTypeVariable(tv);`
	`325`	`+ if (arg instanceof ParameterizedType) {`
	`326`	`+ return extractClass(ownerClass, ((ParameterizedType) arg).getRawType());`
	`327`	`+ }`
`325`	`328`	`}`
`326`	`329`	`else {`
`327`		`- arg = extractClass(ownerClass, arg);`
	`330`	`+ return extractClass(ownerClass, arg);`
`328`	`331`	`}`
`329`	`332`	`}`
`330`	`333`	`return (arg instanceof Class ? (Class) arg : Object.class);`