Preparing for Java and Spring Boot Interview?

Join my Newsletter, its FREE

Difference between @RequestParam vs @RequestBody in Spring MVC? (with Example)

Hello everyone, in this article, we are going to look at an interesting topic from the Java Spring framework and the topic is, to find the difference between @RequestBody and @RequestParam. If you don't know this is one of the frequently asked Spring MVC interview question and also two of the most used annotation when creating backend of a Java web application in Spring Framework. Earlier, I have explained difference between @RequestBody and @ResponseBody in Spring MVC and REST APIs, and in this article, I am going to tell you the difference between @RequestBody and @RequestParam annotation in Spring Framework. It is worth noting that these two annotations are frequently used in Spring Boot REST API.

Before heading towards the main topic, it is important to have reasonable knowledge regarding these terms and an understanding of what role they play in Spring Boot REST APIs. So, let's understand what is @RequestParam annotation, what they do, how to use them with examples as well @RequestBody annotation with examples. 

@RequestParam Annotation in Spring MVC

The @RequestParam annotation in the Spring application allows us to read values from request parameters. Input data can be provided in the form of a query, form data, etc. It uses to bind it automatically to the method parameters provided in the method body. In the next paragraph, we will understand how to capture the requested data using @RequestParam annotation.

This annotation can have the following optional parameters as mentioned:

defaultValue – when the request parameter is absent or has no value, it is utilized as a fallback

name - use to bind parameter with the request

required – show whether it is mandatory or not

value – name alias

Here is an example of Spring Boot web application that makes use of @RequestParam annotation. In this application, I have included two text inputs as username and password in our HTML form. These two tags produce request parameters, which are later read by @RequestParam in the controller.

Difference between @RequestParam and @RequestBody in Spring MVC

1) Create a new maven project

To start with just create a Maven project as shown below:

2) Adding dependencies to your pom.xml file

Next step is to add dependencies in your pom.xml which will make Maven download JAR files automatically from Maven central or Nexus repository configured in your settings.xml file.

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="" xmlns:xsi=""







      <relativePath/> <!-- lookup parent from repository -->





   <name>IPL Dashboard</name>

   <description>App tries to replicate how an IPL Dashboard works</description>


































3) Create Controller class

Now, it's time to code Java classes, starting with Controller

import org.springframework.stereotype.Controller;

import org.springframework.ui.Model;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.bind.annotation.ResponseBody;



public class LoginController {

    @RequestMapping(path = "/login-page")

