Itinerario del curso: profundización y novedades

Profundización contra novedad

El curso introduce decenas de conceptos nuevos, pero también profundiza en territorio conocido. Distinguir ambas categorías ayuda al alumno a calibrar el esfuerzo: una técnica que parte de algo familiar (slice tests a partir de tests integrales con @SpringBootTest) requiere menos rampa que una completamente desconocida (AOP con @Aspect o mutation testing con PIT).

Esta tabla resume la situación. La columna profundización muestra temas que extienden algo del nivel intermedio. La columna novedad muestra temas que el alumno ve por primera vez.

| Bloque | Profundización (extiende algo conocido) | Novedad (concepto nuevo) | |--------|----|----| | M2 Productividad senior | Lombok complementa el modelado de POJOs ya conocido. ProblemDetails extiende @RestControllerAdvice. | AOP con @Aspect, ApplicationEvents, @Async, Spring Cache abstraction, Flyway, multi-datasource, Hibernate Envers. | | M3 JPA avanzado | Entity Graphs extiende fetch = LAZY/EAGER conocido. Locking optimista extiende @Version. @Transactional propagation extiende la @Transactional básica. | Criteria Builder dinámico, locking pesimista, HikariCP tuning detallado. | | M4 Mensajería Kafka | — | Toda la stack: instalación, KafkaTemplate, @KafkaListener, Kafka Streams, EmbeddedKafka. | | M5 WebFlux completo | — | Toda la stack reactiva: Mono/Flux, R2DBC, SSE, backpressure, error handling reactivo, StepVerifier. | | M6 Testing avanzado | Slice tests extienden @SpringBootTest. | ArchUnit, PIT mutation testing, WireMock, Spring REST Docs, Pact contracts. | | M7 Observabilidad | — | Actuator detallado, Micrometer, Prometheus, OpenTelemetry, Observation API. | | M8 Spring Boot 4 moderno | RestClient extiende RestTemplate. @HttpExchange extiende la idea de OpenFeign sin Spring Cloud. | Virtual Threads, ProblemDetails, Native AOT, Docker Compose Support, @MockitoBean. |

Cuatro módulos completos (Mensajería Kafka, WebFlux, Observabilidad y la mayoría de Spring Boot 4) son territorio nuevo en su totalidad. Los otros cuatro mezclan profundización y novedad. Esto explica que el curso pese cerca de 45 horas: aproximadamente dos tercios del contenido es novedad pura.

Recorrido módulo a módulo

El orden de los módulos no es arbitrario. Cada uno construye sobre el anterior y prepara para el siguiente. El alumno que sigue el orden propuesto encuentra una progresión natural.

graph TD
    M1[M1 - Introduccion al curso]
    M2[M2 - Productividad senior]
    M3[M3 - JPA avanzado]
    M4[M4 - Mensajeria Kafka]
    M5[M5 - WebFlux completo]
    M6[M6 - Testing avanzado]
    M7[M7 - Observabilidad]
    M8[M8 - Spring Boot 4 moderno]
    M1 --> M2
    M2 --> M3
    M3 --> M4
    M4 --> M5
    M5 --> M6
    M6 --> M7
    M7 --> M8

Módulo 1: introducción al curso

Tres lecciones de bienvenida (esta es la tercera). Panorama de las áreas, repaso de prerrequisitos del nivel intermedio e itinerario por módulo. Sin sintaxis nueva.

Módulo 2: productividad y patrones de equipo senior

Pasa de escribir código que funciona a escribir código que un equipo grande pueda mantener. Resuelve el problema clásico de la duplicación de boilerplate (Lombok), la configuración multi-entorno (profiles, @ConfigurationProperties), el manejo profesional de errores, los patrones de desacoplamiento (AOP, ApplicationEvents) y los patrones de operación (cache, scheduled, async, Flyway, multi-datasource, Envers). Es el módulo con más impacto inmediato en el día a día.

Módulo 3: persistencia avanzada con JPA

Cambia el foco de "cargar datos" a "cargar datos rápido y de forma segura bajo concurrencia". Aborda Entity Graphs, Criteria Builder dinámico, optimización del problema N+1, locking optimista y pesimista, propagation/isolation de @Transactional y HikariCP tuning. Imprescindible para aplicaciones con base de datos grande.

Módulo 4: mensajería con Apache Kafka

Introduce el paradigma event-driven. Instalación, configuración, KafkaTemplate, @KafkaListener, Kafka Streams para procesamiento en tiempo real y testing con EmbeddedKafka. Es el módulo más denso a nivel arquitectónico de la primera mitad del curso.

Módulo 5: programación reactiva con Spring WebFlux completo

Recorre WebFlux de principio a fin: Mono/Flux, operadores básicos y avanzados, APIs reactivas con anotaciones y router functions, WebClient, R2DBC, repositorios reactivos, Server-Sent Events, backpressure, propagación de contexto reactivo, error handling reactivo, integración con Kafka reactivo y testing con StepVerifier. Es el módulo más extenso (15 lecciones).

Módulo 6: testing avanzado complementario

