Skip to content
/ spring-boot-basics Public

Hub de fundamentos Spring Boot: 5 proyectos progresivos desde perfiles y configuración hasta APIs REST completas con JWT, transacciones ACID, Spring Security, Swagger y queries avanzadas JPA/Hibernate. Arquitectura en capas con MySQL y Docker.

0 stars 0 forks Branches Tags Activity
Star
Notifications You must be signed in to change notification settings

Cortadai/spring-boot-basics

BranchesTags

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

3 Commits
README.md
README.md
 
 

Repository files navigation

🚀 Proyectos de Aprendizaje Spring Boot

5 proyectos progresivos cubriendo fundamentos de Spring Boot, APIs REST y conceptos core. Perfecto para principiantes aprendiendo desarrollo Java empresarial.

📚 Lista de Proyectos

Fundamentos: Conceptos Core

  • springboot-first-app
    Perfiles Activos y Gestión de Configuración

    • Tecnología: Spring Boot 2.7.1, Java 11
    • Concepto: Perfiles de Spring para comportamiento específico por entorno
    • Ejemplo: Servicio meteorológico con perfiles "sunny" y "raining"
    • Caso de uso: Gestión de configuración, separación de entornos
    • Lección: Cómo cambiar comportamiento de aplicación con perfiles

  • springboot-backend
    Configuración, Properties y Gestión de Secrets

    • Tecnología: Spring Boot 2.7.1, Java 11
    • Conceptos: Perfiles Spring, propiedades externas, secrets
    • Ejemplo: Sistema de gestión de empleados con MySQL
    • Características:
      • Múltiples perfiles de entorno (dev, test, prod)
      • Archivos de configuración externalizados
      • Manejo de propiedades secretas
      • Docker Compose para base de datos local
    • Caso de uso: Patrones de configuración del mundo real
    • Lección: Gestionar configuración a través de entornos

Intermedio: Lógica de Negocio

  • springboot-transaction
    Gestión de Transacciones y Consistencia de Datos
    • Tecnología: Spring Boot 2.7.1, Java 11
    • Concepto: Transacciones ACID y atomicidad
    • Ejemplo: Procesamiento de pedidos e-commerce con pagos
    • Características:
      • Uso de anotación @Transactional
      • Rollback en errores
      • Operaciones con múltiples entidades
      • Base de datos MySQL (Docker Compose)
    • Escenario: Pedido falla si el pago falla (operación atómica)
    • Caso de uso: Transacciones financieras, procesamiento de pedidos
    • Lección: Asegurar consistencia de datos con transacciones

Avanzado: APIs REST

  • springboot-blog-rest-api
    API REST Completa con Autenticación y Autorización

    • Tecnología: Spring Boot 2.7.1, Java 11
    • Arquitectura: Tres capas (Controller → Service → Repository)
    • Características:
      • Autenticación basada en JWT
      • Autorización basada en roles
      • Base de datos MySQL con JPA/Hibernate
      • Documentación Swagger/SpringFox
      • Manejo de excepciones
      • DTOs y ModelMapper
    • Entidades: User, Post, Comment, Role
    • Operaciones: CRUD completo para posts y comentarios
    • Seguridad: Spring Security con tokens JWT
    • Documentación: Docs de API Swagger autogeneradas
    • Caso de uso: API de blog lista para producción
    • Lección: Desarrollo completo de API REST segura

  • springboot-search-rest-api
    API REST con Funcionalidad de Búsqueda Avanzada

    • Tecnología: Spring Boot 2.7.1, Java 11
    • Arquitectura: Arquitectura en capas con patrones CRUD
    • Características:
      • Búsqueda por palabras clave (nombre, descripción)
      • Queries JPQL (Java Persistence Query Language)
      • Queries SQL nativas
      • Base de datos MySQL con JPA/Hibernate
      • Configuración Docker Compose
      • Adminer para gestión de base de datos
    • Endpoints:
      • GET /api/v1/products/search1 (JPQL)
      • GET /api/v1/products/search2 (SQL Nativo)
      • POST /api/v1/products/create
    • Caso de uso: Búsqueda de productos, filtrado, sistemas de catálogo
    • Lección: Múltiples enfoques de queries en Spring Data

🏗️ Patrones Arquitectónicos

