Introducción a Spring Boot

2.1 Introducción al ecosistema Spring

El ecosistema Spring es, hoy en día, el estándar de facto para el desarrollo de aplicaciones empresariales en Java. No es simplemente una librería, sino un conjunto masivo de herramientas que permiten construir desde pequeñas aplicaciones de consola hasta arquitecturas de microservicios globales altamente escalables.

Su éxito radica en la Inversión de Control (IoC) y la Inyección de Dependencias (DI), principios que permiten a los desarrolladores centrarse en la lógica de negocio mientras el framework se encarga de la infraestructura (conexiones a bases de datos, seguridad, mensajería, etc.).

2.1.1 Concepto de Framework

En el desarrollo de software, un framework es una estructura de soporte predefinida que ofrece un conjunto de herramientas, librerías y buenas prácticas para facilitar la creación de aplicaciones.

A diferencia de una librería (donde tú llamas al código de la librería), en un framework ocurre la Inversión de Control: el framework es quien tiene el flujo de la aplicación y llama a tu código cuando es necesario.

Características principales:

• Esqueleto funcional: Ofrece una base sobre la cual construir, evitando escribir código repetitivo (boilerplate code).
• Estandarización: Impone una estructura organizada, lo que facilita el mantenimiento y el trabajo en equipo.
• Extensibilidad: Permite añadir funcionalidades específicas sobre su base general.

2.1.2 Arquitectura de Spring

La arquitectura de Spring es modular, lo que significa que no necesitas usar todo el framework; puedes elegir solo los componentes que tu proyecto requiera. Históricamente, se organiza en capas o grupos de módulos.

1. Core Container (El Corazón)

Es la base del framework. Aquí reside el motor que gestiona los objetos de la aplicación (llamados Beans).

• Beans & Core: Proporcionan las funcionalidades de IoC y Di.
• Context: Un medio para acceder a cualquier objeto definido y configurado. El ApplicationContext es la interfaz central.
• SpEL (Spring Expression Language): Un lenguaje de expresiones potente para consultar y manipular el grafo de objetos en tiempo de ejecución.

2. Data Access / Integration

Facilita la comunicación con bases de datos y sistemas externos.

• JDBC: Elimina la necesidad de escribir código tedioso para abrir/cerrar conexiones.
• ORM (Object Relational Mapping): Integración con Hibernate, JPA, etc.
• Transactions: Gestión de transacciones declarativas (usando simplemente anotaciones como @Transactional).

3. Web Layer

Proporciona las herramientas para crear aplicaciones web y servicios REST.

• Spring Web MVC: El framework modelo-vista-controlador para crear aplicaciones web.
• WebFlux: Introducido en Spring 5 para soporte de programación reactiva (no bloqueante).

4. AOP (Aspect Oriented Programming)

Permite separar las funcionalidades transversales (cross-cutting concerns) de la lógica de negocio. Por ejemplo, puedes definir que se guarde un log cada vez que se ejecute cualquier método de la capa de servicio, sin tocar el código de esos métodos.

Guía Práctica: Configuración Básica

Para entender Spring en la práctica, lo más sencillo es utilizar Spring Boot, que preconfigura la arquitectura mencionada anteriormente para que puedas empezar en segundos.

1. Dependencias (Maven)

En un archivo pom.xml, la arquitectura se define mediante "starters":

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

2. Concepto de Bean y Component Scan

Spring busca clases anotadas para gestionarlas automáticamente.

import org.springframework.stereotype.Service;
import org.springframework.stereotype.Component;

@Service // Esto le dice a Spring que esta clase es un Bean de la capa de servicio
public class SaludoService {
    public String obtenerMensaje() {
        return "¡Bienvenido al ecosistema Spring!";
   }
}

3. Inyección de Dependencias (DI)

En lugar de crear el objeto con new, Spring lo "inyecta".

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SaludoController {

    private final SaludoService saludoService;

    // Spring inyecta automáticamente el Bean SaludoService aquí
    public SaludoController(SaludoService saludoService) {
        this.saludoService = saludoService;
    }

    @GetMapping("/saludar")
    public String saludar() {
        return saludoService.obtenerMensaje();
    }
}

Nota Teórica: Observa cómo el SaludoController no sabe cómo se crea el SaludoService. Simplemente lo solicita en su constructor. Esta es la esencia de la arquitectura de Spring: desacoplamiento total.

2.2 Introducción a Spring Boot

Si Spring Framework es la caja de herramientas, Spring Boot es el asistente experto que ya tiene las herramientas listas sobre la mesa para empezar a trabajar. Surgió para solucionar la complejidad de la configuración inicial (archivos XML interminables o configuraciones de Java repetitivas).

Su filosofía es "Convention over Configuration" (Convención sobre Configuración): el framework asume una configuración base estándar, y tú solo intervienes cuando necesitas algo diferente.

2.2.1 Características principales

Spring Boot no reemplaza a Spring, sino que lo envuelve para que sea más rápido de usar. Sus pilares son:

