Curso Spring Boot

Spring Boot es el framework de referencia del backend Java empresarial en España y Europa. Sostiene plataformas de pagos (TPV, gateways, conciliación), core bancario, aplicaciones de trading, procesadores de datos regulatorios, APIs de operadores de telecomunicaciones, WMS logísticos, motores de ecommerce y sedes electrónicas del sector público. Su combinación de autoconfiguración, starters y ecosistema Spring lo convierte en la opción habitual de consultoras IT para construir microservicios, APIs REST y aplicaciones web mantenibles. 

El framework evoluciona el modelo clásico de Spring Framework eliminando configuración manual: los starters agrupan dependencias coherentes, la autoconfiguración detecta el classpath y las propiedades externalizadas permiten desplegar el mismo artefacto en desarrollo, staging y producción sin tocar código.

Orden cronológico:

• Spring Framework 1.0 en 2004.
• Spring Boot 1.0 en 2014.
• Spring Framework 6 y Spring Boot 3 en noviembre de 2022, con migración a Jakarta EE 9+ (jakarta.*), Java 17 mínimo y soporte nativo de GraalVM.
• Spring Boot 3.2 (2023) y Spring Boot 3.3 (2024), con integración nativa de virtual threads de Project Loom y observabilidad basada en la API Observation de Micrometer.
• Spring Boot 3.4 (finales de 2024) con logs estructurados JSON listos para producción y mejoras en la API RestClient.
• Spring Framework 7 y Spring Boot 4 previstos para 2026, alineados con Java 17 y 21 como líneas soportadas y ejecutables en Java 25 LTS.

Versiones recomendadas en 2026

| Componente | Versión recomendada | |------------|---------------------| | Java | 17, 21 o 25 LTS | | Spring Framework | 6.2 o 7 | | Spring Boot | 3.4+ o 4 cuando esté estable | | Jakarta EE | 10 (namespace jakarta.*) | | Build tool | Maven 3.9+ o Gradle 8+ |

Novedades clave del stack moderno

• Records Java para DTOs inmutables con menos código repetitivo.
• Pattern matching para switch y instanceof, que reduce casting manual.
• Virtual threads de Project Loom activables con spring.threads.virtual.enabled=true, ideales para APIs REST con mucha concurrencia IO.
• ProblemDetail (RFC 7807) como representación estándar de errores HTTP.
• RestClient como sustituto moderno y síncrono de RestTemplate.
• Docker Compose Support integrado en el starter spring-boot-docker-compose para arrancar servicios dependientes en desarrollo.
• Observabilidad unificada con Micrometer Observation API y exportadores para OpenTelemetry, Prometheus, Zipkin o Tempo.
• Spring Security 6 con SecurityFilterChain declarativo y authorizeHttpRequests como DSL canónico.

Filosofía y arquitectura de Spring Boot

La filosofía central de Spring Boot se basa en el principio de "convención sobre configuración". En lugar de requerir extensos archivos XML o múltiples clases de configuración, Spring Boot proporciona configuraciones predeterminadas inteligentes que funcionan para la mayoría de casos de uso comunes.

El framework implementa un enfoque opinionado hacia el desarrollo, tomando decisiones arquitectónicas por el desarrollador basándose en las mejores prácticas de la industria. Esto no significa rigidez; Spring Boot mantiene la flexibilidad completa para personalizar cualquier aspecto cuando sea necesario.

La arquitectura modular de Spring Boot se construye sobre el concepto de "starters", que son dependencias preconfiguradas que incluyen todo lo necesario para funcionalidades específicas. Un starter típico incluye las librerías necesarias, configuración automática y beans predefinidos.

Configuración automática y convenciones

El mecanismo de autoconfiguración constituye el corazón de Spring Boot. El framework analiza el classpath de la aplicación y configura automáticamente los beans y componentes necesarios basándose en las dependencias presentes.

@SpringBootApplication
public class MiAplicacionApplication {
    public static void main(String[] args) {
        SpringApplication.run(MiAplicacionApplication.class, args);
    }
}

La anotación @SpringBootApplication combina tres anotaciones fundamentales: @Configuration, @EnableAutoConfiguration y @ComponentScan. Esta composición de anotaciones simplifica significativamente la configuración inicial.

El sistema de propiedades externalizadas permite configurar la aplicación sin modificar el código. Spring Boot busca propiedades en múltiples ubicaciones siguiendo un orden de precedencia específico, desde argumentos de línea de comandos hasta archivos de propiedades en el classpath.

Desarrollo web con Spring MVC