    public String getLoginPage(){

        return "login";



    public String loginProcessing(
           @RequestParam(required = true, name = "username") String username, 
           @RequestParam(required = true, name = "user-password") String password, 
           Model model){

        if(username.equals("username") && password.equals("password")) {

            model.addAttribute("username", username);

            return "home";


        else {


 "Oops! entered username or password is incorrect");

            return "error";




Once a user submits a form along with a username and password. The /login-processing endpoint will then captures the data from the query string and do a simple check to redirect between the error page and the home page. 


@RequestParam(required = true, name = "username")String username

@RequestParam(required = true, name = "user-password") String password

Using @RequestParam annotation, one can see we are binding the request parameter with the variable inside the method body

if(username.equals("username") && password.equals("password"))  {
  model.addAttribute("username", username);
            return "home";

} else {
   model.addAttribute("error_message", "Oops! entered username or password is incorrect");
   return "error";


Here we are checking if the username and password fields contain the term ‘username’ and ‘password’ respectively, redirecting the user to the home page and otherwise navigating to an error page.

4.Application entry point

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import javax.persistence.EntityManager;


public class IplDashboardApplication {

   public static void main(String[] args) {, args);



5. Create view pages

Login page

<!DOCTYPE html>



   <meta charset="utf-8">

   <meta name="viewport" content="width=device-width, initial-scale=1">

   <title>Login Page</title>



   <div class="login-header">

      <h2>Welcome to the Login Page</h2>


   <div class="login-body">

      <form method="GET" action="login-processing">

         <p>Enter your username </p>

            <input type="text" name="username" 

 placeholder="Enter your username">

         <p>Enter your password</p>

         <input type="password" name="user-password" 

 placeholder="Enter your password">



         <input type="submit" name="submit">





Home Page

<!DOCTYPE html>

<html xmlns:th="">


   <meta charset="utf-8">

   <meta name="viewport" content="width=device-width, initial-scale=1">

   <title>Home Page</title>



   <div class="home-header">

      <h2 th:text="|Hi, ${username} Welcome to the Home Page|">Default</h2>





Error Page

<!DOCTYPE html>

<html xmlns:th="">


   <meta charset="utf-8">

   <meta name="viewport" content="width=device-width, initial-scale=1">

   <title>Error Page</title>



   <div class="error-header">

      <h2 th:text="${error_message}">Oops! something went wrong</h2>


   <div style="text-align: center; margin: 0px auto; width: 500px">

      <p>Navigate to Login page? 

<a href="http://localhost:8080/api/v1/login-page">

Login Here</a></p>




What is @RequestBody Annotation in Spring MVC

The request body is known to us as data sent by a client to the server or API. The data which client sent to the server with a POST request may look like


    "username": "some-user",

    "email": "some-email",

    "address": "xyz-address"    


In Spring, the HttpRequest body is automatically deserialized into a Java object thanks to the @RequestBody annotation, which translates the HttpRequest body to a transfer or domain object.

According to Spring’s documentation, @RequestBody annotation is bounded to the web request body. Which then pass through HttpMessageConverter to deserialize into Java objects depending on the request content type (i.e. JSON or XML). 

 Let’s take a look at Spring controller method.

// Sending a simple Email


public String sendMail(@RequestBody EmailDetails details){

    String status = emailService.sendSimpleMail(details);

    return status;


public class EmailDetails {

    private String recipient;

    private String msgBody;

    private String subject;

    private String attachment;


As you can see endpoint /sendMail accepts a request body from a client and parse it to the mentioned EmailDetails type. Spring immediately deserializes the JSON into it. By default, the @RequestBody annotation requires that the type we annotate match the JSON that was transmitted from our client side to the controller.

1) -> Client sends data (JSON/XML) 

2) -> Intercept by HttpMessageConverter for deserialization 

3) -> Hold by a model object (a.k.a User defined object)

Difference Between @RequestBody and @RequestParam annotation in Spring

After understanding the two annotations. Now it’s time to take a look at the difference between them. Below is the list of differences 

@RequestParam Annotation

@RequestParam maps a GET or POST request parameter to the method’s argument.


public String getMatchInfo(@RequestParam(value = "team") 

 String team){



@RequestBody on the other hand maps the whole client request to a model class. We use model class’s getter and setters to use its properties. 



   "vehicle": "VehicleName",

   "yearManufacture" : "2008",

   "registrationNumber": "1909",

   . . .


public String postVehicleInfo(@RequestBody Vehicle vehicle)





public class Vehicle {

    private String name;

    private String color;

   // additional fields

    public String getColor() {

        return color;


    public void setColor(String color) {

        this.color = color;


    public String getVehicleName() {

        return name;


    public void setVehicleName(String name) { = name;



That's all about difference between @RequestParam and @RequestBody annotation in Java. In this article, we learned the difference between the @RequestParam and @ReqeustBody annotation in Spring MVC. We started our discussion by defining each annotation along with a suitable example in the context of the Spring Boot application. Hope the article helps you to distinguish between the two annotations and how to use them in your Spring Boot application. 

Other Java and Spring Articles and Tutorials you may like to explore

Thanks for reading this article so far. If you like my explanation of difference between @RequestParam and @RequestBody annotation in Spring MVC 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 are keen to learn about Spring MVC and REST  with Spring Boot and looking for online courses then you can also checkout this list of 5 Best Spring MVC courses for Java developers, where you will find best spring mvc courses from Udemy, Coursera, and YouTube.

No comments:

Post a Comment

Feel free to comment, ask questions if you have any doubt.