Lección 147: Preparar una aplicación Spring Boot para el despliegue (crear archivos jar/war)

Hoy vamos a ver cómo convertir tu aplicación Spring Boot de un código mono en un artefacto real (jar o war) listo para ejecutarse en cualquier sitio: desde tu portátil local hasta servidores en la nube.

Objetivos principales de la lección

• Aprender cómo preparar correctamente una aplicación Spring Boot para el despliegue.
• Entender qué son los jar y war y en qué se diferencian.
• Configurar Maven para crear esos artefactos.
• Preparar el versionado de la aplicación para trabajar cómodamente en CI/CD.

Un poco de teoría: jar, war y por qué los necesitamos

JAR (Java Archive) — es un archivo empaquetado que contiene tu aplicación y todas sus dependencias. En palabras sencillas, es una "maleta" con todo dentro que puedes ejecutar tal cual:

java -jar your-app.jar

• Ventaja de los JAR: son "autosuficientes". Spring Boot mete dentro del JAR las dependencias y un servidor web embebido (por ejemplo, Tomcat).
• Cuándo usar:
  • Si la aplicación va a ejecutarse como un proceso independiente.
  • Si el servidor ya está preparado para trabajar con Spring Boot.

WAR (Web Application Archive) — es un archivo para aplicaciones web que normalmente se despliega en un servidor externo como Apache Tomcat o Jetty. No incluye un servidor embebido.

• Ventaja de los WAR: encajan bien para desplegar en un servidor ya en producción donde "se deja caer" tu artefacto.
• Cuándo usar:
  • Si tu proyecto forma parte de un sistema mayor.
  • Si la infraestructura del servidor está estrictamente regulada (por ejemplo, "usamos Tomcat y punto").

Práctica 1. Crear un archivo JAR

Vamos a empaquetar nuestra aplicación Spring Boot como JAR. Para eso hay que tocar un poco el pom.xml y ejecutar un par de comandos.

Paso 1. Preparar el proyecto

Asegúrate de tener un proyecto Spring Boot funcional. Si no lo tienes todavía —crea una app básica con Spring Initializer.

La estructura del proyecto debería verse más o menos así:

src/
|-- main/
|   |-- java/
|   |   |-- com.example.demo
|   |       |-- DemoApplication.java
|   |-- resources/
|       |-- application.properties
pom.xml

Paso 2. Configurar Maven para crear JAR

En el pom.xml asegúrate de que está configurada la generación del JAR. La configuración quedaría así:

<build>
    <plugins>
        <!-- Plugin para construir la aplicación Spring Boot -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
        <!-- Opcionalmente puedes añadir el plugin de recursos -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-resources-plugin</artifactId>
        </plugin>
    </plugins>
</build>

Fíjate que spring-boot-maven-plugin hace la mayor parte del trabajo: no solo empaqueta el JAR, sino que añade las dependencias y el servidor embebido.

Paso 3. Compilar el proyecto

Construye el JAR con el comando:

mvn clean install

Después de ejecutar, en la carpeta target aparecerá un archivo como:

demo-0.0.1-SNAPSHOT.jar

Lo ejecutamos así:

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

Si todo está bien configurado, verás que el servidor arranca en http://localhost:8080.

Práctica 2. Crear un archivo WAR

Ahora haremos lo mismo pero para un WAR. Aquí el proceso cambia un poco.

Paso 1. Configurar Maven para crear WAR

Añadimos en el pom.xml la configuración para WAR:

<packaging>war</packaging>

<build>
    <plugins>
        <!-- Plugin para construir la aplicación Spring Boot -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <failOnMissingWebXml>false</failOnMissingWebXml>
            </configuration>
        </plugin>
    </plugins>
</build>

Fíjate en packaging — este tag le dice a Maven que el proyecto debe empaquetarse como WAR.

Paso 2. Cambios en el código de la aplicación

Como el WAR no trae servidor embebido, tenemos que preparar la app para que funcione con un contenedor externo. En el archivo DemoApplication.java hacemos que la clase extienda SpringBootServletInitializer:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

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

Paso 3. Compilar el proyecto

Ahora construimos el proyecto:

mvn clean install

Como resultado obtendrás el archivo demo-0.0.1-SNAPSHOT.war.

Versionado de artefactos

Ya que estamos en modo deploy, vamos a hacer la aplicación un poco "más lista". Añade la versión del proyecto en el pom.xml para que los artefactos tengan nombres únicos:

<version>1.0.0</version>

Ahora tu JAR o WAR se llamará, por ejemplo, demo-1.0.0.jar. Esto es especialmente útil en CI/CD, porque te permite saber rápidamente qué versión está desplegada en el servidor.

Errores típicos y cómo resolverlos

1. Falta el tag <packaging> en el pom.xml.
   Si no pones <packaging>jar</packaging> (o war), Maven por defecto generará un JAR. Revisa siempre ese tag.
2. Error "No Main Manifest Attribute".
   Significa que en el paquete generado falta el punto de entrada. Asegúrate de que la clase DemoApplication tiene el método main, y de que Spring-Boot-Maven-Plugin está añadido en el pom.xml.
3. El WAR no se despliega en el servidor.
   Comprueba que añadiste la clase que extiende SpringBootServletInitializer.

¡Eso es todo! Ahora tu aplicación está lista para desplegarse, ya sea en un servidor local, en la nube o en una plataforma de contenedores. En las próximas lecciones nos meteremos de lleno con la containerización usando Docker.