Lección 176: Trabajo con REST API en microservicios

REST — no es solo una palabra de moda que les gusta a los desarrolladores. Es un estilo arquitectónico que encaja muy bien con sistemas de microservicios gracias a su simplicidad, flexibilidad y escalabilidad. Vamos a ver por qué.

1. Facilidad de integración: REST usa el protocolo HTTP, que soportan todos los lenguajes modernos, así que puedes interactuar con los microservicios desde cualquier plataforma.
2. Principios de separación de responsabilidades: una aplicación REST separa cliente y servidor, lo que facilita mantener y organizar el código.
3. Escalabilidad: puedes escalar los microservicios según las necesidades del negocio, y el REST API seguirá siendo un medio flexible para intercambiar datos.
4. Caché: REST facilita el caché de respuestas, lo que reduce la carga del servidor.

En resumen, REST es una gran opción para construir microservicios. Pero ¿cómo diseñarlo e implementarlo? Nos metemos en los detalles.

Fundamentos de REST API en microservicios

REST (Representational State Transfer) es un estilo arquitectónico que usa los métodos HTTP estándar (GET, POST, PUT, DELETE) para trabajar con recursos.

En la arquitectura de microservicios, cada servicio normalmente expone un REST API para interactuar con otros componentes del sistema.

Ejemplo de REST API para el microservicio "Gestión de pedidos"

Imagina que diseñamos un sistema de gestión de pedidos. Tendremos un servicio Order Service que expone un REST API para crear, obtener, actualizar y eliminar pedidos.

Ejemplo de recursos de nuestro servicio:

• GET /orders: obtener la lista de pedidos.
• GET /orders/{id}: obtener la información de un pedido concreto.
• POST /orders: crear un nuevo pedido.
• PUT /orders/{id}: actualizar un pedido existente.
• DELETE /orders/{id}: eliminar un pedido.

Anotaciones de Spring para REST API

Spring Boot facilita el desarrollo de REST API gracias a un conjunto de anotaciones muy útiles:

1. @RestController: combina @Controller y @ResponseBody. Indica que esta clase expondrá un REST API.
2. @RequestMapping: se usa para definir la ruta y el método de la petición (por ejemplo, GET, POST, PUT, DELETE).
3. @GetMapping: versión simplificada de @RequestMapping para HTTP GET.
4. @PostMapping: para HTTP POST.
5. @PutMapping: para HTTP PUT.
6. @DeleteMapping: para HTTP DELETE.
7. @PathVariable: extrae variables desde el URI.
8. @RequestParam: extrae parámetros desde la query string.
9. @RequestBody: convierte el JSON del cuerpo de la petición a un objeto Java.

Implementación práctica del REST API

Vamos a crear un REST API sencillo para gestionar pedidos.

1. Crear la entidad Order:

   
   // Clase para describir el pedido
   @Data
   @AllArgsConstructor
   @NoArgsConstructor
   public class Order {
   private Long id;
   private String description;
   private Double totalAmount;
   }
   

2. Implementación del controlador OrderController:

   
   @RestController
   @RequestMapping("/orders") // URI base para todos los métodos
   public class OrderController {
   
       private List<Order> orders = new ArrayList<>();
   
       @GetMapping
       public List<Order> getAllOrders() {
           return orders;
       }
   
       @GetMapping("/{id}")
       public Order getOrderById(@PathVariable Long id) {
           return orders.stream()
                   .filter(order -> order.getId().equals(id))
                   .findFirst()
                   .orElseThrow(() -> new RuntimeException("Order not found"));
       }
   
       @PostMapping
       public Order createOrder(@RequestBody Order order) {
           orders.add(order);
           return order;
       }
   
       @PutMapping("/{id}")
       public Order updateOrder(@PathVariable Long id, @RequestBody Order updatedOrder) {
           Order existingOrder = getOrderById(id);
           existingOrder.setDescription(updatedOrder.getDescription());
           existingOrder.setTotalAmount(updatedOrder.getTotalAmount());
           return existingOrder;
       }
   
       @DeleteMapping("/{id}")
       public String deleteOrder(@PathVariable Long id) {
           Order order = getOrderById(id);
           orders.remove(order);
           return "Order deleted successfully!";
       }
   }
   

3. Pruebas del API: Ahora tenemos el CRUD completo para pedidos. Puedes probarlo con herramientas como Postman o curl:
   • Crear pedido: POST /orders con JSON en el cuerpo ({"id":1, "description":"New Order", "totalAmount":100.0}).
   • Obtener todos los pedidos: GET /orders.
   • Obtener pedido por ID: GET /orders/1.
   • Actualizar pedido: PUT /orders/1 con el JSON actualizado.
   • Eliminar pedido: DELETE /orders/1.

Consejos para diseñar REST API

¿Cómo elegir los URI?

• Usa sustantivos en los URI: en vez de /getAllOrders usa /orders.
• Usa el plural para recursos: /orders, no /order.
• Para recursos anidados sigue la jerarquía: /orders/{orderId}/items.

Formato de las respuestas

• Devuelve códigos HTTP útiles: 201 Created para creación, 404 Not Found para recurso no encontrado.
• Usa JSON como formato estándar de respuesta (lo soportan todos los lenguajes).

Validación de datos

• Usa la anotación @Valid para validación automática.
• Por ejemplo:

  
  @PostMapping
  public Order createOrder(@Valid @RequestBody Order order) {
  orders.add(order);
  return order;
  }
  

Manejo de errores

Crea un manejador centralizado de errores con @ControllerAdvice. Ejemplo:

@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(RuntimeException.class)
    public ResponseEntity<String> handleRuntimeException(RuntimeException ex) {
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(ex.getMessage());
    }
}

Seguridad del REST API

Aunque la seguridad se trata con más detalle en otras lecciones, algunos puntos clave:

• nunca pases datos sensibles (por ejemplo, contraseñas) en el URI.
• implementa autenticación y autorización (ver Spring Security).
• usa HTTPS para cifrar los datos.

Siguientes pasos

Hemos visto cómo crear un REST API y trabajar con él en una arquitectura de microservicios usando Spring Boot. En la próxima lección nos meteremos en un ejemplo práctico e implementaremos un REST API completo de un microservicio, incluyendo la conexión a una base de datos, la ejecución de migraciones y las pruebas de todas las operaciones. Mientras tanto, puedes practicar creando tus propios REST API para otras entidades — por ejemplo, productos, usuarios o transacciones.