问题
I have gone through the Spring documentation to know about @RequestBody, and they have given the following explanation:
The
@RequestBodymethod 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.HttpMessageConverteris responsible for converting from the HTTP request message to an object and converting from an object to the HTTP response body.
DispatcherServletsupports annotation based processing using theDefaultAnnotationHandlerMappingandAnnotationMethodHandlerAdapter. In Spring 3.0 theAnnotationMethodHandlerAdapteris extended to support the@RequestBodyand has the followingHttpMessageConverters 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
ServletandPortletenvironments.
I have become confused between them. Please, help me with an example on how they are different from each other.
回答1:
@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) {...
Hope this helps.
回答2:
@RequestParam makes Spring to map request parameters from the GET/POST request to your method argument.
GET Request
http://testwebaddress.com/getInformation.do?city=Sydney&country=Australia
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.
http://testwebaddress.com/getInformation.do
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;
}
}
回答3:
@RequestParam annotation tells Spring that it should map a request parameter from the GET/POST request to your method argument. For example:
request:
GET: http://someserver.org/path?name=John&surname=Smith
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.
回答4:
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>
回答5:
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.
回答6:
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)
map to query parameters, form data, and parts in multipart requests.
RequestParamis likely to be used with name-value form fieldsRequestBody (Spring Framework 5.1.9.RELEASE API)
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 typeof the request. (e.g. JSON, XML)RequestPart (Spring Framework 5.1.9.RELEASE API)
used to associate the part of a "
multipart/form-data" requestRequestPartis likely to be used with parts containing more complex contentHttpMessageConverter (Spring Framework 5.1.9.RELEASE API)
a converter that can convert from and to HTTP requests and responses.
All Known Implementing Classes: ..., AbstractJsonHttpMessageConverter, AbstractXmlHttpMessageConverter, ...
来源：https://stackoverflow.com/questions/28039709/what-is-difference-between-requestbody-and-requestparam