Arrancando la primera aplicación Spring Boot, estructura del proyecto

¡Bienvenido al mundo de Spring Boot! En las lecturas anteriores discutimos los conceptos fundamentales de Spring Framework, aprendimos qué es Spring Boot y cómo facilita la vida a los desarrolladores Java. Hoy vamos a meternos en la parte práctica y dar nuestro primer paso creando y arrancando una aplicación Spring Boot. ¿Listo? Entonces vamos — a nuestras primeras líneas de código y a poner servidores en marcha!

La estructura del proyecto en Spring Boot no es solo un montón caótico de directorios. Está pensada para organizar tu código de forma que sea fácil gestionar tanto pequeños scripts como enormes sistemas enterprise.

Conocer la estructura del proyecto ayuda a:

1. Encontrar más rápido los archivos y la configuración que necesitas.
2. Entender dónde está cada cosa (incluso tras años trabajando en el proyecto).
3. Preparar el proyecto para escalar (para añadir otra funcionalidad sin sufrir).

Estructura del proyecto Spring Boot

Cuando creas un proyecto Spring Boot (por ejemplo, desde Spring Initializr), te dan automáticamente una estructura base. Algo así:

my-spring-boot-app/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/demo/
│   │   │       ├── MySpringBootApplication.java  // Clase principal de la aplicación
│   │   │       └── controllers/
│   │   │           └── HelloController.java     // Nuestros controladores
│   │   ├── resources/
│   │       ├── application.properties           // Configuraciones de la aplicación
│   │       └── static/                          // Recursos estáticos (CSS, JS, etc.)
│   └── test/                                    // Directorio de pruebas de la aplicación
├── pom.xml (o build.gradle)                   // Configuración de dependencias de Maven/Gradle

Analicemos los elementos principales:

1. src/main/java/
   Aquí estará toda tu lógica de negocio. Por ejemplo, controladores, servicios, repositorios y otras clases "inteligentes".

2. src/main/resources/
   Aquí se guardan las configuraciones (por ejemplo, application.properties), recursos (por ejemplo, archivos estáticos) y plantillas para renderizar páginas (si usas Thymeleaf).

3. src/test/
   Directorio para pruebas. Por ahora no nos meteremos ahí, pero en el futuro será nuestro mejor amigo.

4. pom.xml o build.gradle
   Archivo que se encarga de gestionar las dependencias del proyecto. Añadimos las dependencias necesarias, como spring-boot-starter-web, en este archivo.

Clase principal de la aplicación

La clase principal de la aplicación es el punto de entrada al arrancar un proyecto Spring Boot. Normalmente está en src/main/java y contiene apenas unas líneas. Aquí tienes un ejemplo:

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MySpringBootApplication {

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

¿Qué pasa aquí?

• @SpringBootApplication: esta anotación agrupa otras tres (@Configuration, @EnableAutoConfiguration, @ComponentScan) y le dice a Spring Boot: "¡Eh, esta es nuestra clase principal. Empieza por aquí!".
• SpringApplication.run(): pone en marcha la "Spring Boot magic". Encuentra todas las configuraciones, arranca el servidor embebido y empieza a escuchar las peticiones entrantes.

¿Dónde buscar nuestro código? Lo ideal es que la clase principal esté en la raíz de tu paquete, por ejemplo com.example.demo. Eso facilita el escaneo automático de todos los archivos del proyecto. Si decides esconder la clase principal en un paquete más profundo, puede que tengas que configurar manualmente el escaneo de componentes (spoiler: no lo hagas salvo que tengas una buena razón).

El rol del archivo application.properties

Si la clase principal es el corazón de tu aplicación, application.properties (o su versión YAML, application.yml) es su cerebro. Aquí defines configuraciones como el puerto, ajustes de la base de datos, logging y mucho más.

Ejemplo de configuración en application.properties:

# Puerto del servidor
server.port=8081

# Registro
logging.level.org.springframework=DEBUG
logging.level.com.example=TRACE

Arranca la aplicación y escuchará peticiones en el puerto 8081 en vez del 8080 por defecto. Si prefieres la versión YAML, esto sería:

server:
  port: 8081

logging:
  level:
    org.springframework: DEBUG
    com.example: TRACE

Arrancar la aplicación

Spring Boot ofrece una comodidad increíble a la hora de ejecutar la app. Así se hace:

1. Ejecutar desde la IDE

   • Abre tu proyecto en IntelliJ IDEA (u otra IDE).
   • Localiza la clase principal de la aplicación.
   • Haz clic en el botón verde "Run" al lado del método main.
2. Ejecutar desde el terminal. Ejecuta el siguiente comando:

   
   ./mvnw spring-boot:run
   

   o

   
   ./gradlew bootRun
   

3. Crear el archivo jar. Empaqueta tu aplicación:

   
   ./mvnw clean package
   

   Después ejecuta el jar:

   
   java -jar target/my-app-0.0.1-SNAPSHOT.jar
   

Comprobación

Ahora abre el navegador y escribe:

http://localhost:8080/hello

Si ves tu mensaje "¡Hola, Mundo!", ¡todo funciona correctamente! ¡Hurra!

Práctica

Vamos a crear una aplicación mínima que devuelva un saludo. Usaremos un controlador para manejar la petición.

Miremos el código del controlador:

package com.example.demo.controllers;

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

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String sayHello() {
        return "¡Hola, Mundo desde Spring Boot!";
    }
}

¿Qué pasa aquí?

1. @RestController: le dice a Spring que esta clase manejará peticiones HTTP.
2. @GetMapping: indica que el método atenderá solicitudes HTTP GET en la ruta /hello.
3. Respuesta String: devolvemos un saludo de texto simple al cliente.

Probemos la respuesta

Abre el navegador o Postman, visita http://localhost:8080/hello y disfruta de tu primer controlador de Spring Boot.

Errores comunes al arrancar

Spring Boot hace mucho por ti, pero a veces salen errores. Aquí tienes algunos problemas típicos y sus soluciones:

1. Puerto ya en uso
   Al arrancar ves el mensaje Port 8080 is already in use. Eso significa que alguien ya ha "capturado" el puerto. Intenta cambiar el puerto en application.properties:

   
   server.port=8081
   

2. Estructura de paquetes incorrecta
   Si la clase principal de la aplicación (la que tiene la anotación @SpringBootApplication) no está en la raíz del paquete, puede dar problemas con el escaneo de componentes.
3. Error de autoconfiguración
   Si olvidaste añadir el starter necesario (por ejemplo, spring-boot-starter-web), la aplicación no podrá manejar peticiones. Revisa tu pom.xml o build.gradle.

En esta etapa ya estás listo para crear y arrancar aplicaciones Spring Boot. En la próxima clase hablaremos sobre el ciclo de vida de los beans y veremos cómo Spring gestiona nuestros objetos por dentro. ¿Quién dijo que la magia es complicada? 😉