Introducción
Contenido
Con Spring, asignamos solicitudes a los controladores de solicitudes a través del @RequestMapping
anotación. Spring Boot nos presentó los tipos derivados de esta anotación: @GetMapping
, @PostMapping
, @DeleteMapping
etc.
Estas solicitudes contienen diferentes tipos de información y datos y, según lo que haga nuestro punto final con la solicitud, es posible que deseemos recuperar el cuerpo de un POST
Solicitar registro o procesamiento adicional.
los @RequestBody
anotación nos permite recuperar el cuerpo de la solicitud. Luego podemos devolverlo como una cadena o deserializarlo en un objeto Java antiguo simple (POJO).
Spring tiene mecanismos integrados para deserializar objetos JSON y XML en POJO, lo que también facilita mucho esta tarea.
En este artículo, obtendremos el cuerpo de un POST
Solicitud HTTP y empaquetarla en una cadena, así como deserializarla en un POJO
Obtener el cuerpo de HTTP POST como una cadena
Empecemos con un @Controller
class para manejar una solicitud entrante:
@ResponseBody
@Controller
@RequestMapping("/response")
public class HomeController {}
Lo que vale la pena señalar aquí es que hemos agregado el @ResponseBody
anotación a la @Controller
. De esta manera, no representará una plantilla como cuerpo de respuesta, sino que devolverá un cuerpo de respuesta. Específicamente, lo empaquetaremos en una cadena y lo devolveremos.
Spring Boot nos presentó otro tipo derivado: @RestController
que es solo una combinación de las dos anotaciones anteriores. Usemos eso en su lugar por brevedad:
@RestController
@RequestMapping("/response")
public class HomeController {}
Ahora, sigamos adelante y definamos un controlador de solicitudes. Ya que estamos manejando un POST
solicitud, usaremos el @PostMapping
anotación para ello:
@RestController
@RequestMapping("/response")
public class HomeController {
@PostMapping("/postbody")
public String postBody(@RequestBody String fullName) {
return "Hello " + fullName;
}
}
Para recuperar el cuerpo del POST
solicitud enviada al controlador, usaremos el @RequestBody
anotación y asigne su valor a una cadena. Esto toma el cuerpo de la solicitud y lo empaqueta cuidadosamente en nuestro fullName
String. Luego devolvimos este nombre, con un mensaje de saludo.
Probemos este controlador a través de curl
:
curl -X POST -H "Content-type: application/json" -d "John Smith" "http://localhost:8080/response/postbody"
Esto resulta en:
Hello John Smith
Deserializar HTTP POST en POJO
Ahora, normalmente, no trabajaremos con Strings, aunque sirven como un buen ejemplo para aprender. En la mayoría de los casos, querremos hacer algún procesamiento, o al menos, serializar la solicitud en un POJO. Definamos un Person
POJO con un firstName
y lastName
:
public class Person {
private String firstName;
private String lastName;
// Constructor, getters and setters
}
Realizaremos el mismo proceso que en el ejemplo anterior, con el mismo controlador. Sin embargo, esta vez, especificaremos que el controlador acepta valores JSON y XML y que genera respuestas JSON o XML.
Recuperaremos un POST
cuerpo de solicitud en formato JSON, deserialícelo en un POJO para su posterior procesamiento (guardar en una base de datos, por ejemplo) y devolver una respuesta JSON
Aunque Spring Boot puede hacer coincidir automáticamente el cuerpo JSON con nuestro POJO, dado que los nombres de las variables coinciden, estableceremos explícitamente esta opción. Configuraremos los formatos de entrada y salida usando el consumes
y produces
banderas en el @PostMapping
:
@RestController
@RequestMapping("/response")
public class HomeController {
@PostMapping(
value = "/postbody",
consumes = {MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE},
produces = {MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE})
public ResponseEntity<Person> postBody(@RequestBody Person person) {
Person persistedPerson = personService.save(person);
return ResponseEntity
.created(URI
.create(String.format("/persons/%s", person.getFirstName())))
.body(persistedPerson);
}
}
Aquí, aceptamos JSON y XML, además de producirlo nuevamente. Hemos anotado el Person
instancia como el @RequestBody
, que también esperamos de la solicitud. Entonces, usamos un PersonService
instancia para guardar a la persona en una base de datos, que también devuelve el objeto persistente para su posterior procesamiento.
En aras de la brevedad, hemos omitido el PersonService
implementación, ya que es una implementación estándar de la capa de servicio.
Finalmente, hemos devuelto un ResponseEntity
objeto. Es solo una extensión del HttpEntity
clase que también tiene un código de estado. Hemos establecido el código de estado como CREATED
con un URI
ubicación donde se encuentra el nuevo recurso creado. Luego, hemos configurado el cuerpo del ResponseEntity
como el persistentPerson
instancia y construyó la respuesta.
Probemos este controlador a través de curl
otra vez:
curl -X POST -H "Content-type: application/json" -d "{"firstName" : "John", "lastName" : "Smith"}" "http://localhost:8080/response/postbody"
Aquí, hemos hecho un POST
solicitud con un cuerpo JSON, que contiene el nombre y apellido de una persona y lo envió a nuestro punto final.
El punto final responde con:
{"firstName":"John","lastName":"Smith"}
Conclusión
En este tutorial, hemos cubierto dos formas de capturar un POST
Cuerpo de la solicitud HTTP en un controlador Spring Boot.
Utilizando el @RequestBody
anotación, hemos mapeado el cuerpo a un String y lo hemos devuelto. Posteriormente, definimos un POJO para deserializar el contenido JSON entrante, lo procesamos y finalmente devolvimos un ResponseEntity
.