En este post vamos a entender que es un controlador y como se crea un controlador en Spring Boot.
Que es un controlador Rest Controller
Un controller es un componente de Spring capaz de recibir peticiones http y responderlas.
Las clases que definimos como un controller es responsable de procesar las llamadas entrantes (request) que ingresan a nuestra aplicacion, validarlas y dar una respuesta (response).
Un rest controller es un tipo de controller que reciben peticiones con un formato de específico que cumple con formatos de solicitud RESTful habitualmente y mayormente en JSON , aunque a veces se usan otros como HTML, XML, o simplemente texto.
Como crear un RestController con Spring Boot
El primer paso para crear un ‘controlador rest’ es anotar la clase que con @RestController.
Con esto Spring ya sabe que esa clase será un componente encargado de recibir llamadas.
@RestController
public class HelloWordController {
}
Una vez que hemos anotado la clase podemos definir el método y la ruta en la cual recibirá la llamada externa.
Anotamos el método que da respuesta con @GetMapping y le indicamos la ruta en la cual responderá . Aquí definimos el path “/hello”.
@RestController
public class HelloWordController {
@GetMapping("/hello")
public String sayHello() {
return "Hello dev";
}
}
Arrancamos la aplicación.
gradlew booRun
Puedes leer este artículo donde explico el main de Spring Boot y como iniciarlo
Ahora podemos invocar nuestro RestControler mediante una llamada en el path ‘/hello’ que definimos previamente.
El servicio levanta en ‘localhost:8080’ y el path es ‘/hello’. Vemos la respuesta ‘Hello dev’
Tipos de mapeos en un rest controller de Spring Boot
En el punto anterior creamos un mapping para el path ‘/hello’ . Este mapeo lo definimos como un @GetMapping.
Sin embargo, debemos saber que hay otros tipos de mapping en Spring Boot.
En los métodos de un mapeo podemos usar:
- Get: para solicitar información de un recurso.
- Post: para enviar información a fin de crear o de actualizar un recurso.
- Put: para enviar información a fin de modificar un recurso.
- Patch: actualiza una parte del recurso.
- Delete: elimina un recurso específico.
¿Cuál es la diferencia entre Post , Put, Patch?
Habitualmente la diferencia entre Post y Put radica en que Post lo usamos para añadir un recurso y Put lo utilizamos para modificar un recurso en particular.
Patch también lo utilizamos para actualizar un recurso pero solo una parcialidad del mismo.
Ejemplos de mapeo en Spring Boot
A continuación vemos ejemplos simples de mapeo.
Para el caso del GetMapping estamos pidiendo mediante un id al recurso User. A fin de recibir este id utilizamos PathVariable
Para el PostMapping, PutMapping, PatchMapping se recibe un request con el body del User que se quiere insertar o actualizar.
El uso de RequestBody permite que Spring entienda la info que mandamos body de la petición.
En el DeleteMapping recibimos también id que identifica el objeto a eliminar y se devuelve true / false según si se pudo eliminar o no.
@RestController
public class UserController {
private final UserService userService;
public UserController(UserService userService) {
this.userService = userService;
}
@GetMapping("/api/user/{id}")
public User byId(@PathVariable("id") int id) {
return userService.find(id);
}
@PostMapping("/api/user/")
public User create(@RequestBody User user) {
return userService.create(user);
}
@PutMapping("/api/user/")
public User update(@RequestBody User user) {
return userService.update(user);
}
@PatchMapping("/api/user/")
public User change(@RequestBody User user) {
return userService.change(user);
}
@DeleteMapping("/api/user/{id}")
public boolean delete(@PathVariable("id") int id) {
return userService.remove(id);
}
}
¿Cómo haríamos la llamada a cada ruta?
Observa las llamadas que hacemos usando el cliente https://www.postman.com/
GetMapping para la ruta /api/user/{id} con el id a buscar
PostMapping para la ruta /api/user/ enviando el body con los datos
PutMapping para la ruta /api/user/ enviando el body con los datos
PatchMapping para la ruta /api/user/ enviando el body con los datos
DeleteMapping para la ruta /api/user/{id} con el id a eliminar
Conclusión
En este artículo aprendimos a crear un Rest Controller en SpringBoot con un ‘path’ definido por nosotros y como invocarlo.
Aprendimos el uso de las anotaciones necesarias para crear un controlador en Spring utilizando RestController , GetMapping, PostMapping, PutMapping, PatchMapping, DeleteMapping.