Support for ResolvableType.getType().getTypeName() on Java 8

Issue: SPR-16535

spring-core/src/main/java/org/springframework/core/ResolvableType.java

@@ -1495,6 +1495,22 @@ public class ResolvableType implements Serializable {
 			this.typeArguments = typeArguments;
 		}
 
+		@Override
+		public String getTypeName() {
+			StringBuilder result = new StringBuilder(this.rawType.getTypeName());
+			if (this.typeArguments.length > 0) {
+				result.append('<');
+				for (int i = 0; i < this.typeArguments.length; i++) {
+					if (i > 0) {
+						result.append(", ");
+					}
+					result.append(this.typeArguments[i].getTypeName());
+				}
+				result.append('>');
+			}
+			return result.toString();
+		}
+
 		@Override
 		@Nullable
 		public Type getOwnerType() {
@@ -1528,6 +1544,11 @@ public class ResolvableType implements Serializable {
 		public int hashCode() {
 			return (this.rawType.hashCode() * 31 + Arrays.hashCode(this.typeArguments));
 		}
+
+		@Override
+		public String toString() {
+			return getTypeName();
+		}
 	}
 
 

spring-core/src/test/java/org/springframework/core/ResolvableTypeTests.java

@@ -42,7 +42,6 @@ import java.util.SortedSet;
 import java.util.TreeSet;
 import java.util.concurrent.Callable;
 
-import org.hamcrest.Matchers;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
@@ -944,16 +943,6 @@ public class ResolvableTypeTests {
 		assertThat(ResolvableType.forClass(classType).getSuperType().getSource(), equalTo((Object) classType.getGenericSuperclass()));
 	}
 
-	private void assertFieldToStringValue(String field, String expected) throws Exception {
-		ResolvableType type = ResolvableType.forField(Fields.class.getField(field));
-		assertThat("field " + field + " toString", type.toString(), equalTo(expected));
-	}
-
-	private void assertTypedFieldToStringValue(String field, String expected) throws Exception {
-		ResolvableType type = ResolvableType.forField(Fields.class.getField(field), TypedFields.class);
-		assertThat("field " + field + " toString", type.toString(), equalTo(expected));
-	}
-
 	@Test
 	public void resolveFromOuterClass() throws Exception {
 		Field field = EnclosedInParameterizedType.InnerTyped.class.getField("field");
@@ -971,7 +960,6 @@ public class ResolvableTypeTests {
 		assertThat(type.asCollection().getGeneric().getGeneric().resolve(), equalTo((Type) String.class));
 	}
 
-
 	@Test
 	public void isAssignableFromMustNotBeNull() throws Exception {
 		this.thrown.expect(IllegalArgumentException.class);
@@ -1206,18 +1194,18 @@ public class ResolvableTypeTests {
 		assertThat(forFieldDirect, not(equalTo(forFieldWithImplementation)));
 	}
 
-	@SuppressWarnings("unused")
-	private HashMap<Integer, List<String>> myMap;
-
 	@Test
 	public void javaDocSample() throws Exception {
 		ResolvableType t = ResolvableType.forField(getClass().getDeclaredField("myMap"));
+		assertThat(t.toString(), equalTo("java.util.HashMap<java.lang.Integer, java.util.List<java.lang.String>>"));
+		assertThat(t.getType().getTypeName(), equalTo("java.util.HashMap<java.lang.Integer, java.util.List<java.lang.String>>"));
+		assertThat(t.getType().toString(), equalTo("java.util.HashMap<java.lang.Integer, java.util.List<java.lang.String>>"));
 		assertThat(t.getSuperType().toString(), equalTo("java.util.AbstractMap<java.lang.Integer, java.util.List<java.lang.String>>"));
 		assertThat(t.asMap().toString(), equalTo("java.util.Map<java.lang.Integer, java.util.List<java.lang.String>>"));
-		assertThat(t.getGeneric(0).resolve(), equalTo((Class)Integer.class));
+		assertThat(t.getGeneric(0).resolve(), equalTo(Integer.class));
-		assertThat(t.getGeneric(1).resolve(), equalTo((Class)List.class));
+		assertThat(t.getGeneric(1).resolve(), equalTo(List.class));
 		assertThat(t.getGeneric(1).toString(), equalTo("java.util.List<java.lang.String>"));
-		assertThat(t.resolveGeneric(1, 0), equalTo((Class) String.class));
+		assertThat(t.resolveGeneric(1, 0), equalTo(String.class));
 	}
 
 	@Test
@@ -1225,6 +1213,8 @@ public class ResolvableTypeTests {
 		ResolvableType elementType = ResolvableType.forClassWithGenerics(Map.class, Integer.class, String.class);
 		ResolvableType listType = ResolvableType.forClassWithGenerics(List.class, elementType);
 		assertThat(listType.toString(), equalTo("java.util.List<java.util.Map<java.lang.Integer, java.lang.String>>"));
+		assertThat(listType.getType().getTypeName(), equalTo("java.util.List<java.util.Map<java.lang.Integer, java.lang.String>>"));
+		assertThat(listType.getType().toString(), equalTo("java.util.List<java.util.Map<java.lang.Integer, java.lang.String>>"));
 	}
 
 	@Test
@@ -1245,7 +1235,7 @@ public class ResolvableTypeTests {
 		ResolvableType elementType = ResolvableType.forField(Fields.class.getField("stringList"));
 		ResolvableType type = ResolvableType.forArrayComponent(elementType);
 		assertThat(type.toString(), equalTo("java.util.List<java.lang.String>[]"));
-		assertThat(type.resolve(), equalTo((Class) List[].class));
+		assertThat(type.resolve(), equalTo(List[].class));
 	}
 
 	@Test
@@ -1265,14 +1255,14 @@ public class ResolvableTypeTests {
 	@Test
 	public void canResolveVoid() throws Exception {
 		ResolvableType type = ResolvableType.forClass(void.class);
-		assertThat(type.resolve(), equalTo((Class) void.class));
+		assertThat(type.resolve(), equalTo(void.class));
 	}
 
 	@Test
 	public void narrow() throws Exception {
 		ResolvableType type = ResolvableType.forField(Fields.class.getField("stringList"));
 		ResolvableType narrow = ResolvableType.forType(ArrayList.class, type);
-		assertThat(narrow.getGeneric().resolve(), equalTo((Class) String.class));
+		assertThat(narrow.getGeneric().resolve(), equalTo(String.class));
 	}
 
 	@Test
@@ -1355,23 +1345,30 @@ public class ResolvableTypeTests {
 		ResolvableType read = (ResolvableType) ois.readObject();
 		assertThat(read, equalTo(type));
 		assertThat(read.getType(), equalTo(type.getType()));
-		assertThat(read.resolve(), equalTo((Class) type.resolve()));
+		assertThat(read.resolve(), equalTo(type.resolve()));
 		return read;
 	}
 
-	private static AssertAssignbleMatcher assertAssignable(final ResolvableType type, final ResolvableType... fromTypes) {
+	private void assertFieldToStringValue(String field, String expected) throws Exception {
-		return new AssertAssignbleMatcher() {
+		ResolvableType type = ResolvableType.forField(Fields.class.getField(field));
-			@Override
+		assertThat("field " + field + " toString", type.toString(), equalTo(expected));
-			public void equalTo(boolean... values) {
+	}
+
+	private void assertTypedFieldToStringValue(String field, String expected) throws Exception {
+		ResolvableType type = ResolvableType.forField(Fields.class.getField(field), TypedFields.class);
+		assertThat("field " + field + " toString", type.toString(), equalTo(expected));
+	}
+
+	private AssertAssignbleMatcher assertAssignable(final ResolvableType type, final ResolvableType... fromTypes) {
+		return values -> {
 			for (int i = 0; i < fromTypes.length; i++) {
 				assertThat(stringDesc(type) + " isAssignableFrom " + stringDesc(fromTypes[i]),
-							type.isAssignableFrom(fromTypes[i]), Matchers.equalTo(values[i]));
+						type.isAssignableFrom(fromTypes[i]), equalTo(values[i]));
-				}
 			}
 		};
 	}
 
-	private static String stringDesc(ResolvableType type) {
+	private String stringDesc(ResolvableType type) {
 		if (type == ResolvableType.NONE) {
 			return "NONE";
 		}
@@ -1382,7 +1379,11 @@ public class ResolvableTypeTests {
 	}
 
 
-	private static interface AssertAssignbleMatcher {
+	@SuppressWarnings("unused")
+	private HashMap<Integer, List<String>> myMap;
+
+
+	private interface AssertAssignbleMatcher {
 
 		void equalTo(boolean... values);
 	}