web-dev-qa-db-fra.com

Quelle est la différence entre @RequestBody et @RequestParam?

J'ai parcouru la documentation de Spring pour connaître @RequestBody, et ils ont donné l'explication suivante:

L'annotation de paramètre de méthode @RequestBody indique qu'un paramètre de méthode doit être lié à la valeur du corps de la demande 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. HttpMessageConverter est responsable de la conversion du message de requête HTTP en objet et de la conversion d'un objet en corps de réponse HTTP. 

DispatcherServlet prend en charge le traitement basé sur les annotations à l'aide de DefaultAnnotationHandlerMapping et AnnotationMethodHandlerAdapter. Au printemps 3.0, la AnnotationMethodHandlerAdapter prend en charge le @RequestBody et possède les HttpMessageConverters suivants enregistrés par défaut: 

...

mais ma confusion est la phrase qu'ils ont écrite dans le doc qui est 

L'annotation de paramètre de méthode @RequestBody indique qu'un paramètre de méthode doit être lié à la valeur du corps de la demande HTTP.

Que veulent-ils dire par là? Quelqu'un peut-il me donner un exemple?

La définition de @RequestParam dans le document print est 

Annotation indiquant qu'un paramètre de méthode doit être lié à un paramètre de requête Web. Pris en charge pour les méthodes de gestionnaire annotées dans les environnements Servlet et Portlet.

Je suis devenu confus entre eux. S'il vous plaît, aidez-moi avec un exemple sur comment ils sont différents les uns des autres.

springspring-mvcspring-bootservlet-3.0http-request-parameters
33
Manoj Singh

@RequestParamles paramètres annotés sont liés à des paramètres spécifiques à la requête Servlet. Les valeurs de paramètre sont converties dans le type d'argument de méthode déclaré. Cette annotation indique qu’un paramètre de méthode doit être lié à un paramètre de requête Web.

Par exemple, une requête angulaire pour Spring RequestParam (s) ressemblerait à ceci:

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

Point de terminaison 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) {...

@RequestBodyles paramètres annotés sont liés au corps de la requête HTTP. Les valeurs de paramètre sont converties en type d'argument de méthode déclaré à l'aide de HttpMessageConverters. Cette annotation indique qu'un paramètre de méthode doit être lié au corps de la requête Web.

Par exemple, une requête angulaire pour Spring RequestBody ressemblerait à ceci:

$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) {...

J'espère que cela t'aides.

54
Patrik Bego

L'annotation @RequestParam indique à Spring qu'il doit mapper un paramètre de requête de la requête GET/POST sur l'argument de votre méthode. Par exemple:

demande:

GET: http://someserver.org/path?name=John&surname=Smith

code du point final:

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

En résumé, alors que @RequestBody mappe la requête de l’ensemble de l’utilisateur (même pour POST) avec une variable String, @RequestParam le fait avec un paramètre (ou plus compliqué) de requête avec votre argument de méthode.

4
Rafal G.

@RequestParam permet à Spring de mapper les paramètres de requête de la requête GET/POST à ​​l'argument de votre méthode.

Demande GET 

http://testwebaddress.com/getInformation.do?city=Sydney&country=Australia

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

POST Demande

@RequestBody permet à Spring de mapper la requête entière vers une classe de modèle et à partir de là, vous pouvez récupérer ou définir des valeurs à partir de ses méthodes getter et setter. Vérifiez ci-dessous.

http://testwebaddress.com/getInformation.do

Vous avez des données JSON en tant que telles provenant du front-end et frappez votre classe de contrôleur

{
   "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
Dulith De Costa

Voici un exemple avec @RequestBody, regardons d'abord le contrôleur !!

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

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

}

Et voici le contrôleur angulaire

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 aperçu de 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>
0
Pinkk Wormm