Difference Between @RequestParam and @PathVariable in Spring MVC

@RequestParam and @PathVariable

@RequestParam and @PathVariable annotations are used for accessing the values from the request. Both the the annotations have the significant purpose and use respectively. The key difference between @RequestParam and @PathVariable is that @RequestParam used for accessing the values of the query parameters where as @PathVariable used for accessing the values from the URI template.

In this tutorial I will explain the @RequestParam and @PathVariable annotations used in Spring MVC with a simple example and syntax used for accessing the values from query string and URI template.

@RequestParam

@RequestParam annotation used for accessing the query parameter values from the request. Look at the following request URL:

http://localhost:8080/springmvc/hello/101?param1=10&param2=20

In the above URL request, the values for param1 and param2 can be accessed as below:

public String getDetails(
@RequestParam(value="param1", required=true) String param1,
@RequestParam(value="param2", required=false) String param2){
...
}

The following are the list of parameters supported by the @RequestParam annotation:

• defaultValue – This is the default value as a fallback mechanism if the request is not having the value or it is empty.
• name – Name of the parameter to bind
• required – Whether the parameter is mandatory or not. If it is true, failing to send that parameter will fail.
• value – This is an alias for the name attribute

@PathVariable

@PathVariable identifies the pattern that is used in the URI for the incoming request. Let’s look at the below request URL:

http://localhost:8080/springmvc/hello/101?param1=10&param2=20

The above URL request can be written in your Spring MVC as below:

@RequestMapping("/hello/{id}")
public String getDetails(@PathVariable(value="id") String id,
@RequestParam(value="param1", required=true) String param1,
@RequestParam(value="param2", required=false) String param2){
.......
}

The @PathVariable annotation has only one attribute value for binding the request URI template. It is allowed to use the multiple @PathVariable annotation in the single method. But, ensure that no more than one method has the same pattern.

While developing RESTful Web Services, it will be useful to use this annotation for forming the more flexible URI (Also Read : REST API Best Practices).

@PathParam vs @QueryParam

If you want to understand the difference between @PathParam and @QueryParam, the above two annotations are defined in JAX-RS implementations for the exact purpose of @PathVariable and @RequestParam which is defined in spring’s REST implementations. But, you could use either of the annotations without any difference in the behavior.

RequestParam vs PathVariable Example

Here is the complete source code for the example that demonstrates the key difference between RequestParam and PathVariable annotations. I have used Spring Boot for writing this example application. If you feel I have missed any key points about the RequestParam and PathVariable, please write it in the comments section.

SpringMVCController.java

package net.javabeat.spring.boot.example.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class SpringMVCController {
@RequestMapping("/hello/{id}")
public String getDetails(@PathVariable(value="id") String id,
@RequestParam(value="param1", required=true) String param1,
@RequestParam(value="param2", required=false) String param2){
System.out.println("ID : " + id);
System.out.println("Param 1 : " + param1);
System.out.println("Param 2 : " + param2);
return "hello";
}
}

Application.java

package net.javabeat.spring.boot.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@SpringBootApplication
public class Application extends WebMvcConfigurerAdapter{
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}

WebMvcConfig.java

package net.javabeat.spring.boot.example.controller;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

@Configuration
@EnableWebMvc
public class WebMvcConfig extends WebMvcConfigurerAdapter{
@Override
public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
configurer.enable();
}

@Bean
public InternalResourceViewResolver viewResolver() {
InternalResourceViewResolver resolver = new InternalResourceViewResolver();
resolver.setPrefix("WEB-INF/");
resolver.setSuffix(".jsp");
return resolver;
}
}

application.properties

server.contextPath=/springmvc

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>net.javabeat</groupId>
<artifactId>boot</artifactId>
<packaging>war</packaging>
<version>0.0.1-SNAPSHOT</version>
<name>boot</name>
<url>http://maven.apache.org</url>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.3.3.RELEASE</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
<build>
<finalName>boot</finalName>
</build>
</project>

If you don’t know how to run this application, please read our spring boot tutorial to understand how to run a spring boot application.

Download Source Code

Source Code : Difference Between @RequestParam and @PathVariable

1 file(s) 4.30 KB

Download

Summary

This tutorial would have helped you to understand the difference between @PathVariable and @RequestParam in the Spring MVC. Also, I have clarified about the alternative annotations @PathParam and @QueryParam which are supported in the official JAX-RS implementations. If you have any questions, please write it in the comments section.

Thank you for reading my blog. Happy Reading!!