Como crear un controlador Rest en Spring Boot

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.

Spring Boot Controller

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

spring-boot-start.png

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’

spring-boot-controller-hello-word.png

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.

spring-boot-mapping.png

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

Spring Boot Controller

PostMapping para la ruta /api/user/ enviando el body con los datos

Spring Boot Controller

PutMapping para la ruta /api/user/ enviando el body con los datos

Spring Boot Controller

PatchMapping para la ruta /api/user/ enviando el body con los datos

Spring Boot Controller

DeleteMapping para la ruta /api/user/{id} con el id a eliminar

Spring Boot Controller

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.

If you wish to send me any corrections or suggestions, please contact me.
Thanks for your feedback :)

Ver también