🚀 Guía de Estudio: Java + Spring Boot desde Cero

De Cero a Portfolio — Construye un sistema real con impacto

Para quién es esta guía: Desarrolladores con experiencia en otros lenguajes que nunca han tocado Java ni Spring Boot. Resultado final: Una API REST de producción desplegada en AWS, lista para mostrar en tu portafolio.

---

📌 El Proyecto: EduTrack API

Una plataforma de seguimiento académico para instituciones educativas. El sistema permite:

• Gestionar estudiantes, cursos e inscripciones
• Registrar calificaciones y generar reportes de progreso
• Autenticación JWT con roles (ADMIN, MAESTRO, ESTUDIANTE)
• Documentación automática con Swagger/OpenAPI

¿Por qué impacta en el portafolio? EdTech es uno de los sectores más demandados. Un sistema académico demuestra dominio de relaciones complejas entre entidades, seguridad real, y arquitectura en capas — exactamente lo que buscan los reclutadores para roles de Backend Senior.

---

🗺️ Mapa de Ruta

Fase 1 → Fundamentos de Java              (2 semanas)
Fase 2 → Spring Boot Core + Proyecto base (2 semanas)
Fase 3 → Base de datos con JPA/Hibernate  (1.5 semanas)
Fase 4 → Service Layer completo           (1 semana)
Fase 5 → Seguridad JWT                    (1.5 semanas)
Fase 6 → Swagger, Tests y Calidad         (1 semana)
Fase 7 → Despliegue en AWS                (1 semana)
                                   ─────────────────────
                                   Total: ~10 semanas

---

⚙️ Configuración del Entorno

Herramientas necesarias

Herramienta	Versión recomendada	Propósito
JDK (Temurin)	21 LTS	Compilar y ejecutar Java
IntelliJ IDEA Community	Latest	IDE (el mejor para Java)
Maven Wrapper	incluido en proyecto	Gestor de dependencias
Docker Desktop	Latest	Base de datos local
Postman	Latest	Probar endpoints
Git	Latest	Control de versiones

Instalación del JDK

# macOS con Homebrew
brew install --cask temurin@21

# Windows — descargar instalador desde:
# https://adoptium.net/temurin/releases/?version=21

# Linux (Ubuntu/Debian)
sudo apt install temurin-21-jdk

# Verificar instalación
java --version
# Debe mostrar: openjdk 21.x.x ... Temurin-21
javac --version
# Debe mostrar: javac 21.x.x

Base de datos con Docker

# Levantar PostgreSQL local (solo para desarrollo)
docker run --name edutrack-db \
  -e POSTGRES_USER=edutrack \
  -e POSTGRES_PASSWORD=secret123 \
  -e POSTGRES_DB=edutrack_dev \
  -p 5432:5432 \
  -d postgres:16-alpine

# Verificar que está corriendo
docker ps
# Conectar con psql (opcional)
docker exec -it edutrack-db psql -U edutrack -d edutrack_dev

---

---

FASE 1: Fundamentos de Java

Duración: 2 semanas Objetivo: Entender el lenguaje antes de tocar el framework

---

1.1 — ¿Por qué Java? El ecosistema

📖 Teoría

Java es un lenguaje de programación orientado a objetos, fuertemente tipado y compilado creado por Sun Microsystems en 1995. Su principio fundacional es WORA (Write Once, Run Anywhere): el código fuente se compila a bytecode (.class), que es ejecutado por la JVM (Java Virtual Machine) en cualquier sistema operativo.

Diferencias clave vs PHP/Node.js:

Aspecto	PHP / Node.js	Java
Tipado	Dinámico	Estático (fuerte)
Concurrencia	Event Loop / Async/Await	Threads nativos + Virtual Threads (Java 21)
Ejecución	Interpretado	Compilado a bytecode + JIT
Arranque	Inmediato	JVM tiene warm-up (~1-3s)
Memoria	GC del runtime	JVM con Garbage Collector tunable
Error detection	Runtime (muchos bugs en prod)	Compile-time (el compilador atrapa más bugs)

¿Por qué Java sigue siendo dominante en backends? La JVM es extremadamente madura. El JIT (Just-In-Time) compiler optimiza el código en tiempo de ejecución — para sistemas que corren 24/7 (bancos, e-commerce a escala), el rendimiento sostenido supera a lenguajes interpretados.

Maven — el gestor de dependencias: Maven es el equivalente a composer (PHP) o npm (Node). Las dependencias se declaran en pom.xml y Maven las descarga del repositorio central (Maven Central). El Maven Wrapper (mvnw) incluye Maven dentro del proyecto para que todos usen la misma versión sin instalarlo globalmente.

---

1.2 — Tipos, Variables y Estructuras de Control

📖 Teoría

Java es fuertemente tipado: cada variable debe declararse con su tipo explícito y no puede cambiar de tipo en tiempo de ejecución. Esto elimina una clase entera de bugs comunes en lenguajes dinámicos (PHP/JS con == vs ===, por ejemplo).

Dos universos de tipos:

Java tiene tipos primitivos (almacenados en el stack, ultra-eficientes, no son objetos) y tipos objeto/referencia (en el heap, tienen métodos). Para cada primitivo existe una clase wrapper que lo convierte en objeto cuando se necesita (colecciones, generics).

Primitivo	Wrapper	Tamaño	Equivalente PHP/JS
int	Integer	32 bits	int / number
long	Long	64 bits	int grande
double	Double	64 bits	float / number
boolean	Boolean	1 bit	bool / boolean
char	Character	16 bits	(no directo)