Arquitectura en Capas (Usada en todos los proyectos)

┌─────────────────────────────┐
│     Capa Controller         │ ← Endpoints REST, manejo peticiones
├─────────────────────────────┤
│     Capa Service            │ ← Lógica negocio, transacciones
├─────────────────────────────┤
│     Capa Repository         │ ← Acceso datos, JPA/Hibernate
├─────────────────────────────┤
│     Capa Entity/Model       │ ← Objetos dominio, mapeo BD
├─────────────────────────────┤
│     Capa Base de Datos      │ ← MySQL, persistencia
└─────────────────────────────┘

Flujo de Dependencias

Controller
    ↓ (inyecta)
Service
    ↓ (inyecta)
Repository
    ↓ (usa)
JPA/Hibernate
    ↓ (mapea)
Entidad de Base de Datos

📊 Comparativa de Proyectos

Proyecto Enfoque Nivel Base de Datos Seguridad Docs API
springboot-first-app Perfiles Principiante N/A Ninguna Ninguna
springboot-backend Configuración Principiante MySQL Ninguna Ninguna
springboot-transaction Transacciones Intermedio MySQL Ninguna Ninguna
springboot-blog-rest-api API REST Completa Avanzado MySQL JWT Swagger
springboot-search-rest-api Búsqueda y Queries Avanzado MySQL Ninguna Ninguna

🎯 Ruta de Aprendizaje

Semana 1: Fundamentos

Día 1-2: Perfiles y Configuración

springboot-first-app
├─ Activación de perfiles
├─ Creación condicional de beans
└─ Comportamiento específico por entorno

Conceptos:

  • Anotación @Profile
  • Propiedad spring.profiles.active
  • Múltiples archivos application-{profile}.properties

Ejemplo:

# Ejecutar con perfil
java -jar app.jar --spring.profiles.active=raining

Día 3-4: Gestión de Configuración

springboot-backend
├─ Propiedades externas
├─ Perfiles de entorno (dev/test/prod)
├─ Gestión de secrets
└─ Configuración Docker Compose

Conceptos:

  • @ConfigurationProperties
  • Jerarquía de archivos de propiedades
  • Sustitución de variables de entorno
  • Perfiles Spring para diferentes entornos

Ejemplo:

# application-dev.properties
spring.datasource.url=jdbc:mysql://localhost:3306/db_dev

# application-prod.properties
spring.datasource.url=jdbc:mysql://prod-server:3306/db_prod

Semana 2: Lógica de Negocio

Día 5-6: Gestión de Transacciones

springboot-transaction
├─ Anotación @Transactional
├─ Comportamiento de rollback
├─ Garantía de atomicidad
└─ Operaciones múltiples

Conceptos:

  • Transacciones ACID
  • Niveles de propagación
  • Niveles de aislamiento
  • Rollback en excepciones

Escenario de Ejemplo:

Crear Pedido (id=1)
    ↓
Crear Pago (order_id=1)
    ↓ ¡Pago Falla!
        └─ Rollback: Pedido eliminado, Pago nunca creado
            Resultado: Operación atómica (todo o nada)

Código:

@Transactional
public void createOrder(OrderRequest request) {
    Order order = orderRepository.save(new Order(...));
    Payment payment = paymentService.process(...);
    // Si el pago falla, toda la transacción hace rollback
}

Semana 3: APIs REST

Día 7-9: API Segura Completa

springboot-blog-rest-api
├─ Endpoints REST (CRUD)
├─ Autenticación (JWT)
├─ Autorización (Roles)
├─ Manejo de errores
├─ Documentación API (Swagger)
└─ Validación de datos

Arquitectura:

POST /api/auth/register
    ↓
AuthController.register()
    ↓
AuthService.register()
    ├─ Validar entrada
    ├─ Hashear contraseña
    └─ Guardar usuario
    
POST /api/posts
    ├─ Verificar token JWT
    ├─ Comprobar autorización
    ↓
PostController.createPost()
    ↓
PostService.createPost()
    └─ Guardar en base de datos

Endpoints:

  • POST /api/auth/register - Registro de usuario
  • POST /api/auth/login - Generación token JWT
  • GET /api/posts - Listar todos los posts
  • POST /api/posts - Crear post
  • PUT /api/posts/{id} - Actualizar post
  • DELETE /api/posts/{id} - Eliminar post
  • POST /api/posts/{postId}/comments - Añadir comentario

