¿Cuál es la diferencia entre @RequestParam
y @PathVariable
mientras maneja caracteres especiales?
+
fue aceptado por @RequestParam
como espacio.
En el caso de @PathVariable
, +
fue aceptado como +
.
¿Cuál es la diferencia entre @RequestParam
y @PathVariable
mientras maneja caracteres especiales?
+
fue aceptado por @RequestParam
como espacio.
En el caso de @PathVariable
, +
fue aceptado como +
.
Respuestas:
@PathVariable
es obtener algún marcador de posición del URI (Spring lo llama una plantilla de URI) - vea Spring Reference Capítulo 16.3.2.2 Patrones de plantilla de URI@RequestParam
es obtener un parámetro del URI también; consulte el Capítulo 16.3.3.3 de Spring Reference, parámetros de solicitud de enlace a parámetros de método con @RequestParamSi la URL http://localhost:8080/MyApp/user/1234/invoices?date=12-05-2013
recibe las facturas para el usuario 1234 el 5 de diciembre de 2013, el método del controlador se vería así:
@RequestMapping(value="/user/{userId}/invoices", method = RequestMethod.GET)
public List<Invoice> listUsersInvoices(
@PathVariable("userId") int user,
@RequestParam(value = "date", required = false) Date dateOrNull) {
...
}
Además, los parámetros de solicitud pueden ser opcionales y, a partir de Spring 4.3.3, las variables de ruta también pueden ser opcionales . Sin embargo, tenga cuidado, esto podría cambiar la jerarquía de la ruta URL e introducir conflictos de asignación de solicitudes. Por ejemplo, ¿ /user/invoices
proporcionaría las facturas para el usuario null
o detalles sobre un usuario con ID "facturas"?
@PathParam
funciona solo si hay un marcador de posición en la plantilla de uri)
@PathParam
es una anotación javax.ws.rs. docs.oracle.com/javaee/7/api/javax/ws/rs/PathParam.html
Anotación @RequestParam utilizada para acceder a los valores de los parámetros de consulta desde la solicitud. Mire la siguiente URL de solicitud:
http://localhost:8080/springmvc/hello/101?param1=10¶m2=20
En la solicitud de URL anterior, se puede acceder a los valores para param1 y param2 de la siguiente manera:
public String getDetails(
@RequestParam(value="param1", required=true) String param1,
@RequestParam(value="param2", required=false) String param2){
...
}
La siguiente es la lista de parámetros admitidos por la anotación @RequestParam:
@PathVariable
@ PathVariable identifica el patrón que se utiliza en el URI para la solicitud entrante. Veamos la siguiente URL de solicitud:
http: // localhost: 8080 / springmvc / hello / 101? param1 = 10 & param2 = 20
La solicitud de URL anterior se puede escribir en su Spring MVC de la siguiente manera:
@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){
.......
}
La anotación @ PathVariable solo tiene un valor de atributo para vincular la plantilla de URI de solicitud. Está permitido usar la anotación multiple @ PathVariable en el método único. Pero asegúrese de que no más de un método tenga el mismo patrón.
También hay una anotación más interesante: @MatrixVariable
Y el método del controlador para ello
@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";
}
Pero debes habilitar:
<mvc:annotation-driven enableMatrixVariables="true" >
userName
tener un tipo param o no? Me inclino por convertirlo en una variable, pero también podría ser un parámetro.
@PathParam
y @RequestParam
ser declarado sin usar@RequestMapping
@RequestParam se utiliza para parámetros de consulta (valores estáticos) como: http: // localhost: 8080 / calculation / pow? Base = 2 & ext = 4
@PathVariable se usa para valores dinámicos como: http: // localhost: 8080 / calculation / 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) @RequestParam
se utiliza para extraer parámetros de consulta
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 @PathVariable
se usa para extraer datos directamente del 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
es más útil en una aplicación web tradicional donde los datos se pasan principalmente en los parámetros de consulta, mientras que @PathVariable
es más adecuado para los servicios web RESTful donde la URL contiene valores.
3) la @RequestParam
anotación puede especificar valores predeterminados si un parámetro de consulta no está presente o vacío mediante el uso de un defaultValue
atributo, siempre que el atributo requerido sea 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) {
}
Ambas anotaciones se comportan exactamente de la misma manera.
Solo 2 caracteres especiales '!' y '@' son aceptados por las anotaciones @PathVariable y @RequestParam.
Para verificar y confirmar el comportamiento, he creado una aplicación de arranque de resorte que contiene solo 1 controlador.
@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;
}
}
Al presionar las siguientes solicitudes obtuve la misma respuesta:
! @ se recibió como respuesta en ambas solicitudes
puede ser que la aplicación / x-www-form-urlencoded tipo midia convierta el espacio a + , y el receptor decodificará los datos convirtiendo el + al espacio. verifique la url para obtener más información. http://www.w3.org/TR/html401/interact/forms.html#h-17.13.4.1
@PathVariable
se puede usar en cualquier RequestMethod