Scribd
Upload
137 views7 pages

Path Variables and Request (Aram

The article discusses the differences between the @RequestParam and @PathVariable annotations in Spring MVC. @RequestParam is used to extract query parameters from the URL, while @PathVariable extracts values from the URI itself. For example, an order ID could be extracted from the URI using @PathVariable, while a date query parameter could be extracted using @RequestParam. @RequestParam can also specify default values if a parameter is missing, while @PathVariable allows multiple annotations in a handler method. The key difference is that @RequestParam retrieves values after the '?' in the URL, while @PathVariable retrieves values from the URI. Understanding these annotations is important for both traditional web and RESTful applications built with Spring MVC

Uploaded by

Bharat
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
137 views7 pages

Path Variables and Request (Aram

The article discusses the differences between the @RequestParam and @PathVariable annotations in Spring MVC. @RequestParam is used to extract query parameters from the URL, while @PathVariable extracts values from the URI itself. For example, an order ID could be extracted from the URI using @PathVariable, while a date query parameter could be extracted using @RequestParam. @RequestParam can also specify default values if a parameter is missing, while @PathVariable allows multiple annotations in a handler method. The key difference is that @RequestParam retrieves values after the '?' in the URL, while @PathVariable retrieves values from the URI. Understanding these annotations is important for both traditional web and RESTful applications built with Spring MVC

Uploaded by

Bharat
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 7

https://javarevisited.blogspot.

com/2017/10/differences-between-requestparam-and-
pathvariable-annotations-spring-mvc.html#axzz6f79Knayu

Differences between @RequestParam and @PathVariable annotations in


Spring MVC?

The Spring MVC framework, one of the most popular frameworks for developing a
web application in Java world also provides several useful annotations to extract
data from the incoming request and mapping the request to the controller,
like @RequestMapping, @RequestParam, and @PathVariable. Even though
both @RequestParam and @PathVariable is used to extract values from the
HTTP request, there is a subtle difference between them, which makes them a
useful question from an interview and spring certification point of view. We'll examine
the subtle difference between @RequestParam and @PathVaraible in this article.

As the name suggests, @RequestParam is used to get the request parameters from


URL, also known as query parameters, while @PathVariable extracts values from
URI.

For example, if the incoming HTTP request to retrieve a book on topic "Java"
is http://localhost:8080/shop/order/1001/receipts?date=12-05-
2017, then you can use the @RequestParam annotation to retrieve the query
parameter date and you can use @PathVariable to extract the orderId i.e.
"1001" as shown below:

@RequestMapping(value="/order/{orderId}/receipts", method =
RequestMethod.GET)
public List listUsersInvoices(                             
@PathVariable("orderId") int order,
 @RequestParam(value = "date", required = false) Date
dateOrNull) {
...
}

The required=false denotes that the query parameter can be optional, but


the URL must have the same URI.

By the way, if you are new to Spring framework then I also suggest you join a
comprehensive and up-to-date course to learn Spring in depth. If you need
recommendations, I highly suggest you take a look at Spring Framework 5:
Beginner to Guru, one of the comprehensive and hands-on course to learn modern
Spring. It' also most up-to-date and covers Spring 5.

How to extract Query Parameters in Spring MVC


using @RequestParam
Spring MVC is a rich framework to develop both web applications and RESTful web
services in Java. It provides several ways to retrieve data from the incoming HTTP
requests like

 Request Parameters
 Path Variables
 Form inputs

Now that you know the difference


between @RequestParam and @PathVariable in Spring MVC let's see how to
write Spring controllers that can handle request parameters and path variables.

1. Using @RequestParam to get Query parameters

In a Spring MVC application, you can use the @RequestParam annotation to accept


query parameters in Controller's handler methods.

For examples, suppose you have a web application which returns details of orders
and trades, and you have the following URLs:

http://localhost:8080/eportal/orders?id=1001
To accept the query parameters in the above URLs, you can use the following code
in the Spring MVC controller:

@RequestMapping("/orders")
public String showOrderDetails(@RequestParam("id") String
orderId, Model model){
   model.addAttribute("orderId", orderId);
   return "orderDetails";
}

If the name of the query parameter is the same as the name of the variable in
handler's @RequestParam annotated argument then you can simply
use @RequestParam without specifying the name of a query parameter, Spring will
automatically derive the value (see Introduction to Spring MVC).

Also, here is the code to prove the point:

URL: http://localhost:8080/eportal/trades?tradeId=2001
@RequestMapping("/trades")
public String showTradeDetails(@RequestParam String tradeId,
                               Model model){
  model.addAttribute("tradeId", tradeId);
  return "tradeDetails";
}

You can see that we have just annotated the method


parameter tradeId with @RequestParam without specifying the name of the query
parameter because the name of both request parameter and argument name is the
same, i.e., "tradeId."

If you are interested in learning more about the @RequestParam annotations and


other useful Spring MVC annotations, I suggest you check out Spring Framework
5: Beginner to Guru, one of the valuable resources for learning Spring MVC 5.

2. Using @PathVariable annotation to extract values from URI

You can use Spring MVC's @PathVaraible annotation to extract any value which


is embedded in the URL itself. Spring calls it a URI template,
where @PathVariable is used to obtain some placeholders from the URI itself.

If you have worked in RESTful Web services, you might know that the REST
URIs contains values, e.g. a REST API to retrieve a book using ISBN number looks
like the following:

URL: http://localhost:8080/book/9783827319333

Now, to extract the value of ISBN number from the URI in your Spring MVC
Controller's handler method, you can use @PathVariable annotation as shown in
the following code:

@RequestMapping(value="/book/{ISBN}", method=
RequestMethod.GET)
public String showBookDetails(@PathVariable("ISBN") String id,
                              Model model){
   model.addAttribute("ISBN", id);
   return "bookDetails";
}

Similar to @RequestParameter annotation, you also can also omit the value


attribute in @PathVariable annotation, if the name of the path variable's
placeholder in the @RequestMapping annotation is same to the variable name in
the handler method's @PathVariable annotated parameter (see REST with
Spring).

For example, you can rewrite the above code as shown below:

@RequestMapping(value="/book/{ISBN}", method=
RequestMethod.GET)
public String showBookDetails(@PathVariable String ISBN, 
                              Model model){
   model.addAttribute("ISBN", ISBN);
   return "bookDetails";
}

Spring MVC provides several useful annotations to map and extract data from the
HTTP request, and as of Spring developer, you should be aware of these,
e.g. @RequestMapping, @RequestParam, and @PathVariable.
These concepts and annotations are fundamental from both Spring MVC interview
prospects as well as Spring certifications. You will always find a couple of questions
based on these concepts.

Btw, if you are preparing for Spring Professional Certifications, you can also check
out David Mayer's free Spring Mock Questions to get an idea about the level of
questions and format of questions you can expect on real Spring Web Certification.

Difference between @PathVariable and


@RequestParam in Spring
Now that we understand both the difference as well as how to use
both @RequestParam and @PathVariable in Spring MVC application, let's revise
the critical difference between them from an interview perspective.

1) The @RequestParam is used to extract query parameters


