Content type negotiation in Spring Boot

Introduction

Content type negotiation helps your app decide what format to send data in, like JSON or XML, based on what the user or client wants.

When your API needs to support multiple response formats like JSON and XML.

When different clients (web browsers, mobile apps) expect data in different formats.

When you want to make your REST API flexible and user-friendly.

When you want to automatically handle 'Accept' headers from HTTP requests.

When you want to avoid writing separate endpoints for each data format.

Syntax

Spring Boot

In Spring Boot, content type negotiation is often handled automatically by using @RestController and returning objects.

You can also configure it with:

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
        configurer.favorParameter(true)
                  .parameterName("format")
                  .ignoreAcceptHeader(false)
                  .defaultContentType(MediaType.APPLICATION_JSON)
                  .mediaType("json", MediaType.APPLICATION_JSON)
                  .mediaType("xml", MediaType.APPLICATION_XML);
    }
}

Spring Boot automatically supports JSON if Jackson is on the classpath.

You can customize content negotiation by overriding configureContentNegotiation in a WebMvcConfigurer.

Examples

This simple controller returns data. Spring Boot sends JSON by default if the client accepts JSON.

Spring Boot

@RestController
public class MyController {
    @GetMapping("/data")
    public MyData getData() {
        return new MyData("Hello", 123);
    }
}

This config allows clients to add '?format=xml' or '?format=json' to URLs to choose the response format.

Spring Boot

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
        configurer.favorParameter(true)
                  .parameterName("format")
                  .ignoreAcceptHeader(true)
                  .defaultContentType(MediaType.APPLICATION_JSON)
                  .mediaType("json", MediaType.APPLICATION_JSON)
                  .mediaType("xml", MediaType.APPLICATION_XML);
    }
}

This method forces XML output regardless of client request headers.

Spring Boot

@RestController
public class MyController {
    @GetMapping(value = "/data", produces = MediaType.APPLICATION_XML_VALUE)
    public MyData getDataXml() {
        return new MyData("Hello", 123);
    }
}

Sample Program

This Spring Boot app has one endpoint '/data' that returns a simple record. The config allows clients to request JSON or XML by adding '?format=json' or '?format=xml' to the URL or by setting the Accept header.

Spring Boot

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.config.annotation.ContentNegotiationConfigurer;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

@Configuration
class WebConfig implements WebMvcConfigurer {
    @Override
    public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
        configurer.favorParameter(true)
                  .parameterName("format")
                  .ignoreAcceptHeader(false)
                  .defaultContentType(MediaType.APPLICATION_JSON)
                  .mediaType("json", MediaType.APPLICATION_JSON)
                  .mediaType("xml", MediaType.APPLICATION_XML);
    }
}

@RestController
class MyController {
    record MyData(String message, int number) {}

    @GetMapping("/data")
    public MyData getData() {
        return new MyData("Hello, world!", 42);
    }
}

Important Notes

Content negotiation uses HTTP headers like Accept or URL parameters to decide response format.

Always test your API with different Accept headers or URL parameters to see the format change.

Make sure you have the right libraries (like Jackson for JSON, JAXB for XML) in your project.

Summary

Content type negotiation lets your app send data in the format the client wants.

Spring Boot supports this automatically but you can customize it with WebMvcConfigurer.

You can use URL parameters or HTTP headers to control the response format.

Practice

1. What is the main purpose of content type negotiation in Spring Boot?

easy

A. To send data in the format the client prefers

B. To secure the application from unauthorized access

C. To speed up database queries

D. To manage user sessions automatically

Solution

1. Step 1: Understand content type negotiation concept

   Content type negotiation allows the server to send data in different formats like JSON or XML based on what the client requests.

2. Step 2: Identify the main purpose in Spring Boot

   Spring Boot uses content type negotiation to automatically choose the response format that matches the client's preference.

3. Final Answer:

   To send data in the format the client prefers -> Option A

4. Quick Check:

   Content type negotiation = send preferred format [OK]

Hint: Remember: negotiation means choosing the client's format [OK]

Common Mistakes:

• Confusing content type negotiation with security features
• Thinking it speeds up database queries
• Assuming it manages user sessions

2. Which of the following is the correct way to specify JSON response in a Spring Boot controller method?

easy

A. @GetMapping(value = "/data", consumes = "application/json")

