Annotazione Spring @ Pathvariable

1. Panoramica

In questo breve tutorial, esploreremo l' annotazione @PathVariable di Spring .

In poche parole, l' annotazione @PathVariable può essere utilizzata per gestire le variabili del modello nella mappatura dell'URI della richiesta e utilizzarle come parametri del metodo.

Vediamo come utilizzare @PathVariable ei suoi vari attributi.

2. Una semplice mappatura

Un semplice caso d' uso dell'annotazione @PathVariable sarebbe un endpoint che identifica un'entità con una chiave primaria:

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

In questo esempio, utilizziamo l' annotazione @PathVariable per estrarre la parte basata su modelli dell'URI rappresentata dalla variabile {id} .

Una semplice richiesta GET a / api / dipendenti / {id} richiamerà getEmployeesById con il valore id estratto:

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

Ora, esploriamo ulteriormente questa annotazione e diamo un'occhiata ai suoi attributi.

3. Specificare il nome della variabile di percorso

Nell'esempio precedente, abbiamo saltato la definizione del nome della variabile del percorso del modello poiché i nomi per il parametro del metodo e la variabile del percorso erano gli stessi.

Tuttavia, se il nome della variabile di percorso è diverso, possiamo specificarlo nell'argomento dell'annotazione @PathVariable :

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

Possiamo anche definire il nome della variabile di percorso come @PathVariable (value = "id") invece di PathVariable ("id") per chiarezza.

4. Più variabili di percorso in una singola richiesta

A seconda del caso d'uso, possiamo avere più di una variabile di percorso nell'URI della nostra richiesta per un metodo controller, che ha anche più parametri di metodo :

@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

Possiamo anche gestire più di un parametro @PathVariable utilizzando un parametro del metodo di tipo java.util.Map:

@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

Esiste, tuttavia, un piccolo problema durante la gestione di più parametri @ PathVariable quando la stringa della variabile di percorso contiene un carattere punto (.). Abbiamo discusso questi casi d'angolo in dettaglio qui.

5. Variabili di percorso opzionali

In primavera, i parametri del metodo annotati con @PathVariable sono richiesti per impostazione predefinita:

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

Di come appare, il controller di cui sopra dovrebbe gestire sia / api / employeeswithrequired e / api / employeeswithrequired / 1 percorsi di richiesta. Tuttavia, poiché i parametri del metodo annotati da @PathVariables sono obbligatori per impostazione predefinita, non gestisce le richieste inviate a / api / dipendenti con percorso richiesto:

//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

Possiamo gestirlo in due modi.

5.1. Impostazione di @PathVariable come Non richiesto

Possiamo impostare la proprietà richiesta di @PathVariable su false per renderla facoltativa. Quindi, modificando il nostro esempio precedente, ora possiamo gestire le versioni URI con e senza la variabile path:

@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. Utilizzando java.util.Optional

Dalla Spring 4.1, possiamo anche usare java.util.Optional (disponibile in Java 8+) per gestire una variabile di percorso non obbligatoria:

@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"; } }

Ora, se non specifichiamo l' id della variabile di percorso nella richiesta, otteniamo la risposta predefinita:

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

5.3. Utilizzo di un parametro del metodo di tipo Map

Come mostrato in precedenza, possiamo utilizzare un singolo parametro del metodo di tipo java.util.Map per gestire tutte le variabili di percorso nell'URI della richiesta. Possiamo anche usare questa strategia per gestire il caso delle variabili di percorso opzionali:

@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. Valore predefinito per @PathVariable

Per impostazione predefinita, non esiste una disposizione per definire un valore predefinito per i parametri del metodo annotati con @PathVariable . Tuttavia, possiamo utilizzare le stesse strategie discusse sopra per soddisfare il caso del valore predefinito per @PathVariable . Dobbiamo solo verificare la presenza di null sulla variabile del percorso.

Ad esempio, utilizzando java.util.Optional , possiamo identificare se la variabile di percorso è nulla o meno. Se è nullo , possiamo semplicemente rispondere alla richiesta con un valore predefinito:

@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. Conclusione

In questo articolo, abbiamo discusso come utilizzare l' annotazione @PathVariable di Spring . Abbiamo anche identificato i vari modi per utilizzare in modo efficace l' annotazione @PathVariable per adattarsi a diversi casi d'uso come parametri opzionali e gestione dei valori predefiniti.

L'esempio di codice mostrato in questo articolo è disponibile anche su Github.