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, @DeleteMappingetc.
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.
