Saltar al contenido principal

MÓDULO 2 - Primeros Pasos con Spring Boot

Objetivos del Módulo​

Este módulo le permitirá:

  • Dominar el uso de Spring Initializr para crear proyectos
  • Comprender la estructura de un proyecto Spring Boot
  • Configurar su entorno de desarrollo (Visual Studio Code)
  • Crear su primera aplicación REST
  • Utilizar las anotaciones básicas de Spring Boot

Contenido del Módulo​

Teoría​

Capítulo 1: Spring Initializr​

  • Qué es Spring Initializr
  • Configuración del proyecto (Maven, Java, Spring Boot)
  • Metadatos y parámetros
  • Gestión de dependencias y starters
  • Generación e importación del proyecto
  • Alternativas (CLI, API, IDE)

Capítulo 2: Estructura de un Proyecto Spring Boot​

  • Estructura completa de un proyecto
  • Rol del archivo pom.xml
  • Organización de los paquetes (Controller, Service, Repository, Model)
  • Directorios resources (static, templates)
  • Configuración con application.properties/yml
  • Convenciones de nomenclatura

Capítulo 3: Configuración​

  • Archivos application.properties y application.yml
  • Propiedades comunes de Spring Boot
  • Configuración de la base de datos
  • Configuración de logs
  • Propiedades personalizadas con @Value y @ConfigurationProperties
  • Gestión de perfiles (dev, test, prod)
  • Variables de entorno y seguridad

Capítulo 4: Anotaciones Básicas​

  • @SpringBootApplication y sus componentes
  • Anotaciones de estereotipo: @Component, @Service, @Repository
  • @RestController vs @Controller
  • Anotaciones de mapeo HTTP: @GetMapping, @PostMapping, @PutMapping, @DeleteMapping
  • @RequestParam, @PathVariable, @RequestBody
  • Inyección de dependencias con @Autowired

Capítulo 5: Introducción a los Repositories​

  • Qué es un Repository de Spring Data JPA
  • Los 4 métodos básicos heredados de JpaRepository
  • Convenciones de nomenclatura simples: findBy, And, Or
  • Crear una entidad JPA
  • Arquitectura completa Controller → Service → Repository
  • Ejemplos prácticos con la entidad User
  • Nota: Contenido simplificado para principiantes. Los conceptos avanzados (joins, JPQL, @Query) se verán en el Módulo 6

Prácticas​

TP2.1: Aplicación Greeting con VS Code​

Objetivo: Crear su primera aplicación Spring Boot REST

Contenido:

  • Configuración de Spring Initializr
  • Importación del proyecto en Visual Studio Code
  • Creación de un controlador REST simple
  • Prueba y depuración
  • Resolución de problemas comunes

Duración estimada: 2-3 horas

Prerrequisitos: JDK 17+, Maven, VS Code con extensiones Java

Nivel: Principiante

TP2.2: Base de Datos H2 - Memoria y Persistencia​

Objetivo: Dominar H2 en modo memoria y en modo archivo persistente

Contenido:

  • Parte 1: H2 en memoria (datos temporales)
  • Parte 2: H2 persistente (datos en disco)
  • Parte 3: Gestión avanzada con cambio de nombre de archivos
  • Diferencias entre los modos
  • Configuración de schema.sql y data.sql
  • Consola H2
  • 4 ejercicios prácticos
  • Uso de los 4 métodos básicos de JPA (findById, findAll, save, deleteById)

Duración estimada: 3-4 horas

Prerrequisitos: TP2.1 completado, Capítulo 5 (Repositories) leído

Nivel: Principiante

📚 Nota Importante: Reestructuración Pedagógica​

¿Dónde están TP3 y TP4?​

Si está buscando las prácticas avanzadas, han sido trasladadas a los módulos apropiados para una mejor progresión pedagógica:

TP3.1: Arquitectura CRUD → MÓDULO 3​

  • Nuevo nombre: TP3.1 del Módulo 3
  • Razón: Utiliza conceptos avanzados (Validación, ResponseEntity, Gestión de errores)
  • Prerrequisitos añadidos:
    • Capítulo 1: Service Layer en detalle
    • Capítulo 2: Validación de datos
    • Capítulo 3: Gestión de errores HTTP
    • Capítulo 4: Arquitectura profesional de 3 capas

TP4.1: PostgreSQL → MÓDULO 4​

  • Nuevo nombre: TP4.1 del Módulo 4
  • Razón: Utiliza conceptos de producción (PostgreSQL, Lombok, Jakarta, estrategias DDL)
  • Prerrequisitos añadidos:
    • Capítulo 1: PostgreSQL - Instalación y configuración
    • Capítulo 2: Jakarta vs Javax Persistence
    • Capítulo 3: Hibernate y estrategias DDL
    • Capítulo 4: Lombok

¿Por qué este cambio?​