Día 10: Queries Avanzadas

springboot-search-rest-api
├─ Queries JPQL
├─ Queries SQL nativas
├─ Parámetros de query
├─ Filtrado de búsqueda
└─ Consideraciones de rendimiento

Enfoques de Queries:

// JPQL (Orientado a objetos)
@Query("SELECT p FROM Product p WHERE p.name LIKE %:keyword%")
List<Product> searchByJPQL(@Param("keyword") String keyword);

// SQL Nativo
@Query(value = "SELECT * FROM products WHERE description LIKE %:keyword%", 
       nativeQuery = true)
List<Product> searchByNativeSQL(@Param("keyword") String keyword);

// Spring Data (Autogenerado)
List<Product> findByNameContaining(String keyword);

🛠️ Stack Tecnológico

Framework y Runtime

  • Spring Boot 2.7.1 - Framework de aplicación
  • Java 11 - Lenguaje de programación
  • Tomcat - Servidor web embebido

Acceso a Datos

  • Spring Data JPA - Abstracción de repositorios de datos
  • Hibernate - ORM (Object-Relational Mapping)
  • MySQL 8 - Base de datos relacional

Seguridad

  • Spring Security - Autenticación y Autorización
  • JWT (JSON Web Tokens) - Autenticación stateless
  • BCrypt - Hashing de contraseñas

Herramientas de Desarrollo

  • Maven - Herramienta de construcción
  • Docker Compose - Contenedor de base de datos local
  • Adminer - UI web de base de datos
  • Swagger/SpringFox - Documentación de API

Utilidades

  • Lombok - Reducir código boilerplate
  • ModelMapper - Mapeo de objetos (DTO ↔ Entity)
  • Postman - Testing de API (manual)

🚀 Inicio Rápido

Prerrequisitos

Java 11+
Maven 3.6+
Docker & Docker Compose (para base de datos)

Clonar y ejecutar cualquier proyecto

Opción 1: Con Docker Compose (Recomendado)

git clone https://github.com/Cortadai/springboot-blog-rest-api.git
cd springboot-blog-rest-api

# Iniciar MySQL en Docker
docker-compose up -d

# Compilar y ejecutar
mvn clean spring-boot:run

# API disponible en http://localhost:8080
# Swagger UI en http://localhost:8080/swagger-ui.html

Opción 2: Con MySQL local

# Asegúrate de que MySQL está corriendo localmente en puerto 3306
git clone https://github.com/Cortadai/springboot-backend.git
cd springboot-backend

# Actualizar application.properties con tus credenciales MySQL
# Luego ejecutar:
mvn clean spring-boot:run

Probar la API

# Crear usuario
curl -X POST http://localhost:8080/api/auth/register \
  -H "Content-Type: application/json" \
  -d '{"username":"john","password":"password123","email":"john@example.com"}'

# Login y obtener token JWT
curl -X POST http://localhost:8080/api/auth/login \
  -H "Content-Type: application/json" \
  -d '{"username":"john","password":"password123"}'

# Respuesta: {"token":"eyJhbGciOiJIUzUxMiJ9..."}

# Crear post con token JWT
curl -X POST http://localhost:8080/api/posts \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer eyJhbGciOiJIUzUxMiJ9..." \
  -d '{"title":"Mi Primer Post","description":"Aprendiendo Spring Boot","content":"Contenido aquí..."}'

📊 Esquemas de Base de Datos

Base de Datos Blog (springboot-blog-rest-api)

