What is difference between @RequestBody and @RequestParam?

I have gone through the Spring documentation to know about `@RequestBody`, and they have given the following explanation:

> The `@RequestBody` method parameter annotation indicates that a method parameter should be bound to the value of the HTTP request body. For example:

@RequestMapping(value = "/something", method = RequestMethod.PUT)
public void handle(@RequestBody String body, Writer writer) throws IOException {
writer.write(body);
}

> You convert the request body to the method argument by using an `HttpMessageConverter`. `HttpMessageConverter` is responsible for converting from the HTTP request message to an object and converting from an object to the HTTP response body.

>`DispatcherServlet` supports annotation based processing using the `DefaultAnnotationHandlerMapping` and `AnnotationMethodHandlerAdapter`. In Spring 3.0 the `AnnotationMethodHandlerAdapter` is extended to support the `@RequestBody` and has the following `HttpMessageConverter`s registered by default:

> ...


but my confusion is the sentence they have written in the doc that is

> The @RequestBody method parameter annotation indicates that a method parameter should be bound to the value of the HTTP request body.

What do they mean by that? Can anyone provide me an example?

The `@RequestParam` definition in spring doc is

> Annotation which indicates that a method parameter should be bound to a web request parameter. Supported for annotated handler methods in `Servlet` and `Portlet` environments.

I have become confused between them. Please, help me with an example on how they are different from each other.

`@RequestParam` annotation tells Spring that it should map a request parameter from the GET/POST request to your method argument. For example:

request:

GET:

[To see links please register here]

endpoint code:

public User getUser(@RequestParam(value = "name") String name,
@RequestParam(value = "surname") String surname){
...
}

So basically, while `@RequestBody` maps entire user request (even for POST) to a String variable, `@RequestParam` does so with one (or more - but it is more complicated) request param to your method argument.

Here is an example with @RequestBody, First look at the controller !!

public ResponseEntity<Void> postNewProductDto(@RequestBody NewProductDto newProductDto) {

...
productService.registerProductDto(newProductDto);
return new ResponseEntity<>(HttpStatus.CREATED);
....

}

And here is angular controller

function postNewProductDto() {
var url = "/admin/products/newItem";
$http.post(url, vm.newProductDto).then(function () {
//other things go here...
vm.newProductMessage = "Product successful registered";
}
,
function (errResponse) {
//handling errors ....
}
);
}

And a short look at form


<label>Name: </label>
<input ng-model="vm.newProductDto.name" />

<label>Price </label>
<input ng-model="vm.newProductDto.price"/>

<label>Quantity </label>
<input ng-model="vm.newProductDto.quantity"/>

<label>Image </label>
<input ng-model="vm.newProductDto.photo"/>

<Button ng-click="vm.postNewProductDto()" >Insert Item</Button>

<label > {{vm.newProductMessage}} </label>

`@RequestParam` makes Spring to map request parameters from the GET/POST request to your method argument.

**GET Request**

[To see links please register here]

public String getCountryFactors(@RequestParam(value = "city") String city,
@RequestParam(value = "country") String country){ }

**POST Request**

`@RequestBody` makes Spring to map entire request to a model class and from there you can retrieve or set values from its getter and setter methods. Check below.

[To see links please register here]

You have `JSON` data as such coming from the front end and hits your controller class

{
"city": "Sydney",
"country": "Australia"
}

`Java` Code - backend (`@RequestBody`)

public String getCountryFactors(@RequestBody Country countryFacts)
{
countryFacts.getCity();
countryFacts.getCountry();
}


public class Country {

private String city;
private String country;

public String getCity() {
return city;
}

public void setCity(String city) {
this.city = city;
}

public String getCountry() {
return country;
}

public void setCountry(String country) {
this.country = country;
}
}

map HTTP request header `Content-Type`, handle request body.

- `@RequestParam` ← `application/x-www-form-urlencoded`,

- `@RequestBody` ← `application/json`,

- `@RequestPart` ← `multipart/form-data`,

---

- [RequestParam (Spring Framework 5.1.9.RELEASE API)](

[To see links please register here]

)
> map to query parameters, form data, and parts in multipart requests.

> `RequestParam` is likely to be used with name-value form fields

- [RequestBody (Spring Framework 5.1.9.RELEASE API)](

[To see links please register here]

)
> bound to the body of the web request. The body of the request is passed through an **HttpMessageConverter** to resolve the method argument depending on the `content type` of the request. (e.g. JSON, XML)

- [RequestPart (Spring Framework 5.1.9.RELEASE API)](

[To see links please register here]

)
> used to associate the part of a "`multipart/form-data`" request

> `RequestPart` is likely to be used with parts containing more complex content

- [HttpMessageConverter (Spring Framework 5.1.9.RELEASE API)](

[To see links please register here]

)
> a converter that can convert from and to HTTP requests and responses.

> All Known Implementing Classes: ..., [AbstractJsonHttpMessageConverter](

[To see links please register here]

), [AbstractXmlHttpMessageConverter](

[To see links please register here]

), ...

It is very simple just look at their names @RequestParam it consist of two parts one is "Request" which means it is going to deal with request and other part is "Param" which itself makes sense it is going to map only the parameters of requests to java objects.
Same is the case with @RequestBody it is going to deal with the data that has been arrived with request like if client has send json object or xml with request at that time @requestbody must be used.

**`@RequestParam`** annotated parameters get linked to specific Servlet request parameters. Parameter values are converted to the declared method argument type.
This annotation indicates that a method parameter should be bound to a web request parameter.

*For example Angular request for Spring RequestParam(s) would look like that:*

$http.post('http://localhost:7777/scan/l/register?username="Johny"&password="123123"&auth=true')
.success(function (data, status, headers, config) {
...
})

*Endpoint with RequestParam:*

@RequestMapping(method = RequestMethod.POST, value = "/register")
public Map<String, String> register(Model uiModel,
@RequestParam String username,
@RequestParam String password,
@RequestParam boolean auth,
HttpServletRequest httpServletRequest) {...


**`@RequestBody`** annotated parameters get linked to the HTTP request body. Parameter values are converted to the declared method argument type using HttpMessageConverters.
This annotation indicates a method parameter should be bound to the body of the web request.

*For example Angular request for Spring RequestBody would look like that:*

$scope.user = {
username: "foo",
auth: true,
password: "bar"
};
$http.post('http://localhost:7777/scan/l/register', $scope.user).
success(function (data, status, headers, config) {
...
})

*Endpoint with RequestBody:*

@RequestMapping(method = RequestMethod.POST, produces = "application/json",
value = "/register")
public Map<String, String> register(Model uiModel,
@RequestBody User user,
HttpServletRequest httpServletRequest) {...