Content Negotiation in Spring Boot with Kotlin

Welcome to this lesson on Content Negotiation in Spring Boot! In the previous lessons, we focused on validating request data and handling exceptions, essential skills for building robust RESTful APIs. Today, we'll delve into content negotiation — a vital aspect that allows your API to serve responses in different formats, such as JSON and XML, based on the client's request.

Content negotiation is crucial when you want a single endpoint to serve results in various formats. This is particularly useful when different clients use your public endpoint and prefer different response formats. For example, mobile applications may request JSON, while legacy systems might require XML. In this lesson, we'll cover content negotiation for XML and JSON formats in Spring Boot. Other formats, such as YAML, plain text, and PDF, can also be supported by adding the appropriate dependencies and configurations.

Here is an example of a TodoItem object returned in JSON format:

{
    "id": 1,
    "title": "Read book",
    "description": "Read the first chapter of 'Effective Java'"
}

And here is the same TodoItem object returned in XML format:

<TodoItem>
    <id>1</id>
    <title>Read book</title>
    <description>Read the first chapter of 'Effective Java'</description>
</TodoItem>

First, let's add the necessary dependencies to our build.gradle.kts script:

implementation("com.fasterxml.jackson.dataformat:jackson-dataformat-xml")
implementation("jakarta.xml.bind:jakarta.xml.bind-api:3.0.1")

• jackson-dataformat-xml: This dependency includes the necessary components for serializing and deserializing XML data using Jackson.
• jakarta.xml.bind-api: This dependency provides the Jakarta XML Binding API, which is used for converting objects to XML and vice versa.

To enable content negotiation, you'll need to adjust your controller methods in Kotlin. Instead of using semantic annotations like @GetMapping, you'll use @RequestMapping to explicitly specify the supported media types.

Here's a code snippet for our TodoItemController:

package com.codesignal

import org.springframework.http.MediaType
import org.springframework.web.bind.annotation.PathVariable
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RequestMethod
import org.springframework.web.bind.annotation.RestController

@RestController
class TodoItemController(private val todoItemRepository: TodoItemRepository) {

    @RequestMapping(
        value = ["/{id}"],
        method = [RequestMethod.GET],
        produces = [MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE]
    )
    fun getTodoItemById(@PathVariable id: Int): TodoItem {
        return todoItemRepository.findById(id).orElseThrow { NoSuchElementException("Todo item with id $id not found") }
    }
}

The code block demonstrates a controller method supporting content negotiation:

• We replaced @GetMapping with @RequestMapping to enable defining the produces attribute.
• The produces field specifies the supported media types for the endpoint. Here, it is set to [MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE], allowing responses in both JSON and XML formats.
• By supporting multiple media types, the server can return responses in the requested format, based on the client's preference.

These changes enable content negotiation by allowing the server to serve responses in various formats according to client specifications.