Consider adding support for contextual converters

[NicklasWallgren]

It would be useful if we could access contextual information during the conversion of a request parameter (or similar). That would allow us to influence the conversion result based on for example annotations present at the usage site.

Both Jackson and Hibernate offer comparable mechanisms for this:

• Jackson via ContextualSerializer (now deprecated, with the functionality included into ValueSerializer)
• Hibernate via DynamicParameterizedType (also deprecated, with the functionality now built directly into UserType)

Example

@RestController
static class ExampleController {
    @RequestMapping(value = "/v1/10-digit-ssn", method = RequestMethod.GET)
    public void tenDigitSsn(@RequestParam(name = "ssn") @SSNFormat(length=10) SSN tenDigitSsn) {}

    @RequestMapping(value = "/v1/12-digit-ssn", method = RequestMethod.GET)
    public void twelveDigitSsn(@RequestParam(name = "ssn") @SSNFormat(length=12) SSN twelveDigitSsn) {}
}

What is possible using Jackson;

record Response(@SsnFormat(as = Type.INTEGER) SSN ssn) {}

What is possible using Hibernate;

@SSNFormat(as = Type.INTEGER)
@Column(name = "ssn")
SSN ssn;

[bclozel]

Thanks for reaching out.

I'm not sure I understand the requested enhancement here. Spring Framework does support Jackson and Hibernate and I don't think we're getting in the way of those features right now.

Instead of comparing to other libraries, can you explain what you would like to achieve, how you're trying to implement this and what result you are getting instead? Thanks

[NicklasWallgren]

I have a set of value classes that I want to use consistently throughout the entire stack, from the API layer down to the persistence layer.

With Jackson and Hibernate, I can control parts of the serialization and deserialization process using custom annotations, which allows me to reuse the same ValueSerializer and UserType implementations.

I'd like the same level of flexibility when using Spring converters. For example, consider a simple value class, SSN, used as a request parameter. In some endpoints I want to accept only 12-character values, while in others only 10-character values.

Today it isn't possible to create such a converter. I could potentially set up a WebDataBinder per endpoint or introduce wrapper types around each value class, but it would be useful to provide some form of contextual converter to make the conversion a bit more flexible and dynamic.

public static class SsnConverter implements ContextualConverter<String, Ssn> {
    @Override
    public Ssn convert(String source, ConversionContext context) {
        var property = context.getProperty() // from usage site

        var nullableAnnotation = property.getAnnotation(SsnFormat.class);

        // ....

        return Ssn.ofStringAndContext(source, new SsnConstraints(nullableAnnotation.allowedLength()));
    }
}

@Value
public static class Ssn {
    public static final int DEFAULT_LENGTH = 12;

    String ssn; // always 12 characters in length
    SsnConstraints context;

    private Ssn(String ssn, SsnConstraints context) {
        this.ssn = ssn; // apply magic to derive the two "missing" characters, in case of 10 digit.
        this.context = context;

        validateSelf();
    }

    public static Ssn ofString(String value) {
        return new Ssn(value, new SsnConstraints(DEFAULT_LENGTH));
    }

    public static Ssn ofStringAndContext(String value, SsnConstraints context) {
        return new Ssn(value, context);
    }

    private void validateSelf() {
        // validate length
        // validate checksum....
        // validate ....
    }

    public record SsnConstraints(int allowedLength) {}
}