while @PathVariable is used to extract data right from the URI.
2) @RequestParam is more useful on a traditional web application where data is
mostly passed in the query abatements while @PathVariable is more suitable for
RESTful web services where URL contains values,
like http://localhost:8080/book/9783827319333, here data, which is ISBN
number is part of URI.

If you want to learn more about how to effectively develop REST applications using
Spring, I suggest you join Eugen Paraschiv's REST with Spring course.

It's an online course that will teach you the nitty-gritty of developing both REST API
and services for real-world scenarios.

Eugen has extensive experience in developing RESTful web services using Spring,
and this course is a great way to tap into his knowledge.

3) @RequestParam annotation can specify default values if a query parameter is not


present or empty by using a defaultValue attribute, provided the required attribute is
false.

4) Spring MVC allows you to use multiple @PathVariable annotations in the same


method, provided, no more than one argument has the same pattern.

That's all about the difference between @PathVariable and @RequestParam in


Spring MVC. Even though both are used to extract data from
URL, @RequestParam is used to retrieve query parameters, anything after ? in the
URL, while @PathVariable is used to retrieve values from URI itself.

This concept is essential for both traditional web application development as well as
developing RESTful Web Services using Spring, so you must spend some time to
understand it better.

Other Spring MVC articles you may like to explore

Read more: https://javarevisited.blogspot.com/2017/10/differences-between-
requestparam-and-pathvariable-annotations-spring-mvc.html#ixzz6f7Uw3gCI

You might also like