Spring @ Pathvariable Annotation

1. Übersicht

In diesem kurzen Tutorial werden wir die @ PathVariable- Annotation von Spring untersuchen .

Einfach ausgedrückt kann die Annotation @PathVariable verwendet werden, um Vorlagenvariablen in der Anforderungs-URI-Zuordnung zu verarbeiten und sie als Methodenparameter zu verwenden.

Mal sehen, wie man @PathVariable und seine verschiedenen Attribute verwendet.

2. Eine einfache Zuordnung

Ein einfacher Anwendungsfall der Annotation @PathVariable wäre ein Endpunkt, der eine Entität mit einem Primärschlüssel identifiziert:

@GetMapping("/api/employees/{id}") @ResponseBody public String getEmployeesById(@PathVariable String id) { return "ID: " + id; }

In diesem Beispiel verwenden wir die Annotation @PathVariable , um den mit Vorlagen versehenen Teil des URI zu extrahieren, der durch die Variable {id} dargestellt wird .

Eine einfache GET - Anfrage an / api / Mitarbeiter / {id} wird aufrufen getEmployeesById mit der extrahierten ID - Wert:

//localhost:8080/api/employees/111 ---- ID: 111

Lassen Sie uns nun diese Anmerkung weiter untersuchen und ihre Attribute betrachten.

3. Angeben des Namens der Pfadvariablen

Im vorherigen Beispiel haben wir die Definition des Namens der Vorlagenpfadvariablen übersprungen, da die Namen für den Methodenparameter und die Pfadvariable identisch waren.

Wenn der Name der Pfadvariablen jedoch unterschiedlich ist, können Sie ihn im Argument der Annotation @PathVariable angeben :

@GetMapping("/api/employeeswithvariable/{id}") @ResponseBody public String getEmployeesByIdWithVariableName(@PathVariable("id") String employeeId) { return "ID: " + employeeId; }
//localhost:8080/api/employeeswithvariable/1 ---- ID: 1

Wir können den Namen der Pfadvariablen aus Gründen der Übersichtlichkeit auch als @PathVariable (Wert = "id") anstelle von PathVariable ("id") definieren .

4. Mehrere Pfadvariablen in einer einzelnen Anforderung

Abhängig vom Anwendungsfall kann unser Anforderungs-URI mehr als eine Pfadvariable für eine Controller-Methode enthalten, die auch mehrere Methodenparameter enthält :

@GetMapping("/api/employees/{id}/{name}") @ResponseBody public String getEmployeesByIdAndName(@PathVariable String id, @PathVariable String name) { return "ID: " + id + ", name: " + name; }
//localhost:8080/api/employees/1/bar ---- ID: 1, name: bar

Wir können auch mehr als einen @ PathVariable- Parameter mit einem Methodenparameter vom Typ java.util.Map verarbeiten:

@GetMapping("/api/employeeswithmapvariable/{id}/{name}") @ResponseBody public String getEmployeesByIdAndNameWithMapVariable(@PathVariable Map pathVarsMap) { String id = pathVarsMap.get("id"); String name = pathVarsMap.get("name"); if (id != null && name != null) { return "ID: " + id + ", name: " + name; } else { return "Missing Parameters"; } }
//localhost:8080/api/employees/1/bar ---- ID: 1, name: bar

Es gibt jedoch einen kleinen Haken bei der Verarbeitung mehrerer @ PathVariable- Parameter, wenn die Zeichenfolge der Pfadvariablen ein Punktzeichen (.) Enthält. Wir haben diese Eckfälle hier ausführlich besprochen.

5. Optionale Pfadvariablen

In Spring sind standardmäßig mit @PathVariable kommentierte Methodenparameter erforderlich:

@GetMapping(value = { "/api/employeeswithrequired", "/api/employeeswithrequired/{id}" }) @ResponseBody public String getEmployeesByIdWithRequired(@PathVariable String id) { return "ID: " + id; }

