diff --git a/spring-core/src/main/java/org/springframework/core/GenericTypeResolver.java b/spring-core/src/main/java/org/springframework/core/GenericTypeResolver.java
index 1156f8ebdf3..0320381d0ca 100644
--- a/spring-core/src/main/java/org/springframework/core/GenericTypeResolver.java
+++ b/spring-core/src/main/java/org/springframework/core/GenericTypeResolver.java
@@ -371,8 +371,13 @@ public abstract class GenericTypeResolver {
 	 * @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) {
-		Type rawType = getRawType(genericType, typeVariableMap);
-		return (rawType instanceof Class ? (Class) rawType : Object.class);
+		Type resolvedType = getRawType(genericType, typeVariableMap);
+		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);
 	}
 
 	/**
diff --git a/spring-core/src/test/java/org/springframework/core/GenericTypeResolverTests.java b/spring-core/src/test/java/org/springframework/core/GenericTypeResolverTests.java
index 344dcef5418..cdb201c6025 100644
--- a/spring-core/src/test/java/org/springframework/core/GenericTypeResolverTests.java
+++ b/spring-core/src/test/java/org/springframework/core/GenericTypeResolverTests.java
@@ -17,6 +17,8 @@
 package org.springframework.core;
 
 import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
 
 import java.util.Collection;
 import java.util.HashMap;
@@ -128,6 +130,27 @@ public class GenericTypeResolverTests {
 		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> {
 	}
@@ -147,7 +170,7 @@ public class GenericTypeResolverTests {
 	public class MyCollectionSuperclassType extends MySuperclassType<Collection<String>> {
 	}
 
-	public static class MyTypeWithMethods {
+	public static class MyTypeWithMethods<T> {
 		public MyInterfaceType<Integer> integer() { return null; }
 		public MySimpleInterfaceType string() { return null; }
 		public Object object() { return null; }
@@ -166,7 +189,7 @@ public class GenericTypeResolverTests {
 
 		/**
 		 * Similar to {@link #createProxy(Object)} but adds an additional argument
-		 * before the argument of type {@code T}. Note that they may potentially 
+		 * before the argument of type {@code T}. Note that they may potentially
 		 * be of the same time when invoked!
 		 */
 		public static <T> T createNamedProxy(String name, T object) {
@@ -181,7 +204,7 @@ public class GenericTypeResolverTests {
 		}
 
 		/**
-		 * Similar to {@link #createMock(Class)} but adds an additional method 
+		 * Similar to {@link #createMock(Class)} but adds an additional method
 		 * argument before the parameterized argument.
 		 */
 		public static <T> T createNamedMock(String name, Class<T> toMock) {
@@ -211,6 +234,17 @@ public class GenericTypeResolverTests {
 			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> {