CODEWITHSUNDEEP
spring-bootspring-mvc
UncleBob
UncleBob

Reputation: 1391

Polymorphic @RequestBody in Spring-Boot

The problem's pretty straightforward. I have a couple of events that derive from the same interface, and I'd like to deserialize them to their propper super-class.

I know how to do that with an object mapper, but using my own mapper would mean letting Spring-Boot parse the @RequestBody as a String and then doing it myself, which isn't the worlds end, but I can't help but suspect that Spring provides proper tools to handle this kind of situation. Trouble is, I can't seem to find them.

Here's a bit of sample code:

example event:

interface YellowOpsEvent {
    val user: String
    val partner: String
    val subject: String
    val change: NatureOfChange
}

data class StatusChangedEvent(override val user: String,
                              override val partner: String,
                              override val subject: String,
                              val before: String,
                              val after: String): YellowOpsEvent {
    override val change = NatureOfChange.Changed
}

controller:

@PostMapping("/event")
    fun writeEvent(@RequestBody event: YellowOpsEvent) {  // < I expect this not to throw an exception
        val bugme = event is StatusChangedEvent // < I expect this to return true if I send the proper event data.
    }

Just to clarify, I perfectly understand why this doesn't work out of the box. The trouble is, I can't find out what I need to do to make it work.

Upvotes: 4

Views: 2682

Answers (1)

UncleBob
UncleBob

Reputation: 1391

The link in pL4Gu33's comment lead me in the right direction, but it took some additional searching and fiddling, plucking information from here and there to arrive at the solution that would finally work, so I'm summarising it here for completeness.

The trouble is that you'll need two annotations, one on the interface and one on the implementing classes, the combined use of which seems somewhat ill-documented. First, on the interface, add this annotation. Contrary to some tutorials you will find, no further annotation of the interface is required:

@JsonTypeInfo(use=JsonTypeInfo.Id.CLASS, include=JsonTypeInfo.As.PROPERTY, property="@class")
interface YellowOpsEvent {
    val user: String
    val partner: String
    val subject: String
    val change: NatureOfChange
}

According to some documentation, this alone should be enough for propper deserialisation. The spring-boot controller, however, will throw an exception because the passed root name does not match the class it was expecting.

// the above will throw an exception when the serialization product is sent to this controller:

    @PostMapping("/event")
        fun writeEvent(@RequestBody event: YellowOpsEvent) {  // < I expect this not to throw an exception
            val bugme = event is StatusChangedEvent // < I expect this to return true if I send the proper event data.
        }

To fix that, add the @JsonRootName annotation to any implementing classes, with the interface's name. Most documentation of this annotation don't use it for this, instead just for renaming the type, and even when it's mentioned in the linked question in the context of polymorphism, it wrongly uses its own name. This is what it needs to look like:

@JsonRootName("YellowOpsEvent")
data class StatusChangedEvent(override val user: String,
                              override val partner: String,
                              override val subject: String,
                              val before: String,
                              val after: String): YellowOpsEvent {
    override val change = NatureOfChange.Changed
}

Now it works! :)

Upvotes: 3

Related Questions