So wie es aussieht, sollte der obige Controller sowohl / api / employeewithrequired als auch / api / employeewithrequired / 1 Anforderungspfade verarbeiten. Da von @PathVariables mit Anmerkungen versehene Methodenparameter standardmäßig obligatorisch sind, werden die an / api / employee mit dem erforderlichen Pfad gesendeten Anforderungen nicht verarbeitet :

//localhost:8080/api/employeeswithrequired ---- {"timestamp":"2020-07-08T02:20:07.349+00:00","status":404,"error":"Not Found","message":"","path":"/api/employeeswithrequired"}  //localhost:8080/api/employeeswithrequired/1 ---- ID: 111

Wir können damit auf zwei Arten umgehen.

5.1. Festlegen von @PathVariable als nicht erforderlich

Wir können die erforderliche Eigenschaft von @PathVariable auf false setzen , um sie optional zu machen. Wenn wir also unser vorheriges Beispiel ändern, können wir jetzt die URI-Versionen mit und ohne die Pfadvariable behandeln:

@GetMapping(value = { "/api/employeeswithrequiredfalse", "/api/employeeswithrequiredfalse/{id}" }) @ResponseBody public String getEmployeesByIdWithRequiredFalse(@PathVariable(required = false) String id) { if (id != null) { return "ID: " + id; } else { return "ID missing"; } }
//localhost:8080/api/employeeswithrequiredfalse ---- ID missing

5.2. Verwenden von java.util.Optional

Seit Spring 4.1 können wir auch java.util.Optional (verfügbar in Java 8+) verwenden, um eine nicht obligatorische Pfadvariable zu verarbeiten:

@GetMapping(value = { "/api/employeeswithoptional", "/api/employeeswithoptional/{id}" }) @ResponseBody public String getEmployeesByIdWithOptional(@PathVariable Optional id) { if (id.isPresent()) { return "ID: " + id.get(); } else { return "ID missing"; } }

Wenn wir jetzt die Pfadvariablen- ID in der Anforderung nicht angeben , erhalten wir die Standardantwort:

//localhost:8080/api/employeeswithoptional ---- ID missing 

5.3. Verwenden eines Methodenparameters vom Typ Map

Wie bereits gezeigt, können wir einen einzelnen Methodenparameter vom Typ java.util.Map verwenden , um alle Pfadvariablen im Anforderungs-URI zu verarbeiten. Wir können diese Strategie auch verwenden, um den Fall der optionalen Pfadvariablen zu behandeln:

@GetMapping(value = { "/api/employeeswithmap/{id}", "/api/employeeswithmap" }) @ResponseBody public String getEmployeesByIdWithMap(@PathVariable Map pathVarsMap) { String id = pathVarsMap.get("id"); if (id != null) { return "ID: " + id; } else { return "ID missing"; } }

6. Standardwert für @PathVariable

Out of the box, there isn't a provision to define a default value for method parameters annotated with @PathVariable. However, we can use the same strategies discussed above to satisfy the default value case for @PathVariable. We just need to check for null on the path variable.

For instance, using java.util.Optional, we can identify if the path variable is null or not. If it is null then we can just respond to the request with a default value:

@GetMapping(value = { "/api/defaultemployeeswithoptional", "/api/defaultemployeeswithoptional/{id}" }) @ResponseBody public String getDefaultEmployeesByIdWithOptional(@PathVariable Optional id) { if (id.isPresent()) { return "ID: " + id.get(); } else { return "ID: Default Employee"; } }

7. Conclusion

In diesem Artikel haben wir die Verwendung der @ PathVariable- Annotation von Spring erläutert . Wir haben auch die verschiedenen Möglichkeiten identifiziert, um die Annotation @PathVariable effektiv für verschiedene Anwendungsfälle wie optionale Parameter und den Umgang mit Standardwerten zu verwenden.

Das in diesem Artikel gezeigte Codebeispiel ist auch über Github verfügbar.