Spring MVC integrado en Spring Boot proporciona un framework completo para desarrollo web. Los controladores manejan las peticiones HTTP y coordinan la interacción entre la vista y el modelo, siguiendo el patrón arquitectónico Model-View-Controller.

@Controller
public class ProductoController {
    
    @GetMapping("/productos")
    public String listarProductos(Model model) {
        model.addAttribute("productos", productoService.obtenerTodos());
        return "productos/lista";
    }
    
    @PostMapping("/productos")
    public String crearProducto(@ModelAttribute Producto producto) {
        productoService.guardar(producto);
        return "redirect:/productos";
    }
}

La integración con Thymeleaf como motor de plantillas permite crear vistas dinámicas con una sintaxis natural que mantiene la validez HTML. Thymeleaf procesa las plantillas en el servidor, generando HTML final que se envía al cliente.

Los formularios web en Spring MVC se benefician del binding automático de datos y validación integrada. El framework mapea automáticamente los parámetros de formulario a objetos Java, aplicando validaciones definidas mediante anotaciones.

Ciclo de una petición MVC

flowchart LR
    U[Usuario] --> DS[DispatcherServlet]
    DS --> HM[HandlerMapping]
    HM --> C["@Controller"]
    C --> S["@Service"]
    S --> R["@Repository / JPA"]
    R --> DB[(Base de datos)]
    C --> M[Model]
    M --> V[Vista Thymeleaf]
    V --> DS
    DS --> U

APIs REST y servicios web

El desarrollo de APIs REST con Spring Boot utiliza anotaciones específicas que simplifican la creación de endpoints. Los controladores REST devuelven datos directamente en lugar de vistas, utilizando serialización automática a JSON.

@RestController
@RequestMapping("/api/productos")
public class ProductoRestController {
    
    @GetMapping
    public List<Producto> obtenerProductos() {
        return productoService.obtenerTodos();
    }
    
    @PostMapping
    public ResponseEntity<Producto> crearProducto(@RequestBody Producto producto) {
        Producto nuevoProducto = productoService.guardar(producto);
        return ResponseEntity.status(HttpStatus.CREATED).body(nuevoProducto);
    }
}

La gestión de errores en APIs REST requiere un enfoque diferente al desarrollo web tradicional. Spring Boot proporciona mecanismos para manejar excepciones globalmente y devolver respuestas de error estructuradas en formato JSON con ProblemDetail (RFC 7807).

La documentación automática de APIs mediante OpenAPI (anteriormente Swagger) se integra sin fricciones con Spring Boot, generando documentación interactiva basada en las anotaciones del código y en los esquemas derivados de los DTOs.

En Spring Boot 3 se recomienda el uso de RestClient como cliente HTTP síncrono moderno. Para escenarios reactivos se mantiene WebClient, y desde Java 21 los controladores REST se benefician de virtual threads para escalar miles de conexiones simultáneas sin aumentar el pool de hilos del servidor.

Persistencia de datos con Spring Data JPA

Spring Data JPA abstrae la complejidad de la persistencia de datos, proporcionando una capa de acceso a datos que reduce significativamente el código boilerplate. Los repositorios se definen mediante interfaces que Spring implementa automáticamente.

@Entity
public class Producto {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String nombre;
    
    private BigDecimal precio;
    
    // constructores, getters y setters
}

public interface ProductoRepository extends JpaRepository<Producto, Long> {
    List<Producto> findByNombreContaining(String nombre);
    List<Producto> findByPrecioBetween(BigDecimal min, BigDecimal max);
}

Las consultas derivadas permiten crear métodos de consulta basándose únicamente en el nombre del método. Spring Data JPA analiza el nombre y genera automáticamente la consulta JPQL correspondiente.

Para consultas más complejas, JPQL y consultas nativas proporcionan control total sobre la lógica de acceso a datos. La anotación @Query permite definir consultas personalizadas manteniendo la flexibilidad del repositorio.

Inyección de dependencias y servicios

La inyección de dependencias en Spring Boot utiliza el contenedor IoC (Inversión de Control) para gestionar el ciclo de vida de los objetos y sus dependencias. Este patrón promueve el bajo acoplamiento y facilita las pruebas unitarias.

@Service
public class ProductoService {
    
    private final ProductoRepository productoRepository;
    
    public ProductoService(ProductoRepository productoRepository) {
        this.productoRepository = productoRepository;
    }
    
    public List<Producto> obtenerTodos() {
        return productoRepository.findAll();
    }
}

La inyección por constructor se considera la mejor práctica, ya que garantiza que las dependencias estén disponibles en el momento de la creación del objeto y facilita la creación de objetos inmutables.

