Make conversion framework extensible [SPR-11303]

[spring-projects-issues]

Stefan Gheorghiu opened SPR-11303 and commented

Changes implemented in #15515 still don't allow extending the conversion subsystem.

When I tried to port my earlier approach for 3.2.4, it turned out that method/class access is too severe. So, please make the following constructor protected rather than private:

TypeDescriptor(ResolvableType resolvableType, Class<?> type, Annotation[] annotations)

It would be good to make also fields type, resolvableType, annotations protected.

Class ResolvableType should not be final as well as its constructor should be protected.

Interfaces TypeProvider and VariableResolver should have protected or public access.

---

Affects: 4.0 GA

[spring-projects-issues]

Stefan Gheorghiu commented

My goal is to implement a custom TypeDescriptor that would keep extended type information extracted via Scala reflection from Java objects of types Field, MethodParameter, Property.

[spring-projects-issues]

Stefan Gheorghiu commented

My current workaround it to extend the TypeDescriptor via the MethodParameter-constructor by passing there a fake synthetic method. Then I hack private/final modifiers of fields type, resolvableType, annotations and initialize them using reflection. Though finally the approach works, it's not a proper way to interact with something that has the word "framework" in its name :-) Agree?

class ScalaTypeDescriptor(scalaType: TypeRef, ann: Array[Annotation] = Array.empty) extends TypeDescriptor(syntheticMethodParameter) {
  protected val _resolvableType = resolvableTypeField(this)
  protected val _type = typeField(this)
  protected val _annotations = annotationsField(this)
  protected val javaClass = ScalaTypeDescriptor.javaClass(scalaType)
  _annotations() = ann
  _resolvableType() = ResolvableType.forClass(javaClass)
  _type() = javaClass

  override def getSource = scalaType
}

object ScalaTypeDescriptor {
  val mirror = runtimeMirror(getClass.getClassLoader)

  def javaClass(scalaType: TypeRef): Class[_] = mirror.runtimeClass(scalaType)

  val fakeMethod = ReflectionUtils.findMethod(classOf[AnyRef], "equals", classOf[AnyRef])
  val syntheticMethodParameter = new MethodParameter(fakeMethod, 0)

  val resolvableTypeField = FieldAccessBreaker[ScalaTypeDescriptor, ResolvableType]("resolvableType")
  val typeField = FieldAccessBreaker[ScalaTypeDescriptor, Class[_]]("type")
  val annotationsField = FieldAccessBreaker[ScalaTypeDescriptor, Array[Annotation]]("annotations")
}

[spring-projects-issues]

Phil Webb commented

Hi Stefan,

I have update TypeDescriptor to change the constructor to protected. I have also provided a protected getResolvableType() method.

I am not 100% comfortable with some of the other changes that you would like...

It would be good to make also fields type, resolvableType, annotations protected.

We generally prefer not to expose fields and tend to keep them private. Those fields are also final and I would prefer to keep them so.

Class ResolvableType should not be final as well as its constructor should be protected.
Interfaces TypeProvider and VariableResolver should have protected or public access.

Currently ResolvableType is not really intended to be subclasses and it would be better if we could keep the TypeProvider and VariableResolver types internal in case we need to change them in the future.

I was hoping that the combination of TypeDescriptor.getResolvableType{} and ResolvableType.getSource() would be enough. Those methods should let you get back to the original Field or MethodParameter which you could hopefully use to get to the Scala information that you need.

Unfortunately I am not a Scala developer so I may well be missing something.

[spring-projects-issues]

Stefan Gheorghiu commented

The other changes were not actually required, as it turns out now. What you have done is quite enough. Thank you very much for your support.

[spring-projects-issues]

Phil Webb commented

Great, thanks!