Introduce las técnicas que diferencian un proyecto con tests serios de un proyecto que dice tener tests serios: slice tests para velocidad, ArchUnit para tests de arquitectura, PIT para mutation testing, WireMock para mocking HTTP, Spring REST Docs para documentación y Pact para consumer-driven contracts.

Módulo 7: observabilidad en producción

Cinco lecciones para que la aplicación no sea una caja negra en producción: Actuator, logging estructurado, Micrometer con Prometheus, trazas con Observation API y OpenTelemetry.

Módulo 8: Spring Boot 4 y Spring Framework 7 moderno

Cierra el curso con las novedades del stack moderno: Virtual Threads, RestClient, @HttpExchange, ProblemDetails, Observation API, Native AOT, Docker Compose Support y bean override testing con @MockitoBean.

Aplicación práctica por perfil profesional

El curso se cursa completo y en orden. Las ocho áreas forman parte del perfil senior esperado y se evalúan de forma integrada en el proyecto final. Esta sección no es un mapa de "qué estudiar y qué saltar"; es una orientación sobre qué bloques aparecerán con más frecuencia en el día a día del alumno una vez termine el curso, según el rol profesional al que se dedique.

Backend senior

El backend senior usará a diario los módulos 2 y 3: productividad senior (Lombok, profiles, errores, AOP, eventos, cache) y JPA avanzado (Entity Graphs, N+1, locking, propagation). El módulo 6 (testing) aparece en cada PR. El módulo 7 (observabilidad) lo cruza cuando un endpoint va lento en producción. Los módulos 4 (Kafka), 5 (WebFlux) y 8 (Spring Boot 4) son menos frecuentes pero forman parte del mapa mental que distingue a un senior: entender por qué un endpoint reactivo es más eficiente para IO-bound, qué hace @KafkaListener cuando llega un evento, o cómo funciona Native AOT mejora la conversación con el resto del equipo.

Tech lead y arquitecto

El tech lead usa a diario los módulos 6 y 7: testing avanzado (especialmente ArchUnit para defender la arquitectura) y observabilidad (para tomar decisiones basadas en datos). El módulo 4 (Kafka) lo cruza cada vez que el equipo discute si una integración debe ser síncrona o asíncrona. El módulo 8 (Spring Boot 4) aparece en cada decisión de stack: cuándo migrar, qué nuevas APIs adoptar.

Backend que migra a reactive

El profesional que migra una API tradicional a WebFlux usa a diario el módulo 5 completo: operadores reactivos, R2DBC, error handling reactivo, testing con StepVerifier, propagación de contexto. El módulo 7 (observabilidad reactiva con Observation API) es crítico porque el debugging reactivo es más difícil sin trazas correlacionadas.

Backend que opera Kafka

El profesional que mantiene pipelines event-driven usa a diario el módulo 4 completo: configuración de productores y consumidores con commits manuales, Kafka Streams para agregaciones, testing con EmbeddedKafka. Combina con el módulo 5 cuando integra Kafka con WebFlux.

La conclusión común: completa el curso entero. La diferencia entre perfiles está en qué partes te resultarán más familiares al día siguiente de terminarlo, no en qué partes puedes saltarte.

Qué entrega el curso al completarse

Al completar todos los módulos y el proyecto integrador final, el alumno termina con un conjunto de competencias verificables alineadas con un puesto de Spring Boot senior:

• 1. Productividad de equipo: capacidad de aplicar Lombok, profiles, errores con ProblemDetails, AOP, ApplicationEvents, scheduled, async y cache de forma idiomática.
• 2. Persistencia profesional: criterio para optimizar consultas con Entity Graphs, resolver N+1 con la técnica adecuada, aplicar locking, gestionar @Transactional con propagation correcto y afinar HikariCP.
• 3. Mensajería event-driven: capacidad de diseñar un pipeline Kafka con productores, consumidores, Kafka Streams y testing con EmbeddedKafka.
• 4. Programación reactiva: capacidad de construir una API WebFlux completa con R2DBC, SSE, backpressure y error handling reactivo, y de probarla con StepVerifier.
• 5. Testing profesional: criterio para elegir entre slice tests y tests integrales, escribir tests de arquitectura con ArchUnit, medir cobertura de mutación con PIT, mockear HTTP con WireMock y coordinar contratos con Pact.
• 6. Observabilidad y operación: capacidad de instrumentar una aplicación con Actuator, Micrometer, Prometheus y OpenTelemetry, y de leer trazas distribuidas para diagnosticar incidencias.
• 7. Stack moderno: dominio de las novedades de Spring Boot 4 / Spring 7 sobre Java 25 LTS: Virtual Threads, RestClient, @HttpExchange, ProblemDetails, Native AOT, Docker Compose Support y bean override en tests.

El proyecto integrador final consiste en una API REST CRUD que reúne profile-aware configuration, Lombok + records, manejo de errores con ProblemDetails, AOP para auditoría, eventos para desacoplamiento, caching con Caffeine, migraciones con Flyway, observabilidad con Actuator y Micrometer, tests con slices y ArchUnit, y compilación AOT a binario nativo. Es la prueba práctica de que las técnicas se aplican de forma integrada y no aisladas.

A partir de aquí, la primera lección del módulo siguiente entra de lleno en el material avanzado con Lombok aplicado a Spring Boot.