January 28, 2023

Blog @ Munaf Sheikh

Latest news from tech-feeds around the world.

What is @ResponseBody and @RequestBody in Spring MVC? When to use them with Examples

Hello guys, if you are wondering what is
@RequestBody and
@ResponseBody annotation in Spring
and Spring Boot then you have come to the right place. Earlier, I have told you
about the
annotation and in this article, I am going to explain to you what is RequestBody
and ResponseBody annotation and when to use them with simple examples. When
working with REST API, we may need to bind HTTP requests and response bodies
with the domain object. To bind this, we use we can use the
@ResponseBody and
@RequestBody in Spring. So in this
tutorial, we are going to discuss what and when to use the
@ResponseBody and
@RequestBody in
Spring MVC

First, have a look at @ResponseBody annotation and its use cases.

1. @RequestBody Annotation in Spring and Spring Boot

The @RequestBody annotation is
responsible for binding the HTTPRequest body to the body of the web request.
Depending on the content type of the request, the body of the request is
given through a
HttpMessageConverter, which
resolves the method argument. 

We can also use the
@Valid annotation to
automatically validate the input.

In brief, the
@RequestBody annotation is
responsible for retrieving the request body and automatically converting it
to the Java object. 

Let’s have an example to explain this.

Student registration 

model.package com.school.model;
public class Student {

    private String firstName;
    private String lastName;
    private int age;

    public String getFirstName() {
        return firstName;

    public void setFirstName(String firstName) {
        this.firstName = firstName;

    public String getLastName() {
        return lastName;

    public void setLastName(String lastName) {
        this.lastName = lastName;

    public int getAge() {
        return age;

    public void setAge(int age) {
        this.age = age;

So let’s create the
REST controller
to accept the student registration. So there is no need to have converted
the HTTP request to an object. The Spring is responsible for automatically
deserializing the JSON into a Java based object using the

public class StudentController {
    private StudentRepository studentRepository;

    public List < Student > getAllStudents();

    public ResponseEntity < Student > getStudentById(@PathVariable(value = "id") 
                                         Long studentId) {
        Student student = studentRepository.findById(studentId);
        if (student == null) {
            return new ResponseEntity(errors, HttpStatus.SERVICE_UNAVAILABLE);
        return new ResponseEntity(student, HttpStatus.OK);

    public Student addStudent(@Valid @RequestBody Student student) {
        return studentRepository.save(student);


As mentioned above, spring is capable of
deserializing the JSON into a Java type
assuming the appropriate one is specified. But keep in your mind that, the
type that we annotate with the
@RequestBody annotation must
correspond to the JSON object that we sent through the client side.

I will show the API request which is sent through the
Postman in order to send the data to the backend.

So this is above the
@RequestBody annotation and
let’s discuss the

2. @ResponseBody Annotation in Spring and Spring Boot

The @ResponseBody annotation
is telling that the Spring framework serializes a return object into

JSON or XML and send this information back as a part of the HTTP
response. When working with the REST API, we should use
@RestController on a
class level rather than
@ResponseBody on a method

The @RestController is a constructed annotation with
@Controller and
@ResponseBody that is itself a meta-annotation.  The student class which is
created will be the same as for this example also. 
When we send a
POST request to our REST controller, we will get the response as below.



date:Tue, 14 Sep 2021 18:49:39 GMT

"firstName": "James",
"lastName": "Robert",
"age": 30

Note: We need to add the following changes if we don’t have the

public class StudentController {

    private StudentService studentService;

    public @ResponseBody Student register(@RequestBody Student student) {
        return studentService.saveStudentDetail(mapStudentData(student));

So this is all about the
annotation in Java and Spring applications. 

That’s all about
what are @ResponseBody and @RequestBody annotation in Spring
? They are essential annotations to create REST API and RESTful web
services in Java using Spring Framework, and they are the reasons why
it’s so easy to
create RESTful web services using Spring Framework
for Java developers. 

You can map your values to the model you defined in your system for
handling any specific call by using the
annotation. On the other hand, using
@ResponseBody, you can send
anything back to the source of the request. Both of these items can be
readily mapped without the need to write a custom parser or

Other Spring and REST Resources you may like

Thanks a lot for reading this article so far. If you like this
Java and Spring Boot tutorial then please share them with your friends
and colleagues. If you have any questions or feedback then please drop
a note. 

P. S. – If you want to learn the Spring Boot framework from
scratch and look for some of the best online resources, you can also
check out these best Spring Boot courses for Java developersThis article contains the best Udemy and Pluralsight courses to
learn Spring Boot from scratch.  

Source link