Was ist der Unterschied zwischen @RequestBody und @RequestParam?

Ich habe die Spring-Dokumentation durchgesehen, um etwas darüber zu erfahren @RequestBody, und sie haben die folgende Erklärung gegeben:

Die @RequestBodyAnnotation der Methodenparameter gibt an, dass ein Methodenparameter an den Wert des HTTP-Anforderungshauptteils gebunden werden soll. Zum Beispiel:

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

Sie konvertieren den Anforderungshauptteil mit einem in das Methodenargument HttpMessageConverter. HttpMessageConverterist verantwortlich für die Konvertierung von der HTTP-Anforderungsnachricht in ein Objekt und die Konvertierung von einem Objekt in den HTTP-Antworttext.

DispatcherServletunterstützt annotationsbasierte Verarbeitung mit DefaultAnnotationHandlerMappingund AnnotationMethodHandlerAdapter. In Spring 3.0 wird das AnnotationMethodHandlerAdaptererweitert, um das zu unterstützen, @RequestBodyund die folgenden HttpMessageConverters sind standardmäßig registriert:

...

aber meine Verwirrung ist der Satz, den sie in dem Dokument geschrieben haben, das heißt

Die Annotation des @RequestBody-Methodenparameters gibt an, dass ein Methodenparameter an den Wert des HTTP-Anforderungshauptteils gebunden werden soll.

Was meinen sie damit? Kann mir jemand ein Beispiel geben?

Die @RequestParamDefinition im Frühjahr doc ist

Anmerkung, die angibt, dass ein Methodenparameter an einen Webanforderungsparameter gebunden werden soll. Unterstützt für kommentierte Handlermethoden in Servletund PortletUmgebungen.

Ich bin zwischen ihnen verwirrt. Bitte helfen Sie mir mit einem Beispiel, wie sie sich voneinander unterscheiden.

@RequestParamMit Anmerkungen versehene Parameter werden mit bestimmten Servlet-Anforderungsparametern verknüpft. Parameterwerte werden in den deklarierten Methodenargumenttyp konvertiert. Diese Anmerkung gibt an, dass ein Methodenparameter an einen Webanforderungsparameter gebunden werden soll.

Zum Beispiel würde eine Angular-Anfrage für Spring RequestParam (s) folgendermaßen aussehen:

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

Endpunkt mit 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) {...

@RequestBodyMit Anmerkungen versehene Parameter werden mit dem HTTP-Anforderungshauptteil verknüpft. Parameterwerte werden mit HttpMessageConverters in den deklarierten Methodenargumenttyp konvertiert. Diese Anmerkung gibt an, dass ein Methodenparameter an den Hauptteil der Webanforderung gebunden werden soll.

Zum Beispiel würde die Angular-Anfrage für Spring RequestBody folgendermaßen aussehen:

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

Endpunkt mit RequestBody:

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

Hoffe das hilft.

@RequestParam veranlasst Spring, Anforderungsparameter aus der GET / POST-Anforderung Ihrem Methodenargument zuzuordnen.

GET Anfrage

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

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

POST-Anfrage

@RequestBodyveranlasst Spring, die gesamte Anforderung einer Modellklasse zuzuordnen, und von dort aus können Sie Werte aus den Getter- und Setter-Methoden abrufen oder festlegen. Überprüfen Sie unten.

http://testwebaddress.com/getInformation.do

Sie haben JSONDaten als solche, die vom Frontend kommen und Ihre Controller-Klasse treffen

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

JavaCode - 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;
    }
}

@RequestParamDie Annotation teilt Spring mit, dass ein Anforderungsparameter aus der GET / POST-Anforderung Ihrem Methodenargument zugeordnet werden soll. Zum Beispiel:

Anfrage:

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

Endpunktcode:

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

Während @RequestBodydie gesamte Benutzeranforderung (auch für POST) einer String-Variablen zugeordnet wird, @RequestParamgeschieht dies im Grunde genommen mit einem (oder mehreren - aber komplizierteren) Anforderungsparameter für Ihr Methodenargument.

Ordnen Sie den HTTP-Anforderungsheader zu Content-Typeund behandeln Sie den Anforderungshauptteil.

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

• @RequestBody← application/json,

• @RequestPart← multipart/form-data,

• RequestParam (Spring Framework 5.1.9.RELEASE API)

  Zuordnung zu Abfrageparametern, Formulardaten und Teilen in mehrteiligen Anforderungen.

  RequestParam wird wahrscheinlich mit Formularfeldern für Name und Wert verwendet

• RequestBody (Spring Framework 5.1.9.RELEASE API)

  an den Hauptteil der Webanforderung gebunden. Der Hauptteil der Anforderung wird über einen HttpMessageConverter übergeben , um das Methodenargument abhängig content typevon der Anforderung aufzulösen . (zB JSON, XML)

• RequestPart (Spring Framework 5.1.9.RELEASE API)

  wird verwendet, um den Teil einer " multipart/form-data" -Anforderung zuzuordnen

  RequestPart wird wahrscheinlich mit Teilen verwendet, die komplexeren Inhalt enthalten

• HttpMessageConverter (Spring Framework 5.1.9.RELEASE API)

  Ein Konverter, der von und zu HTTP-Anforderungen und -Antworten konvertieren kann.

  Alle bekannten Implementierungsklassen: ..., AbstractJsonHttpMessageConverter , AbstractXmlHttpMessageConverter , ...

Es ist sehr einfach, schauen Sie sich nur ihre Namen an @RequestParam. Es besteht aus zwei Teilen. Einer ist "Request", was bedeutet, dass es sich um eine Anfrage handelt, und der andere Teil ist "Param", was selbst Sinn macht, dass nur die Parameter von zugeordnet werden Anfragen an Java-Objekte. Gleiches gilt für @RequestBody, das sich mit den Daten befasst, die mit der Anfrage eingegangen sind, z. B. wenn der Client zu diesem Zeitpunkt ein JSON-Objekt oder eine XML-Datei mit der Anfrage gesendet hat, muss @requestbody verwendet werden.

Hier ist ein Beispiel mit @RequestBody. Schauen Sie sich zuerst den Controller an!

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

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

}

Und hier ist Winkelregler

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 ....
                        }
                );
            }

Und ein kurzer Blick auf die 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>