• Autoconfiguración (Auto-configuration): Spring Boot intenta adivinar qué necesitas basándose en las librerías que has añadido al proyecto (el classpath). Por ejemplo, si añades la librería de base de datos H2, Spring Boot configura automáticamente una conexión a base de datos en memoria sin que escribas una sola línea de código.
• Starters (Dependencias simplificadas): Son descriptores de dependencias que agrupan librerías relacionadas. En lugar de buscar 10 versiones compatibles de librerías para hacer una API, simplemente añades spring-boot-starter-web.
• Servidor embebido: Spring Boot incluye un servidor (normalmente Tomcat) dentro del propio archivo ejecutable (.jar). Esto significa que no necesitas instalar un servidor externo en tu computadora para correr la aplicación; ella misma "lleva" su servidor.
• Actuator: Una herramienta de monitoreo que permite ver el estado de la aplicación, métricas, logs y salud del sistema a través de HTTP, ideal para entornos de producción.
• CLI (Command Line Interface): Permite crear prototipos rápidos usando scripts en Groovy, aunque es menos común en entornos corporativos que prefieren Maven o Gradle.

2.2.2 Ventajas del framework

El uso de Spring Boot se ha vuelto obligatorio en el desarrollo moderno por las siguientes razones:

1. Reducción drástica de tiempo: Se puede pasar de "idea" a "aplicación funcionando" en minutos. Elimina el boilerplate code (código repetitivo).
2. Facilidad para Microservicios: Gracias a su ligereza y servidores embebidos, es la herramienta perfecta para arquitecturas de microservicios, donde cada servicio debe ser independiente y fácil de desplegar.
3. Configuración externalizada: Permite manejar diferentes configuraciones para Desarrollo, Testing y Producción de forma sencilla mediante archivos application.properties o application.yml.
4. Ecosistema Maduro y Soporte: Al ser parte de Spring, tiene una comunidad gigante. Si tienes un error, es casi seguro que alguien más ya lo solucionó en StackOverflow.
5. Producción-Ready: Incluye por defecto herramientas de seguridad (Spring Security) y gestión de datos que cumplen con estándares bancarios y empresariales.

Guía Práctica: Creando tu primer componente Boot

Para ver la autoconfiguración en acción, solo necesitas una clase con el método main.

Java

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication // Esta anotación activa la Autoconfiguración y el Component Scan
@RestController
public class MiPrimerProyectoApplication {

    public static void main(String[] args) {
        // Lanza toda la infraestructura de Spring y el servidor Tomcat embebido
        SpringApplication.run(MiPrimerProyectoApplication.class, args);
    }

    @GetMapping("/")
    public String home() {
        return "Servidor corriendo gracias a Spring Boot";
    }
}

Punto clave para la práctica:

Si ejecutas este código, notarás en la consola que Spring Boot detecta automáticamente que quieres una aplicación Web, inicia Tomcat en el puerto 8080 y gestiona el ciclo de vida del Bean sin que hayas configurado ni un solo servidor localmente.

2.3 Creación de Proyectos

Crear un proyecto con Spring Boot solía requerir la configuración manual de archivos de construcción complejos. Hoy en día, el proceso se ha estandarizado a través de herramientas que generan la estructura base siguiendo las mejores prácticas de la industria.

2.3.1 Uso de Spring Initializr

Spring Initializr es una interfaz web (disponible en start.spring.io) y un servicio API que actúa como el "bootstrap" oficial para aplicaciones Spring. Su función es generar una estructura de proyecto personalizada que puedes descargar e importar en tu IDE preferido.

Parámetros de configuración:

1. Project: Permite elegir entre Maven o Gradle. Maven es el estándar tradicional basado en XML, mientras que Gradle utiliza un lenguaje basado en Groovy o Kotlin más flexible.
2. Language: Soporta Java, Kotlin y Groovy.
3. Spring Boot Version: Siempre se recomienda usar la versión más reciente con la etiqueta GA (General Availability) para mayor estabilidad.
4. Project Metadata:
   • Group: Identificador de la organización (ej: com.miempresa).
   • Artifact: Nombre del proyecto (ej: sistema-ventas).
   • Packaging:Jar (recomendado para Spring Boot ya que incluye el servidor) o War (si se planea desplegar en un servidor externo).
   • Java Version: Debe coincidir con la versión instalada en tu entorno de desarrollo (JDK 17 y 21 son las versiones LTS más comunes actualmente).

2.3.2 Dependencias (Starters)

En lugar de buscar librerías individuales y preocuparse por la compatibilidad de versiones, Spring Boot utiliza los Starters. Un Starter es un conjunto de descriptores de dependencias que puedes incluir en tu aplicación para obtener una funcionalidad específica "fuera de la caja".

Tipos de dependencias comunes:

• Spring Web: Esencial para crear aplicaciones web, incluyendo RESTful, y usa Apache Tomcat como contenedor embebido por defecto.
• Spring Data JPA: Facilita el uso de Java Persistence API con Hibernate, permitiendo interactuar con bases de datos SQL de forma orientada a objetos.
• Spring Security: Proporciona autenticación y control de acceso altamente personalizable.
• Lombok: Una librería de Java que ayuda a reducir el código repetitivo, generando automáticamente getters, setters y constructores mediante anotaciones.
• Spring Boot DevTools: Proporciona recarga rápida de la aplicación (LiveReload) cada vez que detecta un cambio en el código, mejorando la productividad en desarrollo.

