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 for ResolvableType.getType().getTypeName() on Java 8 

Issue: SPR-16535
This commit is contained in:
Juergen Hoeller 2018-02-26 17:19:12 +01:00
parent c2d5ca9811
commit 6663d0ff07
2 changed files with 54 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
spring-core/src/main/java/org/springframework/core/ResolvableType.java
View File

@ -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();
}
}

65
spring-core/src/test/java/org/springframework/core/ResolvableTypeTests.java
View File

@ -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(1).resolve(), equalTo((Class)List.class));
assertThat(t.getGeneric(0).resolve(), equalTo(Integer.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) {
return new AssertAssignbleMatcher() {
@Override
public void equalTo(boolean... values) {
for (int i = 0; i < fromTypes.length; i++) {
assertThat(stringDesc(type) + " isAssignableFrom " + stringDesc(fromTypes[i]),
type.isAssignableFrom(fromTypes[i]), Matchers.equalTo(values[i]));
}
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));
}
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]), 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);
}