Spring RequestBody and ResponseBody Explained

Data sent over HTTP to server resources (Like a REST Controller) needs to be converted from serialized version to Objects. We can have different types of REST controllers based on the payload they support. For instance, we can design the REST controller to accept/send XML, JSON, TEXT, or HTML payloads/response. The Controller then should be able to read those data acts on it and return the response. Spring uses HTTP Message converters to convert the HTTP request body into domain object [deserialize request body to domain object], and to convert Domain object back to HTTP response body while returning the response. Spring provides a number of MessageConvertes like bellow, StringHttpMessageConverter: Read Write String
FormHttpMessageConverter: Read Write HTTP Form Data
MappingJackson2HttpMessageConverter: Read Write JSON
MappingJackson2XmlHttpMessageConverter: Read Write XML etc.
@RequestBody and @ResponseBody body annotation behind the scene uses these Message converter to serialize or deserialize the data. Following section, we will see each example of these two annotations.

Typically in each controller, we can have multiple methods. Each method is tied to a specific HTTP request path via @RequestMapping. That's how Spring knows for an incoming request which method needs to be invoked. If a method parameter is annotated with @RequestBody, Spring will bind the incoming HTTP request body (payload) to the parameter of the respective method tied to the request path. While doing that, Spring will [behind the scenes] use HTTP Message converters to convert the HTTP request body into domain object [deserialize request body to domain object], based on Accept header present in the request.

Similar to the @RequestBody annotation the @ResponseBody annotation is used to convert the return type of the method to the HTTP response. Here also Spring will use Message Converter to convert the return type of the method to the HTTP response body, set the HTTP headers, and HTTP status.
Let's see an example, where we bind a JSON payload to a @RequestBody method parameter. Following the example, we will create a REST endpoint that can take a JSON payload to create a blog category object and then return the response back to the client.

public class BlogCategory {
  private String id;
  private String name;
  //Getters and Setters removed for readability
}

{
    "id": "new_cat",
    "name": "new cat neme"
}

@RequestMapping(value = {"/categories"}, method = RequestMethod.POST,
      produces = MediaType.APPLICATION_JSON_VALUE)
  public @ResponseBody ResponseEntity addCats(@RequestBody BlogCategory input) {
    try {
      log.info("payload: " + input);
      blogService.addBlogCategories(input);
      return ResponseEntity.ok().body(input);
    } catch (Exception e) {
      log.info(e.getMessage());
      return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
    }
  }

As a result, when the controller receives a request, the payload will be parsed and used to populate an instance of the BlogCategory object. Similarly when returning Web response back to client Spring will serialize the instance of and ResponseEntity to Web response.

curl -X POST \
  http://localhost:8080/blogapi/categories \
  -H 'Content-Type: application/json' \
  -d '{
    "id": "new_cat",
    "name": "new cat neme"
}'

{
    "id": "new_cat",
    "name": "new cat neme"
}