Quelle est la différence entre @RequestBody et @RequestParam?
j'ai parcouru la documentation du printemps pour en savoir plus sur @RequestBody, et ils ont donné l'explication suivante:
@RequestBodyl'annotation du paramètre method indique qu'un paramètre method doit être lié à la valeur du corps de la requête HTTP. Par exemple:
@RequestMapping(value = "/something", method = RequestMethod.PUT)
public void handle(@RequestBody String body, Writer writer) throws IOException {
writer.write(body);
}
vous convertissez le corps de la requête en argument de méthode en utilisant un
HttpMessageConverter.HttpMessageConverterest responsable de la conversion du message de requête HTTP vers un objet et la conversion d'un objet vers le corps de réponse HTTP.
DispatcherServletsupporte le traitement basé sur l'annotation en utilisant leDefaultAnnotationHandlerMappingetAnnotationMethodHandlerAdapter. Au Printemps 3.0AnnotationMethodHandlerAdapterest étendu pour supporter le@RequestBodyet a la suiteHttpMessageConverters inscrits par défaut:...
mais ma confusion est la phrase qu'ils ont écrit dans la doc
annotation du paramètre de la méthode @RequestBody indique qu'un paramètre de méthode doit être lié à la valeur du corps de la requête HTTP.
Que veulent-ils dire par là? Quelqu'un peut-il me donner un exemple?
@RequestParam définition au printemps doc est
Annotation indiquant qu'un paramètre de méthode doit être lié à un paramètre de requête web. Prise en charge des méthodes de handler annotées dans
ServletetPortletenvironnements.
je suis devenu la confusion entre eux. S'il vous plaît, m'aider avec un exemple sur la façon dont ils sont différents les uns des autres.
4 réponses
@RequestParam les paramètres annotés sont liés à des paramètres spécifiques de requête de Servlet. Les valeurs des paramètres sont converties en argument de méthode type déclaré.
Cette annotation indique qu'un paramètre de méthode doit être lié à un paramètre de requête web.
Par exemple Angulaire de la demande pour le Printemps RequestParam(s) ressembleraient à ça:
$http.post('http://localhost:7777/scan/l/register?username="Johny"&password="123123"&auth=true')
.success(function (data, status, headers, config) {
...
})
paramètre avec 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 les paramètres annotés sont liés au corps de la requête HTTP. Les valeurs des paramètres sont converties au type d'argument de méthode déclaré en utilisant HttpMessageConverters.
Cette annotation indique qu'un paramètre de méthode doit être lié au corps de la requête web.
Par exemple Angulaire de la demande pour le Printemps RequestBody ressembleraient à ça:
$scope.user = {
username: "foo",
auth: true,
password: "bar"
};
$http.post('http://localhost:7777/scan/l/register', $scope.user).
success(function (data, status, headers, config) {
...
})
paramètre avec RequestBody:
@RequestMapping(method = RequestMethod.POST, produces = "application/json",
value = "/register")
public Map<String, String> register(Model uiModel,
@RequestBody User user,
HttpServletRequest httpServletRequest) {...
J'espère que cela vous aidera.
@RequestParam annotation indique à Spring qu'il doit associer un paramètre request de la requête GET/POST à votre argument method. Par exemple:
demande:
GET: http://someserver.org/path?name=John&surname=Smith
point de terminaison de code:
public User getUser(@RequestParam(value = "name") String name,
@RequestParam(value = "surname") String surname){
...
}
donc en gros, alors que @RequestBody renvoie la demande entière de L'utilisateur (même pour le POST) à une variable String,@RequestParam le fait avec une (ou plusieurs - mais c'est plus compliqué) requête param à votre argument de méthode.
@RequestParam en fait le Printemps à la carte des paramètres de la requête GET/POST demande à votre argument de méthode.
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 fait Spring pour mapper une requête entière à une classe model et de là vous pouvez récupérer ou définir des valeurs à partir de ses méthodes getter et setter. Découvrez ci-dessous.
http://testwebaddress.com/getInformation.do
Vous avez JSON données en tant que telles venant de l'avant et touchant votre contrôleur classe
{
"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;
}
}
Voici un exemple avec @RequestBody, regardez d'Abord le contrôleur !!
public ResponseEntity<Void> postNewProductDto(@RequestBody NewProductDto newProductDto) {
...
productService.registerProductDto(newProductDto);
return new ResponseEntity<>(HttpStatus.CREATED);
....
}
Et voici angulaire contrôleur
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 ....
}
);
}
Et un bref coup d'œil à la forme
<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>