@RequestParam vs @PathVariable

What is the difference between `@RequestParam` and `@PathVariable` while handling special characters?

`+` was accepted by `@RequestParam` as space.

In the case of `@PathVariable`, `+` was accepted as `+`.

it may be that the application/x-www-form-urlencoded midia type convert space to **+**, and the reciever will decode the data by converting the **+** to space.check the url for more info.http://www.w3.org/TR/html401/interact/forms.html#h-17.13.4.1

@PathVariable - must be placed in the endpoint uri and access the query parameter value from the request
@RequestParam - must be passed as method parameter (optional based on the required property)

[To see links please register here]

@RequestMapping(value=“/call/{callId}", method = RequestMethod.GET)
public List<Calls> getAgentCallById(
@PathVariable(“callId") int callId,
@RequestParam(value = “status", required = false) String callStatus) {

}

[To see links please register here]

@RequestMapping(value=“/call/{callId}", method = RequestMethod.GET)
public List<Calls> getAgentCallById(
@PathVariable(“callId") int callId,
@RequestParam(value = “status", required = true) String callStatus) {

}

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

[To see links please register here]

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 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:


>

[To see links please register here]

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.

Also there is one more interesting annotation:
**@MatrixVariable**

>

[To see links please register here]

And the Controller method for it

@RequestMapping(value = "/{stocks}", method = RequestMethod.GET)
public String showPortfolioValues(@MatrixVariable Map<String, List<String>> matrixVars, Model model) {

logger.info("Storing {} Values which are: {}", new Object[] { matrixVars.size(), matrixVars });

List<List<String>> outlist = map2List(matrixVars);
model.addAttribute("stocks", outlist);

return "stocks";
}

But you must enable:

<mvc:annotation-driven enableMatrixVariables="true" >

@RequestParam is use for query parameter(static values) like:

[To see links please register here]

@PathVariable is use for dynamic values like :

[To see links please register here]

@RequestMapping(value="/pow", method=RequestMethod.GET)
public int pow(@RequestParam(value="base") int base1, @RequestParam(value="ext") int ext1){
int pow = (int) Math.pow(base1, ext1);
return pow;
}

@RequestMapping("/sqrt/{num}")
public double sqrt(@PathVariable(value="num") int num1){
double sqrtnum=Math.sqrt(num1);
return sqrtnum;
}

- `@PathVariable` is to obtain some placeholder from the URI (Spring call it an URI Template)
— see [Spring Reference Chapter 16.3.2.2 URI Template Patterns][1]
- `@RequestParam` is to obtain a parameter from the URI as well — see [Spring Reference Chapter 16.3.3.3 Binding request parameters to method parameters with @RequestParam][2]

If the URL `http://localhost:8080/MyApp/user/1234/invoices?date=12-05-2013` gets the invoices for user 1234 on December 5th, 2013, the controller method would look like:


@RequestMapping(value="/user/{userId}/invoices", method = RequestMethod.GET)
public List<Invoice> listUsersInvoices(
@PathVariable("userId") int user,
@RequestParam(value = "date", required = false) Date dateOrNull) {
...
}



[1]:

[To see links please register here]

[2]:

[To see links please register here]

[3]:

[To see links please register here]

--

Also, request parameters can be optional, and as of Spring 4.3.3 path variables [can be optional as well][3]. Beware though, this might change the URL path hierarchy and introduce request mapping conflicts. For example, would `/user/invoices` provide the invoices for user `null` or details about a user with ID "invoices"?

Both the annotations behave exactly in same manner.

Only 2 special characters '!' and '@' are accepted by the annotations @PathVariable and @RequestParam.

To check and confirm the behavior I have created a spring boot application that contains only 1 controller.

@RestController
public class Controller
{
@GetMapping("/pvar/{pdata}")
public @ResponseBody String testPathVariable(@PathVariable(name="pdata") String pathdata)
{
return pathdata;
}

@GetMapping("/rpvar")
public @ResponseBody String testRequestParam(@RequestParam("param") String paramdata)
{
return paramdata;
}
}

Hitting following Requests I got the same response:

1. localhost:7000/pvar/!@#$%^&*()_+-=[]\{}|;':",./<>?
2. localhost:7000/rpvar?param=!@#$%^&*()_+-=[]\{}|;':",./<>?

!@ was received as response in both the requests

1) `@RequestParam` is used to extract *query parameters*

[To see links please register here]

@GetMapping("/group/test")
public ResponseEntity<?> test(@RequestParam Long id) {
System.out.println("This is test");
return ResponseEntity.ok().body(id);
}

while `@PathVariable` is used to extract data right from the URI:

[To see links please register here]

@GetMapping("/group/test/{id}")
public ResponseEntity<?> test(@PathVariable Long id) {
System.out.println("This is test");
return ResponseEntity.ok().body(id);
}

2) `@RequestParam` is more useful on a traditional web application where data is mostly passed in the query parameters while `@PathVariable` is more suitable for RESTful web services where URL contains values.

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`:

@RestController
@RequestMapping("/home")
public class IndexController {

@RequestMapping(value = "/name")
String getName(@RequestParam(value = "person", defaultValue = "John") String personName) {
return "Required element of request param";
}

}

@RequestParam:We can say it is query param like a key value pair
@PathVariable:-It is came from URI