@RequestParam vs @PathVariable

Qual è la differenza tra @RequestParame @PathVariabledurante la gestione di caratteri speciali?

+è stato accettato @RequestParamcome spazio.

Nel caso di @PathVariable, è +stato accettato come +.

• @PathVariableconsiste nell'ottenere un segnaposto dall'URI (Spring lo chiama un modello URI) - vedere la Guida di riferimento al capitolo 16.3.2.2 Pattern dei modelli URI
• @RequestParamdeve anche ottenere un parametro dall'URI - consultare il capitolo 16.3.3.3 di Riferimento di primavera per associare i parametri di richiesta ai parametri del metodo con @RequestParam

Se l'URL http://localhost:8080/MyApp/user/1234/invoices?date=12-05-2013riceve le fatture per l'utente 1234 il 5 dicembre 2013, il metodo del controller sarebbe simile a:

@RequestMapping(value="/user/{userId}/invoices", method = RequestMethod.GET)
public List<Invoice> listUsersInvoices(
            @PathVariable("userId") int user,
            @RequestParam(value = "date", required = false) Date dateOrNull) {
  ...
}

Inoltre, i parametri di richiesta possono essere facoltativi e, a partire dalla primavera 4.3.3, anche le variabili di percorso possono essere opzionali . Attenzione, questo potrebbe cambiare la gerarchia del percorso URL e introdurre conflitti di mappatura delle richieste. Ad esempio, /user/invoicesfornirebbe le fatture per l'utente nullo i dettagli su un utente con ID "fatture"?

Annotazione @RequestParam utilizzata per accedere ai valori dei parametri della query dalla richiesta. Guarda il seguente URL di richiesta:

http://localhost:8080/springmvc/hello/101?param1=10&param2=20

Nella richiesta URL precedente, è possibile accedere ai valori per param1 e param2 come di seguito:

public String getDetails(
    @RequestParam(value="param1", required=true) String param1,
        @RequestParam(value="param2", required=false) String param2){
...
}

Di seguito sono elencati i parametri supportati dall'annotazione @RequestParam:

• defaultValue - Questo è il valore predefinito come meccanismo di fallback se la richiesta non ha il valore o è vuota.
• name - Nome del parametro da associare
• richiesto - Indica se il parametro è obbligatorio o meno. Se è vero, non riuscire a inviare quel parametro fallirà.
• valore - Questo è un alias per l'attributo name

@PathVariable

@ PathVariable identifica il modello utilizzato nell'URI per la richiesta in arrivo. Diamo un'occhiata all'URL di richiesta seguente:

http: // localhost: 8080 / SpringMVC / ciao / 101 param1 = 10 & param2 = 20

La richiesta URL sopra può essere scritta nel tuo MVC Spring come di seguito:

@RequestMapping("/hello/{id}")    public String getDetails(@PathVariable(value="id") String id,
    @RequestParam(value="param1", required=true) String param1,
    @RequestParam(value="param2", required=false) String param2){
.......
}

L' annotazione @ PathVariable ha solo un valore di attributo per l'associazione del modello URI della richiesta. È consentito utilizzare l' annotazione multipla @ PathVariable nel singolo metodo. Ma assicurati che non più di un metodo abbia lo stesso modello.

Inoltre c'è un'altra annotazione interessante: @MatrixVariable

http: // localhost: 8080 / spring_3_2 / matrixvars / scorte; BT.A = 276.70, + 10,40, + 3,91; AZN = 236.00, + 103.00, + 3.29; SBRY = 375,50, + 7,60, + 2.07

E il metodo Controller per questo

 @RequestMapping(value = "/{stocks}", method = RequestMethod.GET)
  public String showPortfolioValues(@MatrixVariable Map<String, List<String>> matrixVars, Model model) {

    logger.info("Storing {} Values which are: {}", new Object[] { matrixVars.size(), matrixVars });

    List<List<String>> outlist = map2List(matrixVars);
    model.addAttribute("stocks", outlist);

    return "stocks";
  }

Ma devi abilitare:

