Spring @RequestParam Annotation
1. Überblick
In diesem kurzen Tutorial werden wir die Annotation@RequestParamvon Spring untersuchen.
Einfach ausgedrückt können wir@RequestParam verwenden, um Abfrageparameter, Formularparameter und sogar Dateien aus der Anforderung zu extrahieren.
Wir werden diskutieren, wie@RequestParam und seine Attribute verwendet werden. Wir werden auch die Unterschiede zwischen@RequestParam und@PathVariable. diskutieren
Weitere Lektüre:
Spring @RequestMapping Neue Verknüpfungen
In diesem Artikel stellen wir verschiedene Arten von @RequestMapping-Verknüpfungen für die schnelle Webentwicklung unter Verwendung des traditionellen Spring MVC-Frameworks vor.
Die Anmerkungen zu Spring @Controller und @RestController
Erfahren Sie mehr über die Unterschiede zwischen @Controller- und @RestController-Annotationen in Spring MVC.
2. Eine einfache Zuordnung
Nehmen wir an, wir haben einen Endpunkt/api/foos, der einen Abfrageparameter namensid akzeptiert:
@GetMapping("/api/foos")
@ResponseBody
public String getFoos(@RequestParam String id) {
return "ID: " + id;
}
In diesem Beispiel haben wir@RequestParam verwendet, um den Abfrageparameterid zu extrahieren.
Eine einfache GET-Anforderung würdegetFoos aufrufen:
http://localhost:8080/api/foos?id=abc
ID: abc
Next, *let's have a look at the annotation's attributes: _name,_ _value, required_ and _defaultValue._* == *3. Specifying the Request Parameter Name* In the previous example, both variable name and the parameter name are the same. *Sometimes we want these to be different, though.* Or, if we aren't using Spring Boot, we may need to do special compile-time configuration or the parameter names won't actually be in the bytecode. *But what's nice is that we can configure the _@RequestParam_ name using the _name_ attribute:* [source,java,gutter:,true]
@PostMapping("/api/foos") @ResponseBody public String addFoo(@RequestParam(name = "id") String fooId, @RequestParam String name) { return "ID: " + fooId + " Name: " + name; }
We can also do _@RequestParam(value = “id”)_ or just _@RequestParam(“id”)._ == *4. Making an Optional Request Parameter* Method parameters annotated with _@RequestParam_ are required by default. This means that if the parameter isn’t present in the request, we'll get an error: [source,bash,gutter:,true]
GET / api / foos HTTP / 1.1
400 Bad Request Required String parameter 'id' is not present ---- We can configure our _@RequestParam_ to be optional, though, with the __required __attribute: [source,java,gutter:,true] ---- @GetMapping("/api/foos") @ResponseBody public String getFoos(@RequestParam(required = false) String id) { return "ID: " + id; } ---- In this case, both: [source,bash,gutter:,true] ---- http://localhost:8080/api/foos?id=abc ---- ID: abc ---- and [source,bash,gutter:,true] ---- http://localhost:8080/api/foos ---- ID: null ---- will correctly invoke the method. *When the parameter isn't specified, the method parameter is bound to _null_.* == *5. A Default Value for the Request Parameter* We can also set a default value to the _@RequestParam_ by using the _defaultValue_ attribute: [source,java,gutter:,true] ---- @GetMapping("/api/foos") @ResponseBody public String getFoos(@RequestParam(defaultValue = "test") String id) { return "ID: " + id; } ---- *This is like __required=false, __in that the user no longer needs to supply the parameter:* [source,bash,gutter:,true] ---- http://localhost:8080/api/foos ---- ID: test ---- Though, we are still okay to provide it: [source,bash,gutter:,true] ---- http://localhost:8080/api/foos?id=abc ---- ID: abc ---- Note that when we set the __defaultValue __attribute, _required_ is, indeed, set to false. == *6. Mapping All Parameters* *We can also have multiple parameters without defining their names* or count by just using _Map:_ [source,java,gutter:,true] ---- @PostMapping("/api/foos") @ResponseBody public String updateFoos(@RequestParam MapallParams) { return "Parameters are " + allParams.entrySet(); } ---- Which will then reflect back any parameters sent: [source,bash,gutter:,true] ---- curl -X POST -F 'name=abc' -F 'id=123' http://localhost:8080/api/foos
Parameter sind {[name = abc], [id = 123]}
== *7. Mapping a Multi-Value Parameter* A single _@RequestParam_ can have multiple values: [source,java,gutter:,true]
@GetMapping("/api/foos") @ResponseBody public String getFoos(@RequestParam List
*And Spring MVC will map a comma-delimited __id __parameter:* [source,bash,gutter:,true]
IDs are [1,2,3]
Oder eine Liste der separatenid-Parameter:
http://localhost:8080/api/foos?id=1&id=2
IDs sind [1,2]
== *8. _@RequestParam_ vs _@PathVariable_* _@RequestParam_ and _@PathVariable_ can both be used to extract values from the request URI, but they are a bit different. === *8.1. Query Parameter vs URI Path* While __@RequestParam__s extract values from the query string, _@PathVariables_ extract values from the URI path: [source,java,gutter:,true]
@GetMapping("/foos/{id}") @ResponseBody public String getFooById(@PathVariable String id) { return "ID: " + id; }
Then, we can map based on the path: [source,bash,gutter:,true]
ID: abc
Und für@RequestParam, ist es:
@GetMapping("/foos")
@ResponseBody
public String getFooByIdUsingQueryParam(@RequestParam String id) {
return "ID: " + id;
}
Was uns die gleiche Antwort geben würde, nur eine andere URI:
http://localhost:8080/foos?id=abc
ID: abc
=== *8.2. Encoded vs Exact Value* Because _@PathVariable_ is extracting values from the URI path, it’s not encoded. On the other hand, _@RequestParam_ is. Using the previous example, _ab+c_ will return as-is: [source,bash,gutter:,true]
ID: ab+c
Für die Anforderung vona @RequestParamist der Parameter jedoch URL-decodiert:
http://localhost:8080/foos?id=ab+c
ID: ab c
=== *8.3. Optional Values* *Both _@RequestParam_ and _@PathVariable_ can be optional.* We can make _@PathVariable_ optional by using the _required_ attribute starting with Spring 4.3.3: [source,java,gutter:,true]
@GetMapping({"/myfoos/optional", "/myfoos/optional/{id}"}) @ResponseBody public String getFooByOptionalId(@PathVariable(required = false) String id){ return "ID: " + id; }
Which, then, we can do either: [source,bash,gutter:,true]
ID: abc
or:
http://localhost:8080/myfoos/optional
ID: null
For @RequestParam, we can also use the _required_ attribute as we saw in a previous section. Note that *we should be careful when making _@PathVariable_ optional, to avoid conflicts in paths.* == *9. Conclusion* In this article, we learned how to use _@RequestParam_ and the difference between _@RequestParam_ and _@PathVariable_. The full source code for the examples can be found in the https://github.com/eugenp/tutorials/tree/master/spring-mvc-simple[GitHub project].