Aprender arquitectura de microservicios con Java y Spring Boot es hoy una habilidad clave para cualquier desarrollador backend que quiera escalar aplicaciones modernas. Este tutorial paso a paso te guía desde los fundamentos hasta la implementación práctica, sin rodeos y orientado a resultados. Al finalizar, tendrás un microservicio funcional listo para desplegar.
¿Qué es un microservicio y por qué usar Spring Boot?
Un microservicio es una unidad de software independiente que se comunica con otros servicios a través de APIs ligeras. Spring Boot simplifica su creación al ofrecer configuración automática, servidor embebido y ecosistema maduro. Con Java, obtienes tipado fuerte, rendimiento y portabilidad. Para dominar estos conceptos a nivel experto, puedes explorar el curso especializado en microservicios con Java que profundiza en patrones y prácticas de producción.
Paso 1: Configura tu proyecto base con Spring Initializr
Accede a start.spring.io y selecciona las siguientes dependencias:
- Spring Web – para crear APIs REST.
- Spring Data JPA – para persistencia en base de datos.
- H2 Database – base en memoria para desarrollo.
- Lombok – reduce código boilerplate.
Genera el proyecto, impórtalo en tu IDE favorito (IntelliJ o Eclipse) y verifica que la clase principal @SpringBootApplication se ejecute sin errores.
Paso 2: Crea un controlador REST básico
Dentro del paquete principal, crea una clase ProductoController anotada con @RestController y mapea una ruta /api/productos. Implementa un método GET que devuelva una lista estática de productos. Spring Boot serializa automáticamente a JSON gracias a Jackson.
@RestController
@RequestMapping("/api/productos")
public class ProductoController {
@GetMapping
public List<String> listar() {
return List.of("Laptop", "Mouse", "Teclado");
}
}Ejecuta la aplicación y prueba con curl localhost:8080/api/productos. Este pequeño endpoint es ya un microservicio funcional. Si quieres llevar esta técnica a un nivel profesional, el curso de microservicios con Java te enseña a manejar autenticación, balanceo de carga y tolerancia a fallos.
Paso 3: Agrega persistencia con Spring Data JPA
Define una entidad Producto con @Entity, campos id, nombre y precio. Crea una interfaz ProductoRepository que extienda JpaRepository. Luego modifica el controlador para inyectar el repositorio y usar métodos como findAll() y save().
Con H2 activo, Spring Boot crea las tablas automáticamente. Esto te permite probar operaciones CRUD sin configurar una base de datos externa. La combinación de JPA y H2 acelera el desarrollo iterativo.
Paso 4: Implementa comunicación entre microservicios
En arquitecturas reales, los servicios se llaman entre sí. Agrega un segundo microservicio servicio-pedidos que consuma servicio-productos usando RestTemplate o WebClient. Para evitar acoplamiento directo, utiliza un descubridor de servicios como Eureka, pero en este tutorial basta con URLs fijas en application.properties.
@Bean
public RestTemplate restTemplate() {
return new RestTemplate();
}Luego en el controlador de pedidos, llama a restTemplate.getForObject("http://localhost:8081/api/productos", List.class). Este patrón es la base de sistemas distribuidos.
Paso 5: Configura un gateway con Spring Cloud Gateway
Un API Gateway centraliza rutas, seguridad y límites de peticiones. Añade la dependencia spring-cloud-starter-gateway y define rutas en application.yml:
spring:
cloud:
gateway:
routes:
- id: productos
uri: http://localhost:8081
predicates:
- Path=/api/productos/**
- id: pedidos
uri: http://localhost:8082
predicates:
- Path=/api/pedidos/**Al probar, el gateway redirige automáticamente al servicio correcto. Esto mejora la escalabilidad y el mantenimiento.
Paso 6: Agrega tolerancia a fallos con Resilience4j
En microservicios, un fallo en cadena puede tumbar todo el sistema. Resilience4j ofrece circuit breaker, retry y time limiter. Añade la dependencia spring-cloud-starter-circuitbreaker-resilience4j y anota un método del controlador con @CircuitBreaker:
@GetMapping
@CircuitBreaker(name = "productos", fallbackMethod = "fallbackProductos")
public List<Producto> listar() {
return repositorio.findAll();
}
public List<Producto> fallbackProductos(Exception e) {
return List.of(new Producto(0L, "Producto no disponible", 0.0));
}Esta técnica es clave en entornos productivos. Si quieres dominar estos patrones avanzados, revisa el temario de microservicios con Java donde se cubren en detalle.
Paso 7: Prueba, empaqueta y despliega
Usa JUnit 5 y MockMvc para probar los endpoints. Genera el JAR con mvn clean package y ejecuta con java -jar target/mi-servicio.jar. Para despliegues modernos, crea un Dockerfile con una imagen base de OpenJDK 17 y expón el puerto 8080.
FROM openjdk:17-jdk-slim
COPY target/*.jar app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]Construye la imagen con docker build -t mi-servicio . y ejecuta con docker run -p 8080:8080 mi-servicio. Tu microservicio ahora corre en contenedor, listo para orquestarse con Kubernetes.
Próximos pasos en tu aprendizaje
Este tutorial te ha dado una base sólida para construir microservicios con Java y Spring Boot. Para profundizar en temas como eventos asíncronos con Kafka, seguridad OAuth2 o monitoreo con Prometheus, te recomiendo el curso completo de microservicios con Java que incluye proyectos reales y acompañamiento de instructores.
La clave está en practicar cada paso, probar fallos y escalar gradualmente. Con esta guía, tienes el mapa; ahora toca ejecutar.
