De Java a producción en la nube, en 3 semanas o 1 mes
Material completo, autocontenido y sin conexión: 13 módulos con teoría condensada, código listo para ejecutar, errores típicos, checklists de repaso, preguntas de entrevista y un proyecto final integrador. Diseñado para alguien que ya programa y quiere ponerse al día con el stack Java empresarial actual (Java 17/21, Spring Boot 3, contenedores, cloud, observabilidad e IA).
Has marcado 0 tareas de 0 registradas. El total crece a medida que visitas cada módulo, porque cada página aporta sus propias tareas.
Cómo usar este material
Reglas de oro
- 70% teclado, 30% lectura. Cada concepto se fija escribiendo código, no leyendo sobre él.
- Un proyecto que crece contigo. Todo lo que aprendes se añade al proyecto final (módulo 13); no hagas 20 demos sueltas.
- Explícalo en voz alta. Si no puedes explicar
@Transactionalo un índice B-tree en 60 segundos, no lo sabes todavía. - Repaso espaciado. Al inicio de cada día, 10 minutos repasando las checklists del día anterior.
- Marca las tareas. Las casillas se guardan solas; la barra de arriba te dice cuánto llevas.
Dos ritmos posibles
| Ritmo | Duración | Horas/día | Qué se recorta |
|---|---|---|---|
| Intensivo | 3 semanas (21 días) | 6–8 h | Nada: se juntan los días marcados como “fusionable” y se estudia también el fin de semana. |
| Sostenible | 4 semanas (1 mes) | 3–4 h | Nada: 5 días por semana + 1 día de repaso y proyecto. |
| Mínimo viable | 10 días | 6 h | Solo módulos 01, 02, 04, 05, 06, 09 y 12 (los marcados crítico). |
Atajo de teclado: pulsa / para buscar cualquier tema desde cualquier página.
Entorno de trabajo (haz esto hoy, antes del día 1)
Plan día a día
Cada día tiene un objetivo único y verificable. Marca la casilla solo cuando hayas escrito el código, no cuando hayas leído la teoría.
Semana 1 · Java moderno de verdad
Módulos 01–03 Objetivo: escribir Java 21 idiomático y razonar sobre memoria y concurrenciaFundamentos y POO con criterio · Módulo 01
Tipos, String pool e inmutabilidad, equals/hashCode, interfaces vs clases abstractas, composición sobre herencia, SOLID aplicado a código real.
Colecciones, complejidad y Streams · Módulo 01
ArrayList vs LinkedList, HashMap por dentro, TreeMap, Comparator; Streams, Collectors, Optional sin abusar.
JVM, memoria y recolección de basura · Módulo 01
Heap/stack/metaspace, ciclo de vida de un objeto, G1 vs ZGC, fugas de memoria, lectura de un OutOfMemoryError, flags esenciales y contenedores.
Java 11 y 17: lo que cambió tu forma de escribir · Módulo 02
var, HttpClient, API de String, records, sealed interfaces, switch con patrones, text blocks, instanceof con patrón.
Java 21 y migración · Módulo 02
Pattern matching para records, sequenced collections, SequencedMap, novedades 22–25 que ya se usan, y la ruta real de migración Java 8 → 17/21 (javax → jakarta).
Concurrencia clásica + virtual threads · Módulo 03
ExecutorService, CompletableFuture, synchronized vs Lock, colecciones concurrentes, volatile y happens-before; virtual threads y concurrencia estructurada.
Repaso activo + kata fusionable
Sin material delante: reescribir de memoria los ejemplos clave y resolver 2 katas (procesar CSV con streams; caché LRU con LinkedHashMap).
Semana 2 · Spring Boot, datos y tests
Módulos 04–07 Objetivo: una API REST con persistencia real, transacciones y tests de integraciónSpring Core: IoC, DI y ciclo de vida · Módulo 04
Contenedor, beans, scopes, inyección por constructor, @Configuration, autoconfiguración de Boot, @ConditionalOn…, arranque explicado paso a paso.
API REST profesional · Módulo 04
Diseño de recursos, validación con Bean Validation, manejo global de errores con ProblemDetail (RFC 9457), paginación, versionado, OpenAPI, perfiles y Actuator.
SQL en serio · Módulo 06
Modelado y normalización, joins, agregados, funciones de ventana, CTEs, índices, EXPLAIN ANALYZE, transacciones y niveles de aislamiento en PostgreSQL.
Spring Data JPA e Hibernate · Módulo 05
Entidades y relaciones, lazy vs eager, el problema N+1, @EntityGraph, DTO projections, cerrojos optimistas, caché de primer nivel, Flyway.
Transacciones y concurrencia de datos · Módulo 05
@Transactional de verdad: propagación, readOnly, rollback, autoinvocación que no funciona, pérdidas de actualización, @Version, idempotencia.
Testing y calidad · Módulo 07
JUnit 5, Mockito sin abusar, @SpringBootTest vs slices, MockMvc/WebTestClient, Testcontainers, datos de prueba, cobertura útil y test de mutación.
Repaso + refactor del proyecto fusionable
Aplicar arquitectura por capas/hexagonal al proyecto, revisar nombres, quitar lógica de los controladores y dejar la suite verde.
Semana 3 · Sistemas distribuidos y contenedores
Módulos 08–09 Objetivo: dos servicios comunicándose por Kafka, empaquetados y desplegados en KubernetesArquitectura: monolito modular, DDD y microservicios · Módulo 08
Cuándo NO usar microservicios, límites de contexto, arquitectura hexagonal, contratos, API gateway, service discovery, config centralizada.
Comunicación entre servicios y resiliencia · Módulo 08
REST vs mensajería vs gRPC, timeouts y reintentos con jitter, circuit breaker, bulkhead, rate limiting, degradación elegante, idempotencia.
Kafka y eventos · Módulo 08
Topics, particiones, claves, consumer groups, offsets, entrega at-least-once, orden, DLQ, patrón outbox, saga vs 2PC, event-driven sin perder datos.
Docker y empaquetado de aplicaciones Java · Módulo 09
Imágenes multi-stage, capas y caché, JVM en contenedores (memoria y CPU), usuario no root, distroless, Jib, docker compose para el entorno local.
Kubernetes esencial · Módulo 09
Pods, Deployments, Services, Ingress, ConfigMaps y Secrets, probes, requests/limits, HPA, rolling updates y rollback; depuración con kubectl.
Observabilidad y CI/CD · Módulos 08–09
Logs estructurados con correlación, métricas RED/USE, trazas distribuidas con OpenTelemetry, alertas y SLO; pipeline de GitHub Actions con tests, escaneo y publicación de imagen.
Repaso + prueba de carga fusionable
Medir antes de optimizar: k6 o JMeter contra tu API, encontrar el cuello de botella (¿pool de conexiones? ¿N+1? ¿GC?) y documentar la mejora.
Semana 4 · Cloud, seguridad, IA y entrevistas
Módulos 10–13 Objetivo: app segura en la nube, temas de actualidad y entrevista preparadaCloud para desarrolladores Java · Módulo 09
Modelos IaaS/PaaS/CaaS/FaaS, equivalencias AWS ↔ Azure ↔ GCP, cómputo, almacenamiento, bases gestionadas, colas, IAM, redes básicas, coste y regiones.
Serverless, IaC y 12-Factor · Módulo 09
Lambda con Java (cold start, SnapStart), S3 y colas, Terraform básico, secretos gestionados, configuración por entorno, aplicaciones sin estado.
Seguridad de aplicaciones · Módulo 10
Spring Security 6: filtros, autenticación, autorización por método, JWT vs sesión, OAuth2/OIDC con Keycloak, CORS y CSRF, hashing de contraseñas, gestión de secretos.
Temas de actualidad: IA, GraalVM, nuevas prácticas · Módulo 11
Spring AI, RAG con vector store, MCP, uso responsable de asistentes de código, GraalVM native image, CDS/AppCDS, Kotlin y Quarkus/Micronaut en el panorama actual.
Entrevista técnica: preguntas y código · Módulo 12
120 preguntas con respuesta modelo, cómo estructurar una respuesta en 90 segundos, live coding sin pánico, preguntas de comportamiento con método STAR.
System design y trade-offs · Módulo 12
Plantilla de diseño en 45 minutos, cálculo de capacidad, caché, particionado, consistencia, colas, CAP en la práctica; tres diseños resueltos.
Cierre: proyecto, README y portfolio · Módulo 13
Documentar el proyecto como si fuera de empresa: README con arquitectura, decisiones (ADR), instrucciones de arranque, diagrama, demo y plan de mejoras.
Los 13 módulos
Cada módulo es autónomo: teoría breve, código comentado, errores frecuentes, checklist y preguntas de entrevista.
Java Core y POO
Tipos, inmutabilidad, colecciones, streams, excepciones, genéricos, JVM, memoria y GC.
Java 8 → 25 (11 · 17 · 21 LTS)
Qué aporta cada versión, records, sealed, pattern matching, y cómo migrar sin dolor.
Concurrencia y virtual threads
Executors, CompletableFuture, modelo de memoria, Loom y concurrencia estructurada.
Spring Framework y Spring Boot 3
IoC/DI, autoconfiguración, REST, validación, errores, perfiles, Actuator y métricas.
Spring Data JPA e Hibernate
Entidades, relaciones, N+1, proyecciones, transacciones, bloqueos y Flyway.
Bases de datos y SQL
Modelado, joins, ventanas, índices, planes de ejecución, aislamiento, NoSQL y Redis.
Testing y calidad
JUnit 5, Mockito, slices de Spring, Testcontainers, cobertura, mutación y contratos.
Microservicios y arquitectura
DDD, hexagonal, gateway, resiliencia, Kafka, saga/outbox, CQRS y observabilidad.
Docker, Kubernetes y cloud
Imágenes, compose, K8s, CI/CD, AWS/Azure/GCP, serverless, Terraform y 12-Factor.
Seguridad de aplicaciones
Spring Security 6, JWT, OAuth2/OIDC, OWASP Top 10, secretos y cadena de suministro.
Actualidad 2026
Spring AI, RAG, MCP, GraalVM nativo, plataformas alternativas y tendencias reales.
Entrevistas técnicas
120 preguntas con respuesta, katas de código, system design y preguntas de conducta.
Recursos y proyecto final
Documentación oficial, libros, canales, y el proyecto integrador paso a paso.
Mapa mental del stack
┌──────────────────────────────┐
│ Java (11 / 17 / 21) │ ← módulos 01·02·03
│ lenguaje · JVM · memoria │
└───────────────┬──────────────┘
│
┌───────────────────────┼────────────────────────┐
▼ ▼ ▼
┌──────────────────┐ ┌────────────────────┐ ┌────────────────────┐
│ Spring Boot 3 │ │ Persistencia │ │ Testing │
│ IoC · REST · AOP │ │ JPA · SQL · Redis │ │ JUnit5 · TC · PIT │
│ módulo 04 │ │ módulos 05·06 │ │ módulo 07 │
└────────┬─────────┘ └─────────┬──────────┘ └─────────┬──────────┘
└───────────────┬───────┴────────────────────────┘
▼
┌───────────────────────────────┐
│ Arquitectura distribuida │ ← módulo 08
│ DDD · Kafka · resiliencia │
│ observabilidad · saga/outbox │
└───────────────┬───────────────┘
▼
┌───────────────────────────────┐
│ Entrega y operación │ ← módulo 09
│ Docker · K8s · CI/CD · Cloud │
└───────────────┬───────────────┘
▼
┌────────────────────────────────────────┐
│ Seguridad (10) · Actualidad/IA (11) │
│ Entrevistas (12) · Proyecto (13)│
└────────────────────────────────────────┘Lee el mapa de arriba abajo: sin el lenguaje no hay framework, sin persistencia no hay negocio, sin tests no hay entrega, y sin operación no hay producción. Las entrevistas preguntan de todas las capas.
Autoevaluación inicial (5 minutos)
Marca lo que ya dominas. Lo que quede sin marcar es exactamente por donde debes empezar.
0–4 marcas: sigue el plan completo de 4 semanas. 5–8: haz el intensivo de 3 semanas saltando lo que dominas. 9–12: ve directo a los módulos 08, 09, 11 y 12.