1. Introduction

The content type indicates how to interpret the data present in the request/response. Whenever a controller receives a web request, it consumes or produces some media types. In this request-response model, several media types can be consumed/produced, and JSON is one of them.

In this quick tutorial, we’ll explore different ways to set the content type in Spring MVC with spring boot.

2. @RequestMapping in Spring

Simply put, @RequestMapping is an important annotation that maps web requests to a Spring controller. It has various attributes, including HTTP method, request parameters, headers, and media types.

Generally, media types fall into two categories: consumable and producible. In addition to these, we can also define a custom media type in Spring. The main purpose is to restrict the primary mapping to a list of media types for our request handler.

2.1. Consumable Media Type

With the consumes attribute, we can specify the media type that the controller will accept from a client. We can provide a list of media types too. Let’s define a simple endpoint:

@RequestMapping(value = "/greetings", method = RequestMethod.POST, consumes="application/json")
public void addGreeting(@RequestBody ContentType type, Model model) {
 // code here
}

If a client specifies a media type that’s unable to consume by resource, the system will generate an HTTP “415 Unsupported Media Type” error.

2.2. Producible Media Type

As opposed to the consumes attribute, produces specifies the media type a resource can produce and send back to the client. Without a doubt, we can use a list of options. If a resource is unable to produce the requested resource, the system will generate an HTTP “406 Not Acceptable” error.

Let’s start with a simple example of an API exposing a JSON string.

Here’s our endpoint:

@GetMapping(
 value = "/greetings-with-response-body", 
 produces="application/json"
) 
public String getGreetingWhileReturnTypeIsString() { 
 return "{\"test\": \"Hello\"}";
}

We’ll test this using CURL:

curl http://localhost:8080/greetings-with-response-body

The above command produces the response:

{ "test": "Hello" }

3. Rest Controllers With Spring Boot

If we are using Spring Boot for rest controllers it will make easy our lives through a single annotation that will handle multiple things. @RestController annotation combines the @Controller and @ResponseBody annotation into just a single one. This will be applied to all endpoints defined in that class.

3.1. Using @RestController Annotation

The Jackson ObjectMapper class parses a JSON from a string, stream, or file. If Jackson is on the classpath, any controller in Spring applications renders the JSON response by default.

We’ll add a unit test to verify from the response:

@Test
public void givenReturnTypeIsString_whenJacksonOnClasspath_thenDefaultContentTypeIsJSON() 
 throws Exception {
 
 // Given
 String expectedMimeType = "application/json";
 
 // Then
 String actualMimeType = this.mockMvc.perform(MockMvcRequestBuilders.get("/greetings-with-response-body", 1))
 .andReturn().getResponse().getContentType();

 Assert.assertEquals(expectedMimeType, actualMimeType);
}

3.2. Using ResponseEntity

In contrast to @ResponseBody, the ResponseEntity is a generic type that represents the entire HTTP response. As a result, we can control anything that goes into it: status code, header, and the body.

Let’s define a new endpoint:

@GetMapping(
 value = "/greetings-with-response-entity",
 produces = "application/json"
)
public ResponseEntity<String> getGreetingWithResponseEntity() {
 final HttpHeaders httpHeaders= new HttpHeaders();
 httpHeaders.setContentType(MediaType.APPLICATION_JSON);
 return new ResponseEntity<String>("{\"test\": \"Hello with ResponseEntity\"}", httpHeaders, HttpStatus.OK);
}

In the developer console of our browser, we can see the following response:

{"test": "Hello with ResponseEntity"}

We’ll verify the response’s content type with a test case:

@Test
public void givenReturnTypeIsResponseEntity_thenDefaultContentTypeIsJSON() throws Exception {
 
 // Given
 String expectedMimeType = "application/json";
 
 // Then
 String actualMimeType = this.mockMvc.perform(MockMvcRequestBuilders.get("/greetings-with-response-entity", 1))
 .andReturn().getResponse().getContentType();

 Assert.assertEquals(expectedMimeType, actualMimeType);
}

3.3. Using Map<String, Object> Return Type

Last, but not least, we can also set the content type by changing the return type from String to Map. This Map return type will need marshaling, and returns a JSON object.

Here’s our new endpoint:

@GetMapping(
 value = "/greetings-with-map-return-type", 
 produces = "application/json"
)
public Map<String, Object> getGreetingWhileReturnTypeIsMap() {
 HashMap<String, Object> map = new HashMap<String, Object>();
 map.put("test", "Hello from map");
 return map;
}

Let’s see this in action:

curl http://localhost:8080/greetings-with-map-return-type

The curl command returns a JSON response:

{ "test": "Hello from map" }

4. Conclusion

In this article, we learned how to set the content type in Spring MVC with Spring boot, first the default Json mapper in the classpath, then using ResponseEntity, and finally, changing the return type from String to Map.