Los servicios encapsulan la lógica de negocio y actúan como una capa intermedia entre los controladores y los repositorios. Esta separación de responsabilidades mejora la mantenibilidad y testabilidad del código.

Testing integral en Spring Boot

El framework de testing de Spring Boot proporciona herramientas específicas para probar diferentes capas de la aplicación. Las anotaciones de testing configuran automáticamente el contexto de Spring necesario para cada tipo de prueba.

@SpringBootTest
class ProductoServiceTest {
    
    @Autowired
    private ProductoService productoService;
    
    @MockBean
    private ProductoRepository productoRepository;
    
    @Test
    void deberiaObtenerTodosLosProductos() {
        // Given
        List<Producto> productos = Arrays.asList(
            new Producto("Producto 1", new BigDecimal("10.00")),
            new Producto("Producto 2", new BigDecimal("20.00"))
        );
        when(productoRepository.findAll()).thenReturn(productos);
        
        // When
        List<Producto> resultado = productoService.obtenerTodos();
        
        // Then
        assertThat(resultado).hasSize(2);
    }
}

Las pruebas de integración verifican el funcionamiento conjunto de múltiples componentes, mientras que las pruebas unitarias se enfocan en componentes individuales utilizando mocks para aislar las dependencias.

El testing de controladores puede realizarse mediante @WebMvcTest para pruebas de la capa web o @SpringBootTest con TestRestTemplate para pruebas de integración completas que incluyen el servidor embebido.

Configuración de bases de datos

Spring Boot simplifica la configuración de bases de datos mediante propiedades de configuración y autoconfiguración inteligente. El framework detecta automáticamente los drivers de base de datos en el classpath y configura las conexiones apropiadas.

# Configuración para MySQL
spring.datasource.url=jdbc:mysql://localhost:3306/miapp
spring.datasource.username=usuario
spring.datasource.password=contraseña
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

La base de datos H2 proporciona una solución ideal para desarrollo y testing, funcionando completamente en memoria o como base de datos embebida. Su configuración mínima y capacidades de consola web la convierten en una herramienta valiosa durante el desarrollo.

Para entornos de producción, Spring Boot soporta todas las bases de datos relacionales principales, incluyendo PostgreSQL, MySQL, Oracle y SQL Server, con configuraciones optimizadas para cada una.

Ecosistema y herramientas de desarrollo

El ecosistema Spring Boot incluye herramientas que mejoran significativamente la experiencia de desarrollo. Spring Boot DevTools proporciona reinicio automático de la aplicación durante el desarrollo, recarga de plantillas y configuraciones de desarrollo optimizadas.

Los IDEs modernos como IntelliJ IDEA y Visual Studio Code ofrecen soporte nativo para Spring Boot, incluyendo asistentes de creación de proyectos, autocompletado inteligente y herramientas de debugging específicas.

Spring Initializr facilita la creación de proyectos nuevos mediante una interfaz web intuitiva que permite seleccionar dependencias, configurar metadatos del proyecto y generar un proyecto base completamente funcional.

La integración con herramientas de build como Maven y Gradle está optimizada para Spring Boot, incluyendo plugins específicos que simplifican tareas como el empaquetado de aplicaciones ejecutables y la gestión de dependencias.

Observabilidad y producción en 2026

La observabilidad es un pilar de las aplicaciones modernas. Spring Boot 3 integra Micrometer como fachada de métricas y la API Observation unifica métricas, trazas y logs en un mismo evento. Los exportadores hacia Prometheus, OpenTelemetry, Zipkin o Tempo se activan añadiendo la dependencia correspondiente.

Los logs estructurados en formato JSON (ECS o Logstash) se configuran declarativamente desde Spring Boot 3.4 con logging.structured.format.console=ecs, facilitando la ingesta en Elasticsearch, Loki o Grafana Cloud sin escribir formatters a medida.

Para despliegue, GraalVM Native Image permite empaquetar aplicaciones como ejecutables nativos con arranque en milisegundos y consumo de memoria reducido, lo que encaja con arquitecturas serverless y entornos Kubernetes con autoescalado agresivo.

Microservicios con Spring Cloud

Spring Cloud complementa Spring Boot con componentes listos para arquitecturas distribuidas: Config Server para configuración centralizada, Eureka o Consul para descubrimiento de servicios, Spring Cloud Gateway para enrutado y filtros, Resilience4j para circuit breakers y Spring Cloud Stream para mensajería sobre Kafka o RabbitMQ. Todo el stack se combina con Spring Security como Resource Server OAuth2 para autenticar peticiones mediante JWT emitidos por un authorization server externo.