<mvc:annotation-driven enableMatrixVariables="true" >

@RequestParam è utilizzato per il parametro di query (valori statici) come: http: // localhost: 8080 / calcolo / pow? Base = 2 & ext = 4

@PathVariable è uso per valori dinamici come: http: // localhost: 8080 / calcolo / sqrt / 8

@RequestMapping(value="/pow", method=RequestMethod.GET)
public int pow(@RequestParam(value="base") int base1, @RequestParam(value="ext") int ext1){
    int pow = (int) Math.pow(base1, ext1);
    return pow;
}

@RequestMapping("/sqrt/{num}")
public double sqrt(@PathVariable(value="num") int num1){
    double sqrtnum=Math.sqrt(num1);
    return sqrtnum;
}

1) @RequestParamviene utilizzato per estrarre i parametri della query

http://localhost:3000/api/group/test?id=4

@GetMapping("/group/test")
public ResponseEntity<?> test(@RequestParam Long id) {
    System.out.println("This is test");
    return ResponseEntity.ok().body(id);
}

while @PathVariableviene utilizzato per estrarre i dati direttamente dall'URI:

http://localhost:3000/api/group/test/4

@GetMapping("/group/test/{id}")
public ResponseEntity<?> test(@PathVariable Long id) {
    System.out.println("This is test");
    return ResponseEntity.ok().body(id);
}

2) @RequestParamè più utile in un'applicazione Web tradizionale in cui i dati vengono per lo più passati nei parametri della query mentre@PathVariable è più adatto per i servizi Web RESTful in cui l'URL contiene valori.

3) l' @RequestParamannotazione può specificare valori predefiniti se un parametro di query non è presente o vuoto utilizzando un defaultValueattributo, a condizione che l'attributo richiesto sia false:

@RestController
@RequestMapping("/home")
public class IndexController {

    @RequestMapping(value = "/name")
    String getName(@RequestParam(value = "person", defaultValue = "John") String personName) {
        return "Required element of request param";
    }

}

@PathVariable - must be placed in the endpoint uri and access the query parameter value from the request
@RequestParam - must be passed as method parameter (optional based on the required property)
 http://localhost:8080/employee/call/7865467

 @RequestMapping(value=“/call/{callId}", method = RequestMethod.GET)
 public List<Calls> getAgentCallById(
            @PathVariable(“callId") int callId,
            @RequestParam(value = “status", required = false) String callStatus) {

    }

http://localhost:8080/app/call/7865467?status=Cancelled

@RequestMapping(value=“/call/{callId}", method = RequestMethod.GET)
public List<Calls> getAgentCallById(
            @PathVariable(“callId") int callId,
            @RequestParam(value = “status", required = true) String callStatus) {

}

Entrambe le annotazioni si comportano esattamente allo stesso modo.

Solo 2 caratteri speciali "!" e '@' sono accettati dalle annotazioni @PathVariable e @RequestParam.

Per verificare e confermare il comportamento, ho creato un'applicazione di avvio a molla che contiene solo 1 controller.

 @RestController 
public class Controller 
{
    @GetMapping("/pvar/{pdata}")
    public @ResponseBody String testPathVariable(@PathVariable(name="pdata") String pathdata)
    {
        return pathdata;
    }

    @GetMapping("/rpvar")
    public @ResponseBody String testRequestParam(@RequestParam("param") String paramdata)
    {
        return paramdata;
    }
}

Rispondendo alle seguenti richieste ho ottenuto la stessa risposta:

1. ! Localhost: 7000 / PVAR / @ # $% ^ & * () _ + - = [] {} |; ':"/ <>.?
2. ?! Localhost: 7000 / rpvar param = @ # $% ^ & * () _ + - = [] {} |; ':"/ <>.?

! @ è stato ricevuto come risposta in entrambe le richieste

può essere che il tipo midia application / x-www-form-urlencoded converta lo spazio in + e il ricevitore decodifichi i dati convertendo il + in space.checkeck l'url per ulteriori informazioni. http://www.w3.org/TR/html401/interact/forms.html#h-17.13.4.1