Estructura del proyecto Spring Boot

Cuando creas un proyecto Spring Boot (por ejemplo, a través de Spring Initializr), obtienes una estructura ya preparada. No es simplemente un montón caótico de archivos y carpetas, es una plantilla bien pensada que facilita el desarrollo y el mantenimiento. Vamos a ver sus componentes.

Estructura del proyecto

Supongamos que hemos creado un proyecto nuevo llamado demo. Esta es la estructura que verás:

demo/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/demo/
│   │   │       └── DemoApplication.java
│   │   ├── resources/
│   │       ├── static/
│   │       ├── templates/
│   │       ├── application.properties
│   │       └── application.yml
│   ├── test/
│       ├── java/
│       │   └── com/example/demo/
│       │       └── DemoApplicationTests.java
│       └── resources/
├── mvnw
├── mvnw.cmd
├── pom.xml
└── README.md

Vamos a desmenuzar todo esto.

src/main/java

Probablemente ya conoces este directorio: aquí vive el código principal de tu aplicación. Dentro de la carpeta encontrarás la estructura basada en tu Group y Artifact ID que indicaste al crear el proyecto. Por ejemplo, si el Group ID es com.example y el Artifact ID es demo, obtendrás el directorio com/example/demo.

Clase principal de la aplicación Cada proyecto Spring Boot contiene la clase principal con la anotación @SpringBootApplication. En nuestro caso — es DemoApplication.java:

package com.example.demo;

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

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

En realidad, no es sólo una "clase principal" cualquiera. Esta clase:

1. Arranca la aplicación.
2. Activa la autoconfiguración mediante la anotación @SpringBootApplication.
3. Realiza el escaneo de componentes (hola, @ComponentScan).

Cómo organizar el código dentro de src/main/java

Normalmente el código se divide en 3 capas: Controller, Service, Repository.

• Controller: se encarga de procesar las peticiones HTTP.
• Service: aquí vive la lógica de negocio.
• Repository: se ocupa de la interacción con la base de datos.

Ejemplo de estructura:

src/main/java/com/example/demo/
├── controller/
├── service/
└── repository/

Esta estructura, claro, no es obligatoria, pero es el estándar más común.

src/main/resources

Esta carpeta está destinada a almacenar todos los recursos no funcionales de tu aplicación. Si tienes archivos JSON, plantillas HTML, archivos de configuración o imágenes, vivirán aquí.

• static/: aquí van los recursos estáticos como CSS, JavaScript, imágenes.
• templates/: esta carpeta contiene las plantillas HTML (por ejemplo, si usas Thymeleaf).
• application.properties o application.yml: es el archivo principal de configuración, ya hemos "buceado" un poco en él en clases anteriores.

Ejemplo del contenido de application.properties:

server.port=8081
spring.datasource.url=jdbc:mysql://localhost:3306/demo
spring.datasource.username=root
spring.datasource.password=secret

Fíjate: Spring carga automáticamente los recursos desde esta carpeta. No necesitas escribir código extra para cargarlos — la magia de Spring lo hace todo por ti.

src/test/java

¿Testing? Sí, no hay escapatoria. Este directorio es tu mejor amigo para escribir tests unitarios, de integración y funcionales.

Ejemplo de test para la clase principal de la aplicación:

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class DemoApplicationTests {
    @Test
    void contextLoads() {
    }
}

Spring Boot configura automáticamente el entorno de pruebas, así que siempre puedes estar tranquilo respecto al correcto funcionamiento de tu aplicación.

Archivos raíz del proyecto

En el nivel superior de la estructura hay varios archivos importantes:

• pom.xml o build.gradle — herramienta para gestionar dependencias (Maven o Gradle). Aquí conectas las librerías necesarias para que todo funcione.
• mvnw y mvnw.cmd — el "wrapper" de Maven. Estos archivos permiten ejecutar Maven incluso si no está instalado en tu máquina.
• README.md — aquí normalmente se escribe la guía de uso del proyecto (aunque, siendo honestos, poca gente la usa).

Clase principal de la aplicación

@SpringBootApplication — tres anotaciones en una

@SpringBootApplication combina tres anotaciones:

1. @Configuration — permite usar la clase como una fuente de configuración.
2. @EnableAutoConfiguration — activa la mágica autoconfiguración de Spring Boot.
3. @ComponentScan — busca automáticamente componentes anotados como @Component, @Service, @Repository, etc.

Por eso, al añadir @SpringBootApplication, obtienes de golpe todo lo necesario de Spring Boot para arrancar la aplicación.

Archivo de configuración: application.properties o application.yml

Diferencia entre application.properties y application.yml

• application.properties: formato tradicional clave-valor.
• application.yml: forma más moderna, que soporta estructuras anidadas.

Ejemplo de application.properties:

server.port=8080
spring.application.name=DemoApplication

Ejemplo de application.yml:

server:
  port: 8080
spring:
  application:
    name: DemoApplication

YAML suele ser más legible, especialmente para configuraciones complejas.

Ahora tienes una idea de lo que hay dentro de un proyecto Spring Boot. Como se dice, "no juzgues un proyecto por el aspecto de sus carpetas hasta que no mires su src/main/java". Vamos a seguir para profundizar aún más en el mundo de Spring Boot.