root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 8 Packages Projects Releases Wiki Activity

Support GenericArrayType in GenericTypeResolver method 

Before this change GenericTypeResolver.resolveType supported
TypeVariable's and ParameterizedType's only. Now it also supports
GenericArrayType.
This commit is contained in:
Rossen Stoyanchev 2012-11-21 13:23:02 -05:00
parent 0e2904b71a
commit b36ab83ab3
2 changed files with 44 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
spring-core/src/main/java/org/springframework/core/GenericTypeResolver.java
View File

@ -371,8 +371,13 @@ public abstract class GenericTypeResolver {
* @return the type if it resolves to a Class, or <code>Object.class</code> otherwise * @return the type if it resolves to a Class, or <code>Object.class</code> otherwise
*/ */
public static Class<?> resolveType(Type genericType, Map<TypeVariable, Type> typeVariableMap) { public static Class<?> resolveType(Type genericType, Map<TypeVariable, Type> typeVariableMap) {
Type rawType = getRawType(genericType, typeVariableMap); Type resolvedType = getRawType(genericType, typeVariableMap);
return (rawType instanceof Class ? (Class) rawType : Object.class); if (resolvedType instanceof GenericArrayType) {
Type componentType = ((GenericArrayType) resolvedType).getGenericComponentType();
Class<?> componentClass = resolveType(componentType, typeVariableMap);
resolvedType = Array.newInstance(componentClass, 0).getClass();
}
return (resolvedType instanceof Class ? (Class) resolvedType : Object.class);
} }
/** /**

36
spring-core/src/test/java/org/springframework/core/GenericTypeResolverTests.java
View File

@ -17,6 +17,8 @@
package org.springframework.core; package org.springframework.core;
import java.lang.reflect.Method; import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.Collection; import java.util.Collection;
import java.util.HashMap; import java.util.HashMap;
@ -128,6 +130,27 @@ public class GenericTypeResolverTests {
assertEquals(Object.class, resolveReturnTypeForGenericMethod(extractMagicValue, new Object[] { map })); assertEquals(Object.class, resolveReturnTypeForGenericMethod(extractMagicValue, new Object[] { map }));
} }
/**
* @since 3.2
*/
@Test
public void testResolveType() {
Method intMessageMethod = findMethod(MyTypeWithMethods.class, "readIntegerInputMessage", MyInterfaceType.class);
MethodParameter intMessageMethodParam = new MethodParameter(intMessageMethod, 0);
assertEquals(MyInterfaceType.class,
resolveType(intMessageMethodParam.getGenericParameterType(), new HashMap<TypeVariable, Type>()));
Method intArrMessageMethod = findMethod(MyTypeWithMethods.class, "readIntegerArrayInputMessage", MyInterfaceType[].class);
MethodParameter intArrMessageMethodParam = new MethodParameter(intArrMessageMethod, 0);
assertEquals(MyInterfaceType[].class,
resolveType(intArrMessageMethodParam.getGenericParameterType(), new HashMap<TypeVariable, Type>()));
Method genericArrMessageMethod = findMethod(MySimpleTypeWithMethods.class, "readGenericArrayInputMessage", Object[].class);
MethodParameter genericArrMessageMethodParam = new MethodParameter(genericArrMessageMethod, 0);
Map<TypeVariable, Type> varMap = getTypeVariableMap(MySimpleTypeWithMethods.class);
assertEquals(Integer[].class, resolveType(genericArrMessageMethodParam.getGenericParameterType(), varMap));
}
public interface MyInterfaceType<T> { public interface MyInterfaceType<T> {
} }
@ -147,7 +170,7 @@ public class GenericTypeResolverTests {
public class MyCollectionSuperclassType extends MySuperclassType<Collection<String>> { public class MyCollectionSuperclassType extends MySuperclassType<Collection<String>> {
} }
public static class MyTypeWithMethods { public static class MyTypeWithMethods<T> {
public MyInterfaceType<Integer> integer() { return null; } public MyInterfaceType<Integer> integer() { return null; }
public MySimpleInterfaceType string() { return null; } public MySimpleInterfaceType string() { return null; }
public Object object() { return null; } public Object object() { return null; }
@ -211,6 +234,17 @@ public class GenericTypeResolverTests {
return null; return null;
} }
public void readIntegerInputMessage(MyInterfaceType<Integer> message) {
}
public void readIntegerArrayInputMessage(MyInterfaceType<Integer>[] message) {
}
public void readGenericArrayInputMessage(T[] message) {
}
}
public static class MySimpleTypeWithMethods extends MyTypeWithMethods<Integer> {
} }
static class GenericClass<T> { static class GenericClass<T> {