Guía Práctica: Estructura del Proyecto Generado

Una vez que generas y descomprimes el proyecto, te encontrarás con la siguiente estructura estándar:

Plaintext

mi-proyecto/
├── src/
│  ├── main/
│  │   ├── java/             <-- Código fuente Java (.java)
│  │   └── resources/
│  │       ├── static/       <-- Archivos CSS, JS, Imágenes
│  │       ├── templates/    <-- Plantillas HTML (Thymeleaf)
│  │       └── application.properties <-- Configuración de la aplicación
│  └── test/                 <-- Pruebas unitarias e integración
├── pom.xml                   <-- Configuración de Maven (dependencias)
└── mvnw                      <-- Maven Wrapper (para ejecutar sin instalar Maven)

Ejemplo: El archivo pom.xml

Cuando seleccionas dependencias en Initializr, se reflejan así en tu archivo de configuración:

XML

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

Dato clave: No verás números de versión en estas dependencias. Esto se debe a que el archivo tiene un parent (padre) que gestiona automáticamente las versiones compatibles de todas las librerías del ecosistema para evitar conflictos de "infierno de dependencias".

Para desarrollar aplicaciones escalables y mantenibles, Spring Boot promueve una arquitectura en capas. Esta separación de responsabilidades permite que cada parte del código se encargue de una sola tarea (Principio de Responsabilidad Única).

2.4.1 Controller (Capa de Presentación)

El Controlador es el punto de entrada de la aplicación. Su función es recibir las peticiones HTTP (GET, POST, PUT, DELETE), validar someramente la entrada y delegar la ejecución a la capa de servicio.

• Anotación clave: @RestController.
• Responsabilidad: Manejar la comunicación exterior. No debe contener lógica de negocio compleja ni acceso a la base de datos.
• Ejemplo:

Java

@RestController
@RequestMapping("/api/usuarios")
public class UsuarioController {
    private final UsuarioService usuarioService;

    public UsuarioController(UsuarioService usuarioService) {
        this.usuarioService = usuarioService;
    }

    @GetMapping("/{id}")
    public ResponseEntity<Usuario> obtenerUsuario(@PathVariable Long id) {
        return ResponseEntity.ok(usuarioService.buscarPorId(id));
    }
}

2.4.2 Service (Capa de Negocio)

Es el "cerebro" de la aplicación. Aquí es donde reside toda la lógica, reglas de negocio, cálculos y coordinaciones entre diferentes repositorios.

• Anotación clave: @Service.
• Responsabilidad: Implementar algoritmos, aplicar reglas de validación y gestionar transacciones. Sirve de puente entre el controlador y el repositorio.
• Ejemplo:

Java

@Service
public class UsuarioService {
    private final UsuarioRepository usuarioRepository;

    public UsuarioService(UsuarioRepository usuarioRepository) {
        this.usuarioRepository = usuarioRepository;
    }

    public Usuario buscarPorId(Long id) {
        // Lógica de negocio: por ejemplo, verificar si el usuario está activo
        return usuarioRepository.findById(id)
            .orElseThrow(() -> new RuntimeException("Usuario no encontrado"));
    }
}

2.4.3 Repository (Capa de Acceso a Datos)

El Repositorio es la capa que se comunica directamente con la base de datos. En Spring Data JPA, la mayoría de las veces es una interface, y Spring genera la implementación automáticamente.

• Anotación clave: @Repository.
• Responsabilidad: Realizar operaciones CRUD (Create, Read, Update, Delete) y consultas personalizadas.
• Ejemplo:

Java

@Repository
public interface UsuarioRepository extends JpaRepository<Usuario, Long> {
    // Spring crea automáticamente la lógica para buscar por email
    Optional<Usuario> findByEmail(String email);
}

2.4.4 Model / Entity (Capa de Datos)

El Modelo representa los datos de la aplicación. Cuando trabajamos con bases de datos relacionales, usamos Entidades, que son clases Java que mapean directamente a una tabla de la base de datos.

• Anotación clave: @Entity y @Id.
• Responsabilidad: Definir la estructura de la información y sus relaciones (Uno a Muchos, Muchos a Muchos, etc.).
• Ejemplo:

Java

@Entity
@Table(name = "usuarios")
public class Usuario {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String nombre;

    @Column(unique = true)
    private String email;

    // Getters, Setters y Constructores
}

Resumen del Flujo de Datos

1. Petición: El cliente envía un JSON al Controller.
2. Proceso: El Controller llama al Service.
3. Lógica: El Service procesa los datos y pide al Repository que los guarde.
4. Persistencia: El Repository mapea el Model (Entity) a la base de datos.
5. Respuesta: El camino se recorre de vuelta hasta entregar una respuesta al cliente.