Autoboxing: Java convierte automáticamente entre primitivos y wrappers cuando es necesario. int x = 5; Integer obj = x; — Java hace el "boxing" implícito.

String en Java: Los String son inmutables — cada operación de concatenación crea un nuevo objeto en el heap. Para construir strings de forma eficiente en bucles, se usa StringBuilder.

var (Java 10+): Inferencia de tipo local. El compilador determina el tipo en tiempo de compilación — el tipo no cambia en runtime. Equivalente al auto de C++ o la inferencia de TypeScript.

💻 Práctica

Crea el archivo src/JavaBasics.java y ejecútalo con java JavaBasics.java:

import java.util.ArrayList;
import java.util.List;

public class JavaBasics {

    public static void main(String[] args) {

        // ── Tipos primitivos ─────────────────────────────────
        int edad = 25;
        long matriculaId = 1_000_000L;   // L al final = literal Long
        double promedio = 8.75;
        boolean activo = true;

        // ── Inferencia con var (Java 10+) ────────────────────
        var nombre = "Arturo";            // compilador infiere: String
        var lista = new ArrayList<String>(); // compilador infiere: ArrayList<String>

        // ── Strings ──────────────────────────────────────────
        String saludo = "Hola, " + nombre;       // Crea nuevo String (ineficiente en bucles)

        StringBuilder sb = new StringBuilder();  // Eficiente para concatenaciones múltiples
        sb.append("Hola").append(", ").append(nombre).append("!");
        String saludoEficiente = sb.toString();

        // Text Blocks (Java 15+) — strings multilínea sin escapes
        String json = """
                {
                    "nombre": "Arturo",
                    "rol": "Backend Developer"
                }
                """;

        // ── Control de flujo ─────────────────────────────────
        if (promedio >= 9.0) {
            System.out.println("Matrícula de honor");
        } else if (promedio >= 7.0) {
            System.out.println("Aprobado");
        } else {
            System.out.println("Reprobado");
        }

        // Switch expression (Java 14+) — retorna un valor directamente
        String nivel = switch (edad / 10) {
            case 1      -> "Adolescente";
            case 2, 3   -> "Joven adulto";
            case 4, 5   -> "Adulto";
            default     -> "Senior";
        };
        System.out.println("Nivel: " + nivel);

        // ── Bucles ───────────────────────────────────────────
        for (int i = 0; i < 5; i++) {
            System.out.println("Iteración: " + i);
        }

        // Enhanced for (equivalente a foreach en PHP)
        int[] calificaciones = {8, 9, 7, 10, 6};
        for (int cal : calificaciones) {
            System.out.println("Calificación: " + cal);
        }

        // while
        int contador = 0;
        while (contador < 3) {
            System.out.println("Contador: " + contador);
            contador++;
        }

        // ── Casting ──────────────────────────────────────────
        double resultado = 10.7;
        int entero = (int) resultado;   // Cast explícito: trunca a 10 (no redondea)
        System.out.println("Cast: " + entero); // 10

        // Widening (automático, sin riesgo de pérdida)
        int pequeño = 100;
        long grande = pequeño;   // int → long automático
    }
}

---

1.3 — Programación Orientada a Objetos (POO)

📖 Teoría

Java es 100% orientado a objetos — todo código vive dentro de una clase. Los cuatro pilares de la POO son esenciales para entender Spring Boot, que los aplica en cada capa:

1. Encapsulamiento: Ocultar el estado interno de un objeto y exponer solo lo necesario a través de una interfaz pública. Se implementa con modificadores de acceso:

• private: solo accesible dentro de la misma clase
• protected: accesible en la misma clase y subclases
• package-private (sin modificador): accesible en el mismo paquete
• public: accesible desde cualquier lugar

2. Herencia: Una clase puede extend otra para reutilizar e interceptar comportamiento. Java tiene herencia simple (una sola clase padre). La palabra super llama al constructor o métodos del padre. @Override señala que un método sobreescribe al del padre (el compilador verifica que realmente exista en el padre).

3. Polimorfismo: Una variable de tipo A puede contener un objeto de tipo B si B extiende o implementa A. Esto permite que Spring inyecte cualquier implementación de una interfaz sin que el código que la usa sepa cuál es.

4. Abstracción: abstract class: clase que no puede instanciarse directamente, puede tener métodos abstractos (sin cuerpo) y concretos (con cuerpo). interface: contrato puro de lo que una clase debe hacer. Desde Java 8, puede tener métodos default con implementación. Una clase puede implementar múltiples interfaces — esto resuelve la limitación de herencia simple.

Records (Java 16+): Para clases que solo almacenan datos inmutables (DTOs, value objects). Un record genera automáticamente: constructor canónico, getters, equals(), hashCode() y toString(). Son la forma moderna de crear DTOs en Java sin boilerplate.

💻 Práctica

import java.util.ArrayList;
import java.util.List;

// ── Interface — contrato ──────────────────────────────────────────
public interface Evaluable {
    double calcularPromedio();    // abstracto por defecto en interfaces

    // Método default (Java 8+) — implementación base que las clases pueden sobreescribir
    default String obtenerNivel() {
        double prom = calcularPromedio();
        if (prom >= 9.0) return "Excelente";
        if (prom >= 7.0) return "Satisfactorio";
        return "Necesita mejora";
    }
}

// ── Clase abstracta — base compartida ────────────────────────────
public abstract class Persona {
    private final String nombre;  // final = no puede cambiar después de construir
    private String email;

    // Constructor
    public Persona(String nombre, S