-- Tabla usuarios
CREATE TABLE users (
    id INT PRIMARY KEY,
    username VARCHAR(100) UNIQUE,
    password VARCHAR(255),
    email VARCHAR(100) UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Tabla roles
CREATE TABLE roles (
    id INT PRIMARY KEY,
    name VARCHAR(50) UNIQUE
);

-- Roles de usuario (muchos a muchos)
CREATE TABLE user_roles (
    user_id INT,
    role_id INT,
    FOREIGN KEY (user_id) REFERENCES users(id),
    FOREIGN KEY (role_id) REFERENCES roles(id)
);

-- Tabla posts
CREATE TABLE posts (
    id INT PRIMARY KEY AUTO_INCREMENT,
    title VARCHAR(255),
    description VARCHAR(500),
    content LONGTEXT,
    user_id INT,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (user_id) REFERENCES users(id)
);

-- Tabla comentarios
CREATE TABLE comments (
    id INT PRIMARY KEY AUTO_INCREMENT,
    body TEXT,
    post_id INT,
    user_id INT,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (post_id) REFERENCES posts(id),
    FOREIGN KEY (user_id) REFERENCES users(id)
);

Base de Datos Productos (springboot-search-rest-api)

CREATE TABLE products (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(255),
    description TEXT,
    price DECIMAL(10,2),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

🔐 Conceptos de Seguridad

Flujo de Autenticación (JWT)

1. Usuario envía credenciales (username/password)
    ↓
2. Servidor valida credenciales
    ↓
3. Servidor genera token JWT
    │  Token incluye: user_id, roles, expiración
    ↓
4. Cliente almacena token JWT
    ↓
5. Cliente envía JWT en header Authorization
    ↓
6. Servidor valida firma JWT
    ↓
7. Servidor procesa petición
    ↓
8. Servidor retorna respuesta

Estructura JWT

Header.Payload.Signature
Ejemplo:
eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJqb2huIiwicm9sZXMiOlsiUk9MRV9VU0VSIl0sImlhdCI6MTYzMDcwMzQ2M30.signature...

Decodificado:
{
  "alg": "HS512"              // Header: Algoritmo
}
{
  "sub": "john",              // Payload: Sujeto (usuario)
  "roles": ["ROLE_USER"],     // Payload: Roles
  "iat": 1630703463           // Payload: Emitido en
}

🧪 Enfoques de Testing

Testing Unitario

@SpringBootTest
class PostServiceTest {
    
    @Mock
    PostRepository postRepository;
    
    @InjectMocks
    PostService postService;
    
    @Test
    void testCreatePost() {
        // Arrange
        Post post = new Post(...);
        when(postRepository.save(any())).thenReturn(post);
        
        // Act
        Post created = postService.createPost(post);
        
        // Assert
        assertNotNull(created);
        assertEquals("Title", created.getTitle());
    }
}

Testing de Integración

@SpringBootTest(webEnvironment = RANDOM_PORT)
class BlogApiIntegrationTest {
    
    @LocalServerPort
    int port;
    
    @Test
    void testPostEndpoint() {
        RestTemplate template = new RestTemplate();
        
        String url = "http://localhost:" + port + "/api/posts";
        ResponseEntity<Post> response = template.postForEntity(url, postRequest, Post.class);
        
        assertEquals(HttpStatus.CREATED, response.getStatusCode());
    }
}

💡 Conceptos Clave por Proyecto

Concepto Proyecto Lección
Perfiles Spring springboot-first-app Comportamiento específico por entorno
Gestión de Configuración springboot-backend Propiedades externas, secrets
Inyección de Dependencias Todos Gestión de dependencias Spring
Transacciones springboot-transaction ACID, rollback, atomicidad
Endpoints REST springboot-blog-rest-api Operaciones CRUD, verbos HTTP
Autenticación springboot-blog-rest-api Tokens JWT, login/register
Autorización springboot-blog-rest-api Control de acceso basado en roles
JPA/Hibernate Todos con BD ORM, mapeo de entidades
Spring Data Todos con BD Patrón Repository
Lenguajes de Query springboot-search-rest-api JPQL vs SQL Nativo
Manejo de Excepciones springboot-blog-rest-api Manejo global de errores
Documentación API springboot-blog-rest-api Swagger/OpenAPI

📝 Patrones Comunes

Patrón Capa Service

@Service
public class PostService {
    
    @Autowired
    private PostRepository postRepository;
    
    @Transactional
    public Post createPost(Post post) {
        // Lógica de negocio aquí
        return postRepository.save(post);
    }
    
    public List<Post> getAllPosts() {
        return postRepository.findAll();
    }
    
    public Post getPostById(Long id) {
        return postRepository.findById(id)
            .orElseThrow(() -> new ResourceNotFoundException("Post no encontrado"));
    }
}

Patrón Capa Controller

@RestController
@RequestMapping("/api/posts")
public class PostController {
    
    @Autowired
    private PostService postService;
    
    @GetMapping
    public List<PostDto> getAllPosts() {
        return postService.getAllPosts();
    }
    
    @PostMapping
    public ResponseEntity<PostDto> createPost(@Valid @RequestBody CreatePostRequest request) {
        PostDto post = postService.createPost(request);
        return ResponseEntity.status(HttpStatus.CREATED).body(post);
    }
    
    @PutMapping("/{id}")
    public PostDto updatePost(@PathVariable Long id, @RequestBody UpdatePostRequest request) {
        return postService.updatePost(id, request);
    }
    
    @DeleteMapping("/{id}")
    public ResponseEntity<?> deletePost(@PathVariable Long id) {
        postService.deletePost(id);
        return ResponseEntity.ok().build();
    }
}

🏷️ Topics Aplicados

Todos los proyectos etiquetados con:

  • #spring-boot - Framework Spring Boot
  • #aprendizaje - Material de aprendizaje
  • #educacion - Contenido educativo
  • #tutorial - Estilo tutorial
  • #java - Lenguaje Java
  • #rest-api - Desarrollo API REST (seleccionados)

Proyecto hub spring-boot-basics también etiquetado con:

  • #coleccion - Hub recopilatorio
  • #principiante - Nivel principiante
  • #rest - Patrones REST

📊 Estadísticas del Proyecto

Métrica Valor
Total Proyectos 5
Framework Spring Boot 2.7.1
Versión Java 11
Base de Datos MySQL 8
Nivel de Aprendizaje Principiante a Avanzado
Tiempo Estimado de Aprendizaje 2-3 semanas

🎓 Resultados de Aprendizaje

Después de completar esta colección, comprenderás:

  • ✅ Fundamentos de Spring Boot
  • ✅ Gestión de configuración a través de entornos
  • ✅ Inyección de dependencias e inversión de control
  • ✅ Perfiles Spring para separación de entornos
  • ✅ Gestión de transacciones y propiedades ACID
  • ✅ Principios de diseño de API REST
  • ✅ Métodos HTTP (GET, POST, PUT, DELETE)
  • ✅ Autenticación con tokens JWT
  • ✅ Autorización y control de acceso basado en roles
  • ✅ Spring Data JPA e Hibernate
  • ✅ Queries JPQL y SQL Nativo
  • ✅ Manejo de excepciones y respuestas de error
  • ✅ Documentación de API con Swagger
  • ✅ Estrategias de testing (unitario e integración)
  • ✅ Docker Compose para desarrollo local

🔗 Colecciones Relacionadas

💬 Resolución de Problemas

Problema: Conexión MySQL Fallida

Solución: Asegúrate de que el contenedor Docker está corriendo
$ docker-compose up -d
$ docker-compose ps  # Verificar contenedores

Problema: Puerto 8080 Ya en Uso

Solución: Cambiar puerto en application.properties
server.port=8081

Problema: Token JWT Expirado

Solución: Obtener nuevo token vía endpoint login
O aumentar expiración de token en application.properties
jwt.expiration.ms=86400000  # 24 horas

Problema: Swagger UI No Visible

Solución: Acceder a /swagger-ui.html (no /swagger-ui.html/)
Comprobar dependencia springfox en pom.xml

📚 Recursos Externos

Spring Boot Oficial

Tutoriales y Guías

Herramientas

📬 Notas

Estos proyectos fueron creados como ejemplos de aprendizaje para entender el desarrollo Spring Boot desde fundamentos hasta APIs REST listas para producción.

Perfecto para:

  • ✅ Principiantes aprendiendo Spring Boot
  • ✅ Entender arquitectura en capas
  • ✅ Aprender desarrollo de API REST
  • ✅ Dominar Spring Data e Hibernate
  • ✅ Implementar seguridad con JWT
  • ✅ Patrones de aplicaciones del mundo real

Última actualización: Noviembre 2025

About

Hub de fundamentos Spring Boot: 5 proyectos progresivos desde perfiles y configuración hasta APIs REST completas con JWT, transacciones ACID, Spring Security, Swagger y queries avanzadas JPA/Hibernate. Arquitectura en capas con MySQL y Docker.

Topics

java learning tutorial collection spring-boot rest-api

Resources

Readme
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

No packages published