Lección 171: Uso de Spring Boot para crear microservicios

Ya hemos creado aplicaciones muy sencillas usando Spring Boot, entendimos la estructura de un proyecto Spring Boot, su auto-configuración y las formas de configurar mediante application.properties y application.yml. Ahora estamos listos para dar el siguiente paso y aplicar Spring Boot para crear microservicios.

Spring Boot resuelve problemas

Antes de meternos en la parte práctica, veamos por qué Spring Boot es tan popular para desarrollar microservicios. Si alguna vez sufriste con infinitas configuraciones XML en aplicaciones Spring antiguas o pasaste horas buscando la versión correcta de una dependencia, apreciarás las ventajas de Spring Boot en el contexto de una arquitectura de microservicios.

Simplificación del desarrollo y la configuración

Spring Boot ofrece herramientas potentes para facilitar el desarrollo:

• Autoconfiguración: la mayoría de las configuraciones necesarias se hacen automáticamente, lo que reduce mucho el tiempo de "montaje" de la aplicación.
• Spring Boot Starters: conjuntos de dependencias preconfiguradas para habilitar funciones comunes. Por ejemplo, spring-boot-starter-web incluye lo necesario para un REST API, y spring-boot-starter-data-jpa — para trabajar con bases de datos.
• Servidores web embebidos: Tomcat, Jetty o Undertow, que te evitan tener que desplegar un servidor externo.

Soporte para arquitectura de microservicios

En los microservicios son importantes el aislamiento, la modularidad, la facilidad de escalado y la capacidad de añadir componentes rápido. Spring Boot facilita esto gracias a:

• La idea de "opinionated configuration": Spring Boot propone soluciones y ajustes listos para usar que funcionan "out of the box".
• Compatibilidad con ecosistemas DevOps: por ejemplo, integración con Docker o Kubernetes.
• Amplio soporte de integraciones: trabajo con bases de datos, message brokers (por ejemplo, Kafka), configuración centralizada y otros aspectos típicos de microservicios.

Primer microservicio con Spring Boot

Ahora que sabemos por qué usar Spring Boot para microservicios, vamos a crear nuestra primera aplicación. Por ejemplo, puede ser un servicio de gestión de clientes (CustomerService) que ofrezca operaciones CRUD.

Preparación del proyecto

1. Crear el proyecto con Spring Initializr

Abre Spring Initializr y configura:

• Project: Maven o Gradle (elige lo que te resulte más cómodo).
• Dependencies: añade Spring Web y Spring Data JPA.
• Language: Java.
• Packaging: Jar.
• Java Version: 17 (o la versión que tengas).

Después descarga el proyecto y ábrelo en tu IDE preferida (por ejemplo, IntelliJ IDEA o Eclipse).

2. Estructura del proyecto

Al abrir el proyecto verás la estructura básica:

src/main/java
└── com.example.customerservice
    ├── CustomerServiceApplication.java
    └── ... (aquí estarán tus clases)
src/main/resources
├── application.properties
└── ... (archivos de recursos)

En el directorio src/main/java escribiremos el código, y en application.properties las configuraciones.

Implementación de CustomerService

1. Modelo de datos: clase Customer

Crea la entidad Customer que representará al cliente.

package com.example.customerservice.model;

import jakarta.persistence.*;

@Entity // Indica que esto es una entidad JPA
public class Customer {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private String email;

    // Getters y setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

Hemos usado las anotaciones JPA:

• @Entity convierte la clase en una entidad de base de datos.
• @Id y @GeneratedValue marcan el campo id como clave primaria con autogeneración.

2. Repositorio: CustomerRepository

Crea la interfaz para acceder a los datos.

package com.example.customerservice.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import com.example.customerservice.model.Customer;

public interface CustomerRepository extends JpaRepository<Customer, Long> {
}

Spring Data JPA generará automáticamente los métodos para trabajar con la base de datos (por ejemplo, save, findAll, deleteById).

3. Controlador: CustomerController

Crea una API REST para gestionar clientes.

package com.example.customerservice.controller;

import com.example.customerservice.model.Customer;
import com.example.customerservice.repository.CustomerRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/customers")
public class CustomerController {

    @Autowired
    private CustomerRepository customerRepository;

    @GetMapping
    public List<Customer> getAllCustomers() {
        return customerRepository.findAll();
    }

    @PostMapping
    public Customer createCustomer(@RequestBody Customer customer) {
        return customerRepository.save(customer);
    }

    @DeleteMapping("/{id}")
    public void deleteCustomer(@PathVariable Long id) {
        customerRepository.deleteById(id);
    }
}

Aquí hemos creado tres endpoints:

1. GET /customers: obtener todos los clientes.
2. POST /customers: crear un nuevo cliente.
3. DELETE /customers/{id}: eliminar un cliente.

Ejecución y pruebas

1. Configuración de la base de datos
   Añade en application.properties la configuración para H2 (base de datos embebida, para no complicarte al principio):

   
   spring.datasource.url=jdbc:h2:mem:testdb
   spring.datasource.driver-class-name=org.h2.Driver
   spring.datasource.username=sa
   spring.datasource.password=password
   spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
   

2. Ejecutar la aplicación
   Arranca la clase CustomerServiceApplication (contiene el método main). La app arrancará en http://localhost:8080.
3. Probar la API
   Usa Postman o cURL:

• Obtener clientes:
  

  curl -X GET http://localhost:8080/customers
  

• Crear cliente:
  

  curl -X POST http://localhost:8080/customers -H "Content-Type: application/json" -d '{"name":"John Doe","email":"john.doe@example.com"}'
  

Extras útiles de Spring Boot para microservicios

Ahora tienes un microservicio funcionando. Pero Spring Boot ofrece muchas funcionalidades interesantes:

• Escalado sencillo: cada microservicio es una app independiente que puedes ejecutar por separado.
• Facilidad de integración con Kafka, API Gateway y otras herramientas (lo veremos en próximas lecciones).
• Configuración cómoda vía application.yml: temas de múltiples perfiles y gestión de entornos se tratarán en próximas lecciones.

En este punto tienes una visión básica de cómo Spring Boot ayuda a desarrollar rápidamente un microservicio funcional.