Lente @Pathvariable annotatie

1. Overzicht

In deze korte tutorial zullen we de lente verkennen @PathVariable annotatie.

Simpel gezegd, de @PathVariable annotatie kan worden gebruikt om sjabloonvariabelen af ​​te handelen in de aanvraag-URI-toewijzing, en gebruik ze als methodeparameters.

Laten we eens kijken hoe we het kunnen gebruiken @PathVariable en zijn verschillende attributen.

2. Een eenvoudige kaart

Een eenvoudig gebruiksscenario van de @PathVariable annotatie zou een eindpunt zijn dat een entiteit identificeert met een primaire sleutel:

@GetMapping ("/ api / werknemers / {id}") @ResponseBody openbare String getEmployeesById (@PathVariable String-id) {return "ID:" + id; }

In dit voorbeeld gebruiken we @PathVariable annotatie om het sjabloongedeelte van de URI te extraheren dat wordt vertegenwoordigd door de variabele {ID kaart}.

Een eenvoudige GET verzoek naar / api / medewerkers / {id} zal aanroepen getEmployeesById met de geëxtraheerde id-waarde:

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

Laten we deze annotatie nu verder onderzoeken en de kenmerken ervan bekijken.

3. Specificeer de naam van de padvariabele

In het vorige voorbeeld hebben we het definiëren van de naam van de sjabloonpadvariabele overgeslagen, aangezien de namen voor de methodeparameter en de padvariabele hetzelfde waren.

Als de naam van de padvariabele echter anders is, kunnen we deze specificeren in het argument van de @PathVariable annotatie:

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

We kunnen ook de naam van de padvariabele definiëren als @PathVariable (waarde = ”id”) in plaats van PathVariable ("id") voor alle duidelijkheid.

4. Meerdere padvariabelen in één aanvraag

Afhankelijk van de use case, we kunnen meer dan één padvariabele hebben in onze verzoek-URI voor een controllermethode, die ook meerdere methodeparameters heeft:

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

We kunnen er ook meer dan één aan @PathVariable parameters met behulp van een methodeparameter van het type java.util.Map:

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

Er is echter een klein probleem bij het verwerken van meerdere @PadVariabele parameters als de padvariabele tekenreeks een punt (.) teken bevat. We hebben die hoekgevallen hier in detail besproken.

5. Optionele padvariabelen

In het voorjaar werden methodeparameters geannoteerd met @PathVariable zijn standaard vereist:

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

Door hoe het eruit ziet, zou de bovenstaande controller beide moeten verwerken / api / workerswithrequired en / api / workerswithrequired / 1 verzoekpaden. Maar aangezien methodeparameters geannoteerd door @PathVariables zijn standaard verplicht, het behandelt niet de verzoeken die worden verzonden naar / api / workerswithrequired pad:

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

We kunnen dit op twee manieren aanpakken.

5.1. Instelling @PathVariable als niet vereist

We kunnen de verplicht eigendom van @PathVariable naar false om het optioneel te maken. Daarom kunnen we, door ons vorige voorbeeld aan te passen, nu de URI-versies met en zonder de padvariabele afhandelen:

@GetMapping (value = {"/ api / workerswithrequiredfalse", "/ api / workerswithrequiredfalse / {id}"}) @ResponseBody public String getEmployeesByIdWithRequiredFalse (@PathVariable (verplicht = false) String-id) {if (id! = Null) { retourneer "ID:" + id; } else {retourneer "ID ontbreekt"; }}
// localhost: 8080 / api / workerswithrequiredfalse ---- ID ontbreekt

5.2. Gebruik makend van java.util.Optioneel

Sinds Spring 4.1 kunnen we ook gebruiken java.util.Optioneel (beschikbaar in Java 8+) om een ​​niet-verplichte padvariabele af te handelen:

@GetMapping (value = {"/ api / workerswithoptional", "/ api / workerswithoptional / {id}"}) @ResponseBody openbare tekenreeks getEmployeesByIdWithOptional (@PathVariable Optioneel id) {if (id.isPresent ()) {return "ID: "+ id.get (); } else {retourneer "ID ontbreekt"; }}

Nu, als we de padvariabele niet specificeren ID kaart in het verzoek krijgen we het standaardantwoord:

// localhost: 8080 / api / workerswithoptional ---- ID ontbreekt 

5.3. Met behulp van een Method Parameter van Type Kaart

Zoals eerder getoond, kunnen we een enkele methodeparameter van het type gebruiken java.util.Map om alle padvariabelen in de aanvraag-URI af te handelen. We kunnen deze strategie ook gebruiken om het geval van optionele padvariabelen af ​​te handelen:

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

6. Standaardwaarde voor @PathVariable

Standaard is er geen voorziening om een ​​standaardwaarde te definiëren voor methodeparameters die zijn geannoteerd met @PathVariable. We kunnen echter dezelfde strategieën gebruiken die hierboven zijn besproken om te voldoen aan de standaardwaarde voor @PathVariable. We hoeven alleen maar te controleren nul op de padvariabele.

Gebruik bijvoorbeeld java.util.Optioneelkunnen we identificeren of de padvariabele is nul of niet. Als het is nul dan kunnen we gewoon op het verzoek reageren met een standaardwaarde:

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

7. Conclusie

In dit artikel hebben we besproken hoe u Spring's kunt gebruiken @PathVariable annotatie. We hebben ook de verschillende manieren geïdentificeerd om de @PathVariable annotatie voor verschillende gebruiksscenario's, zoals optionele parameters en het omgaan met standaardwaarden.

Het codevoorbeeld dat in dit artikel wordt getoond, is ook beschikbaar op Github.