Is it possible to extend the default deserializers behavior through BeanDeserializerModifier?

[KasperWolsink99]

Hi all,

I am using Jackson with Kotlin and have some mechanism in place that deserializes JSON to Kotlin data classes.
This works fine, but what I am trying to do is extend the deserializer used in my context to first check if the JSON contains all non-nullable fields of the data class, and if it doesn't throw an exception containing all missing fields.

So, what I am trying to do is have some custom validation logic trigger just before deserialization.
I dug a bit, and came up with the following idea:

class RequiredFieldChecker : BeanDeserializerModifier() {
    override fun modifyDeserializer(
        config: DeserializationConfig,
        beanDesc: BeanDescription,
        deserializer: JsonDeserializer<*>
    ): JsonDeserializer<*> {
        val modifiedDeserializer = super.modifyDeserializer(config, beanDesc, deserializer)
        return object : JsonDeserializer<Any>() {
            override fun deserialize(parser: JsonParser, ctxt: DeserializationContext): Any {
                /*
                    Logic that checks if the JSON misses any of the required fields defined on beanDesc
                 */
                return modifiedDeserializer.deserialize(parser, ctxt)
            }
        }
    }
}

This however, does not work:

JSON parse error: Instantiation of [simple type, class <my-type>] value failed for JSON property entity due to missing (therefore NULL) value for creator parameter entity which is a non-nullable type

I have replaced my custom logic with a comment, this to illustrate that even omitting any logic and just simply returning a deserializer that delegates to modifiedDeserializer fails. Clearly wrapping the deserializer with a custom one is the wrong approach.

I am wondering why exactly this doesn't work, if I am on the right track or if I should consider a different way?

[cowtowncoder]

Use of BeanDeserializerModifier works in general but there are some subtleties. If you want to delegate, you also must implement ContextualDeserializer interface and delegate call (createContextual()) to default deserializer that you "wrap" (and use different deserializer instance if returned; construct new wrapping deserializer and return that).

Not all deserializers rely on ContextualDeserializer but BeanDeserializer specifically does (for applying annotations, for example).

Not sure if this is the issue you have, but it is a common problem.

[KasperWolsink99]

Thanks for the quick reply, unfortunately I get a different error this time:

JSON parse error: Cannot construct instance of <my-type> (although at least one Creator exists): cannot deserialize from Object value (no delegate- or property-based Creator)]

My wrapper:

class Wrapper(
    private val wrapped: JsonDeserializer<*>
) : JsonDeserializer<Any>(), ContextualDeserializer {
    
    override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Any {
        logger.info { "It works?" }
        return wrapped.deserialize(p, ctxt)
    }

    override fun createContextual(ctxt: DeserializationContext, property: BeanProperty): JsonDeserializer<*> {
        if (wrapped is ContextualDeserializer) {
            val contextual = wrapped.createContextual(ctxt, property)
            return Wrapper(contextual)
        }
        return this
    }
}

Could it be that my BeanDeserializerModifier somehow affects the deserialization mechanisms of other modules (i.e. the jackson-kotlin module)? How do different modules inter-opt?

When I read this code I expect my wrapper deserializer to have the exact same behavior as the wrapped desererialiser except for logging a statement that is. It doesn't seem to be the case though.

[cowtowncoder]

BeanDeserializerModifier can modify JsonDeserializers provided by any module, it's not limited to "default" deserializers.

At this point you probably want to file an issue on jackson-module-kotlin with full reproduction.