Lección 144: Práctica: configuración del build de una aplicación Spring Boot usando Maven

Maven: recordatorio

Conceptos básicos en Maven:

• POM (Project Object Model) — es un archivo XML de configuración (pom.xml) que contiene toda la información sobre tu proyecto y sus dependencias.
• Fases: Maven ejecuta el build a través de un conjunto de etapas o fases (compile, test, package, etc.).
• Plugins: amplían la funcionalidad de Maven. Por ejemplo, un plugin para empaquetar la aplicación en jar/war.

Puedes leer más sobre Maven en la documentación oficial de Maven.

Preparación del proyecto Spring Boot

Crear un proyecto Maven

Para empezar, vamos a crear una aplicación Spring Boot usando Maven. Si ya tienes experiencia con Spring Boot Initializr, no te llevará mucho tiempo.

1. Crea un nuevo proyecto a través de Spring Initializr:
   • Elige Maven como tipo de build.
   • Indica el lenguaje Java y la versión de Spring Boot (por ejemplo, 3.1.0).
   • Añade dependencias: Spring Web (para crear REST API).
   • Descarga el zip del proyecto, descomprímelo y ábrelo en tu IDE.
2. Revisa la estructura del proyecto. Debería verse más o menos así:

src/
└── main/
    ├── java/
    │   └── com/example/demo/  // Paquete para tu aplicación
    │       └── DemoApplication.java
    └── resources/
        └── application.properties
pom.xml                            // Tu archivo principal de configuración de Maven

* Estructura de pom.xml*

Recordemos la estructura del archivo pom.xml. Define todas las dependencias, plugins y configuraciones. Ejemplo de contenido:

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.1.0</version>
        <relativePath />
    </parent>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

• groupId y artifactId: identifican tu proyecto.
• spring-boot-starter-parent: POM base de Spring Boot que establece ajustes importantes por defecto.
• dependencies: lista de librerías usadas en el proyecto (por ejemplo, Spring Web).
• spring-boot-maven-plugin: plugin para el build de aplicaciones Spring Boot.

Configuración del proceso de build con Maven

Añadir la fase de build

La fase de build en Maven —es cuando el proyecto se compila, se testea y se empaqueta en un archivo ejecutable (por ejemplo, jar). Para asegurarte de que todo funciona, ejecuta el comando:

mvn clean package

Qué ocurre aquí:

1. clean: elimina archivos generados anteriormente (la carpeta target).
2. package: compila el código (compile), ejecuta los tests (test), y luego empaqueta el proyecto en un archivo .jar que puedes ejecutar.

Después de una build exitosa, encontrarás el archivo en la carpeta target/, por ejemplo: demo-0.0.1-SNAPSHOT.jar. Ejecútalo:

java -jar target/demo-0.0.1-SNAPSHOT.jar

Prueba abrir en el navegador http://localhost:8080. Si ves un error 404, no te preocupes, es normal —¡todavía no tenemos controladores!

Añadir plugins personalizados

Para mejorar el proceso de build puedes añadir plugins útiles. Por ejemplo, para revisar el código en busca de errores o para indicar parámetros JVM al desplegar. Añadamos un plugin para crear un jar ejecutable:

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>3.3.0</version>
            <configuration>
                <archive>
                    <manifest>
                        <addClasspath>true</addClasspath>
                        <mainClass>com.example.demo.DemoApplication</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>
    </plugins>
</build>

Ahora el jar se ejecutará correctamente, incluso si quieres pasarle parámetros adicionales.

Parte práctica

Empaquetar la aplicación con dependencias

A veces la aplicación referencia librerías externas que no están disponibles en el entorno de ejecución. Para eso se puede crear un fat jar (o uber jar), que incluya todas las dependencias. En Spring Boot esto viene listo para usar. Simplemente ejecuta:

mvn clean install

Se creará un jar que incluye todas las dependencias. Puedes comprobar su tamaño con:

ls -lh target/

Manejo de tests en el proceso de build

Maven ejecuta automáticamente los tests antes del empaquetado. Vamos a añadir un test sencillo:

1. Crea el archivo src/test/java/com/example/demo/DemoApplicationTests.java con el contenido:

package com.example.demo;

import org.junit.jupiter.api.Test;

import static org.assertj.core.api.Assertions.assertThat;

class DemoApplicationTests {

    @Test
    void contextLoads() {
        // Prueba simple para comprobar si el contexto de Spring está vivo
        assertThat(1).isEqualTo(1);
    }
}

2. Ejecuta:

mvn clean test

Si todo va bien, Maven mostrará Tests run: 1, Failures: 0.

¿Qué hacer si algo no funciona?

Si durante la build o al ejecutar aparecen errores, aquí tienes algunos problemas típicos:

• Error "Main class not found": revisa si se ha indicado la entrada principal correctamente en la sección mainClass del plugin.
• Incompatibilidad de versiones de Java: asegúrate de que la JDK que estás usando coincide con la versión del proyecto (en este caso Java 17).
• No se descargan dependencias: comprueba que tienes conexión a Internet y revisa tus repositorios de Maven.

Ahora tienes el build listo de tu aplicación Spring Boot usando Maven. En la siguiente lección lo conectaremos a un pipeline automático de CI/CD usando GitLab CI. ¡Prepárate para automatizar! 🚀