Provide 'with implementationType' overloads on ResolvableType [SPR-11218]

[spring-projects-issues]

Bruce Brouwer opened SPR-11218 and commented

Add another method to ResolvableType with a signature something like this:

public static ResolvableType forField(Field field, 
    ResolvableType implementationType)

In this way I can use it to resolve a field where the field is a generic field and the implementingClass is generic.

public class MyType<T> {
  public T field;
}

This is roughly the code I would want to use:

ResolvableType type = ResolvableType.forClassWithGenerics(MyType.class, 
    ResolvableType.forClass(String.class));
Field f = MyType.class.getField("field");
ResolvableType field = ResolvableType.forField(f, type);
System.out.println(field); // I want it to print java.lang.String

If there is another, easier way to do this, I would love to hear what it is. I would possibly like to use this to replace a utility class that I wrote that does basically the same thing as ResolvableType.

---

Affects: 4.0 GA

Referenced from: commits 9076c70

[spring-projects-issues]

Juergen Hoeller commented

Phil, since this would involve quite a few overloaded methods if we did it consistently: Is there an alternative way of achieving this? Could we provide a way to get there without duplicating a ton of methods on ResolvableType?

Juergen

[spring-projects-issues]

Bruce Brouwer commented

What I did for my utility that I wrote, my ResolvableType actually implemented java.lang.reflect.Type. Now, maybe it is taboo to invent new things that implement Type, but that is what I did. Once I did this, all the method signatures that I had in my utility simply took a java.lang.reflect.Type instead of java.lang.Class. That does, however, open up possibilities of users passing in other things that implement Type, such as ParameterizedType, WildcardType, ...

Sometimes it doesn't always make sense, in which case I would simply throw an IllegalArgumentException. For example, if I passed in a WildcardType to ResolvableType.forField(field, wildcardType), I could expect an IllegalArgumentException.

Maybe my idea complicates things more than they need to be, but I just wanted to offer it as an idea.

[spring-projects-issues]

Phil Webb commented

I have added overloaded methods for Field and MethodParameter. Since we don't want an explosion of additional methods for a fairly exotic use-case I won't add overloads for all the Method variants since you can always create a MethodParamter yourself.

Here are some examples of use:

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

Lines 662 to 670 in 9076c70

	@Test
	public void resolveTypeVariableFromFieldTypeWithImplementsType() throws Exception {
	ResolvableType implementationType = ResolvableType.forClassWithGenerics(
	Fields.class, Integer.class);
	ResolvableType type = ResolvableType.forField(
	Fields.class.getField("parameterizedType"), implementationType);
	assertThat(type.resolve(), equalTo((Class) List.class));
	assertThat(type.getGeneric().resolve(), equalTo((Class) Integer.class));
	}

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

Lines 748 to 756 in 9076c70

	@Test
	public void resolveTypeVariableFromMethodParameterTypeWithImplementsType() throws Exception {
	Method method = Methods.class.getMethod("typedParameter", Object.class);
	MethodParameter methodParameter = MethodParameter.forMethodOrConstructor(method, 0);
	ResolvableType implementationType = ResolvableType.forClassWithGenerics(Methods.class, Integer.class);
	ResolvableType type = ResolvableType.forMethodParameter(methodParameter, implementationType);
	assertThat(type.resolve(), equalTo((Class) Integer.class));
	assertThat(type.getType().toString(), equalTo("T"));
	}