Análisis pedagógico:

TP3 (anteriormente aquí): 60% de conceptos no enseñados
TP4 (anteriormente aquí): 80% de conceptos no enseñados

Impacto positivo:

  • ✅ Cada práctica ahora tiene TODA la teoría necesaria ANTES de comenzarla
  • ✅ Menos frustración y confusión
  • ✅ Aprendizaje más progresivo y eficaz
  • ✅ Mejor preparación para producción

Progresión Recomendada​

MÓDULO 2 (Bases)
├── 5 Capítulos teóricos
└── 2 Prácticas (TP2.1, TP2.2)
    ↓
MÓDULO 3 (Arquitectura Robusta)
├── 4 Capítulos teóricos
└── 1 Práctica (Arquitectura CRUD) ← Antiguo TP3 del Módulo 2
    ↓
MÓDULO 4 (Producción)
├── 4 Capítulos teóricos
└── 1 Práctica (PostgreSQL) ← Antiguo TP4 del Módulo 2

Prerrequisitos Técnicos​

Antes de comenzar este módulo, asegúrese de tener:

Software Requerido​

  1. JDK 17 o superior

  2. Visual Studio Code

  3. Extensiones para VS Code:

    • Extension Pack for Java (Microsoft)
    • Spring Boot Extension Pack (VMware)
    • Maven for Java (Microsoft)

  4. Maven 3.9+

Verificación de la Instalación​

# Verificar Java
java -version

# Verificar Maven
mvn -version

Duración Estimada​

Teoría: 6-8 horas (5 capítulos)
Práctica: 5-7 horas (TP2.1, TP2.2)
Total: 11-15 horas (2-3 sesiones de 4-6 horas)

Nota: El Módulo 2 ha sido simplificado para centrarse en los fundamentos. Las prácticas avanzadas (Arquitectura CRUD, PostgreSQL) ahora están en los Módulos 3 y 4 con la teoría correspondiente.

Recursos Adicionales​

Documentación Oficial​

Tutoriales Recomendados​

Criterios de Éxito​

Al finalizar este módulo, usted debería ser capaz de:

  • ✅ Crear un proyecto Spring Boot con Spring Initializr
  • ✅ Configurar Visual Studio Code para desarrollo Java/Spring
  • ✅ Crear y probar un controlador REST simple
  • ✅ Comprender la estructura de un proyecto Spring Boot
  • ✅ Configurar application.properties y application.yml
  • ✅ Utilizar las anotaciones básicas (@RestController, @Service, @Repository)
  • ✅ Crear entidades JPA simples
  • ✅ Utilizar los 4 métodos CRUD básicos (findById, findAll, save, deleteById)
  • ✅ Crear métodos de búsqueda simples (findBy, And, Or)
  • ✅ Trabajar con H2 en modo memoria y persistente

Lo que aún NO se espera que domine (esto está en los siguientes módulos):

  • ❌ Arquitectura completa de 3 capas (Módulo 3)
  • ❌ Validación avanzada (Módulo 3)
  • ❌ Gestión de errores HTTP (Módulo 3)
  • ❌ PostgreSQL en producción (Módulo 4)
  • ❌ Lombok (Módulo 4)
  • ❌ Joins JPA (Módulo 6)

Próximos Pasos​

Una vez completado este módulo, estará listo para:

  • Módulo 3: Arquitectura en Capas y CRUD Completo

    • Service Layer en profundidad
    • Validación de datos (@Valid, @NotNull, @Size, etc.)
    • Gestión de errores HTTP (ResponseEntity, códigos de estado)
    • Arquitectura profesional de 3 capas
    • TP3.1: Arquitectura CRUD (trasladado para mejor progresión)

  • Módulo 4: Bases de Datos en Producción

    • PostgreSQL - Instalación y configuración
    • Jakarta vs Javax Persistence
    • Hibernate y estrategias DDL
    • Lombok para reducir el código
    • TP4.1: Migración PostgreSQL (trasladado para mejor progresión)

  • Módulo 5: Spring Core - IoC y DI avanzado

  • Módulo 6: Spring Data JPA Avanzado (Joins, JPQL, Optimización)

📚 ¿Por qué esta reorganización?​

Estructura anterior:

  • El Módulo 2 contenía 4 prácticas, de las cuales 2 eran demasiado avanzadas
  • TP3.1 y TP4.1 utilizaban conceptos no enseñados
  • Frustración de los estudiantes

Nueva estructura:

  • ✅ Módulo 2: Solo fundamentos (TP2.1, TP2.2)
  • ✅ Módulo 3: CRUD con teoría completa (TP3.1)
  • ✅ Módulo 4: Producción con teoría completa (TP4.1)

💡 Resultado: ¡Cada práctica ahora tiene TODA la teoría necesaria ANTES de comenzarla!

Comenzar con el TP2.1