B. @GetMapping(value = "/data", produces = "application/json")

C. @PostMapping(value = "/data", produces = "text/html")

D. @RequestMapping(value = "/data", method = GET, consumes = "text/plain")

Solution

1. Step 1: Understand 'produces' vs 'consumes'

   'produces' defines the response content type; 'consumes' defines the request content type.

2. Step 2: Identify correct annotation for JSON response

   @GetMapping with produces = "application/json" tells Spring Boot to send JSON data in response.

3. Final Answer:

   @GetMapping(value = "/data", produces = "application/json") -> Option B

4. Quick Check:

   produces = JSON means response is JSON [OK]

Hint: Use 'produces' to set response format [OK]

Common Mistakes:

• Mixing 'consumes' with response content type
• Using wrong HTTP method annotation
• Setting produces to unrelated content types

3. Given this Spring Boot controller method:

@GetMapping(value = "/info", produces = {"application/json", "application/xml"})
public Data getInfo() {
    return new Data("Spring", 5);
}

What will happen if the client sends an HTTP Accept header with value application/xml?

medium

A. The server responds with JSON format

B. The server ignores the Accept header and sends plain text

C. The server returns a 406 Not Acceptable error

D. The server responds with XML format

Solution

1. Step 1: Check the produces attribute

   The method supports both JSON and XML response formats as per the produces array.

2. Step 2: Match client Accept header with produces

   The client requests 'application/xml', which is supported, so Spring Boot will respond with XML.

3. Final Answer:

   The server responds with XML format -> Option D

4. Quick Check:

   Accept header matches produces = XML response [OK]

Hint: Response matches Accept header if supported [OK]

Common Mistakes:

• Assuming JSON is always returned
• Thinking 406 error occurs if multiple produces are set
• Ignoring the Accept header

4. Consider this Spring Boot configuration snippet:

@Override
public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
    configurer.favorParameter(true)
              .parameterName("format")
              .defaultContentType(MediaType.APPLICATION_JSON)
              .mediaType("xml", MediaType.APPLICATION_XML)
              .mediaType("json", MediaType.APPLICATION_JSON);
}

What is the likely problem if a client requests /api/data?format=txt?

medium

A. The server will throw an error due to unknown format

B. The server will respond with XML format

C. The server will respond with JSON as default

D. The server will ignore the format parameter and respond with plain text

Solution

1. Step 1: Analyze configured media types

   Only 'json' and 'xml' are mapped to media types; 'txt' is not recognized.

2. Step 2: Check default content type behavior

   If the parameter value is unknown, Spring Boot falls back to the default content type, which is JSON here.

3. Final Answer:

   The server will respond with JSON as default -> Option C

4. Quick Check:

   Unknown format uses default JSON [OK]

Hint: Unknown format falls back to default content type [OK]

Common Mistakes:

• Expecting an error for unknown format
• Assuming XML is default
• Thinking plain text is sent automatically

5. You want to customize content negotiation in Spring Boot so that clients can request response format via URL parameter ?type= instead of the default ?format=. Which code snippet correctly achieves this?

hard

A. configurer.favorParameter(true).parameterName("type").defaultContentType(MediaType.APPLICATION_JSON);

B. configurer.favorParameter(false).parameterName("type").defaultContentType(MediaType.APPLICATION_JSON);

C. configurer.favorParameter(true).parameterName("format").defaultContentType(MediaType.APPLICATION_XML);

D. configurer.favorParameter(true).parameterName("type").defaultContentType(MediaType.TEXT_PLAIN);

Solution

1. Step 1: Enable parameter-based content negotiation

   Set favorParameter(true) to allow URL parameter control.

2. Step 2: Change parameter name to 'type'

   Use parameterName("type") to listen for '?type=' instead of default '?format='.

3. Step 3: Set default content type to JSON

   defaultContentType(MediaType.APPLICATION_JSON) ensures JSON if no parameter is given.

4. Final Answer:

   configurer.favorParameter(true).parameterName("type").defaultContentType(MediaType.APPLICATION_JSON); -> Option A

5. Quick Check:

   favorParameter + parameterName = custom URL param [OK]

Hint: Set favorParameter true and parameterName to customize URL param [OK]

Common Mistakes:

• Disabling favorParameter disables URL param negotiation
• Using wrong parameter name
• Setting inappropriate default content type