Maven para principiantes: conceptos básicos

Programación > Maven > Maven para principiantes: conceptos básicos

Bienvenido a esta introducción a Apache Maven. Si estás empezando en el mundo del desarrollo de software en Java, pronto descubrirás que gestionar proyectos, sus dependencias (las librerías que usa vuestro código) y el proceso de construcción (compilar, probar, empaquetar…) puede volverse complejo. Aquí es donde Maven entra en juego para simplificarnos la vida.

En esta primera sesión, vamos a entender qué es Maven, por qué lo necesitamos y daremos nuestros primeros pasos creando un proyecto Maven básico usando IntelliJ IDEA. ¡Olvidémonos de la línea de comandos por ahora y centrémonos en cómo nuestro IDE nos ayuda!

¿Qué es Maven?

Imagina que estás construyendo una casa muy compleja. Necesitarás ladrillos, cemento, tuberías, cables… y cada uno de estos «componentes» podría venir de diferentes fabricantes y tener diferentes versiones. Gestionar todo esto manualmente sería una pesadilla, ¿verdad?

En el desarrollo de software, nuestros «componentes» son librerías (archivos JAR) que nos proporcionan funcionalidades ya hechas: para trabajar con fechas, conectar a bases de datos, crear interfaces gráficas, etc.

El Problema Histórico: El «JAR Hell»

Antiguamente (y a veces, todavía hoy sin herramientas adecuadas), los desarrolladores tenían que:

Buscar manualmente las librerías en internet.
Descargar los archivos JAR correctos.
Añadirlos manualmente al proyecto.
Asegurarse de que las versiones de diferentes librerías fueran compatibles entre sí (¡la parte más difícil!).
Si una librería necesitaba otra librería (dependencia transitiva), repetir el proceso.

Esto llevaba a proyectos con carpetas lib llenas de JARs, problemas de versiones y una gran dificultad para compartir proyectos o que otros desarrolladores pudieran compilarlos fácilmente. A esto se le conocía como el «JAR Hell» (el infierno de los JARs).

La solución que nos da Maven

Maven es una herramienta de gestión y construcción de proyectos que automatiza gran parte de este trabajo. No solo compila código, sino que también gestiona librerías externas (dependencias), ejecuta pruebas, empaqueta el resultado y mucho más. Sus principales funciones son:

Gestión de Dependencias: adiós al infierno de los JAR. Le dices a Maven qué librerías necesitas (y qué versión), y él se encarga de descargarlas automáticamente de repositorios centrales y añadirlas a tu proyecto. ¡Adiós a la búsqueda manual!
Estandarización del Proceso de Construcción (Build): Define una estructura de directorios y un ciclo de vida estándar para compilar tu código, ejecutar tests, empaquetar tu aplicación (por ejemplo, en un archivo JAR ejecutable) y mucho más. Esto asegura que todos los proyectos Maven se construyan de la misma manera.
Gestión de Proyectos: Proporciona una forma estándar de describir la información de tu proyecto.
Reproducibilidad: Asegura que el proyecto se construya de la misma manera en diferentes entornos.

Ventajas Clave de Usar Maven:

Consistencia y convención: al seguir una estructura y unos flujos predefinidos, todos los proyectos Maven tienen una estructura y un proceso de construcción similares.
Facilidad para añadir librerías gracias a la centralización de dependencias. Solo necesitas declarar la dependencia y Maven hace el resto.
Automatización: Simplifica tareas repetitivas como compilar, probar y empaquetar.
Colaboración: Facilita que varios desarrolladores trabajen en el mismo proyecto y que otros puedan entenderlo y construirlo rápidamente.

El Corazón de Maven: pom.xml (Project Object Model)

Todo proyecto Maven se define mediante un archivo llamado pom.xml. Podemos decir que este archivo XML es el cerebro del proyecto, ya que contiene toda la información de configuración de un proyecto Maven:

Qué es el proyecto.
Cómo se construye.
Qué dependencias necesita.
Plugins a utilizar.
Y mucho más.

Los elementos mínimos esenciales que debe contener son:

<project>: Elemento raíz.
<modelVersion>: Versión del modelo POM (actualmente 4.0.0).
<groupId>: Identificador del grupo u organización que crea el proyecto (ej: com.miempresa, org.apache). Suele ser el nombre de dominio invertido.
<artifactId>: Identificador único del proyecto dentro del grupo (ej: mi-aplicacion, commons-lang).
<version>: Versión del proyecto (ej: 1.0.0, 1.0-SNAPSHOT).

Aquí tienes un ejemplo básico:

<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.misclases.dam</groupId>
    <artifactId>mi-primera-app-maven</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!-- Aquí irán dependencias, plugins, etc. -->

</project>

Las Coordenadas Maven (GAV): La Identidad Única

Cada proyecto Maven (y cada librería que usamos) tiene una «dirección» única en el universo Maven. Estas son sus coordenadas, conocidas como GAV, que puedes consultar en el ejemplo de antes:

groupId: identifica a la organización, grupo o empresa que crea el proyecto. Suele seguir el formato de nombre de dominio invertido (ej: com.miescuela.dam, org.apache.commons).
artifactId: es el nombre único del proyecto o librería dentro de ese grupo (ej: mi-primera-app, commons-lang3).
version: indica la versión específica del proyecto o librería (ej: 1.0-SNAPSHOT, 3.12.0).
- SNAPSHOT indica una versión en desarrollo, no estable.
Opcionalmente, también pueden incluir:
- <packaging>: cómo se debe empaquetar el proyecto. Lo más común para aplicaciones de escritorio o librerías es jar. Para aplicaciones web, sería war.
- <name>: Un nombre descriptivo para el proyecto.
- <classifier>: para especificar variantes del artefacto, por ejemplo cuando el mismo artefacto debe estar preparado para distintos entornos o configuraciones.
- <description>: Una descripción más detallada.
- <properties>: Aquí se pueden definir variables reutilizables, como la versión de Java que usa el proyecto.

Cuando añades una dependencia, estás especificando su GAV para que Maven sepa exactamente qué descargar.

Importante: Estas coordenadas son cruciales para declarar dependencias y para que otros proyectos puedan usar el tuyo.

En el siguiente ejemplo tienes un pom.xml funcional. Verás los valores comunes que se suelen utilizar para los campos que hemos visto, además de dependencias y configuración, que por ahora no vamos a tocar. Puedes usar este archivo como plantilla y hacer las modificaciones que necesites.

<?xml version="1.0" encoding="UTF-8"?>
<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>

    <!-- Información del Proyecto -->
    <groupId>com.example</groupId>  <!-- Identificador del grupo (generalmente el dominio de la empresa) -->
    <artifactId>mi-proyecto</artifactId>  <!-- Nombre del artefacto (el nombre del proyecto) -->
    <version>1.0.0-SNAPSHOT</version>  <!-- Versión del proyecto (SNAPSHOT indica desarrollo) -->
    <packaging>jar</packaging>  <!-- Tipo de empaquetado (jar, war, pom, etc.) -->

    <name>Mi Proyecto Ejemplo</name>  <!-- Nombre legible del proyecto -->
    <classifier>sources</classifier>  <!-- Opcional: clasificador para diferentes variantes (e.g., sources, javadoc) -->
    <description>Este es un proyecto de ejemplo para Maven.</description>  <!-- Descripción del proyecto -->

    <!-- Propiedades del Proyecto -->
    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>  <!-- Versión de Java del compilador -->
        <maven.compiler.target>1.8</maven.compiler.target>  <!-- Versión de Java de destino -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  <!-- Codificación de caracteres -->
    </properties>

    <!-- Dependencias del Proyecto -->
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>  <!-- Alcance de la dependencia (test, compile, provided, etc.) -->
        </dependency>
    </dependencies>

    <!-- Configuración de Builds (Opcional) -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>${maven.compiler.source}</source>
                    <target>${maven.compiler.target}</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

Estructura de directorios estándar de Maven

Maven promueve una estructura estándar de directorios para simplificar la configuración de proyectos. Sería interesante contemplar esta estructura aunque no estés usando Maven, sin embargo muchas veces el IDE que estés utilizando define su propia estructura que no siempre es esta.

Aquí tienes como quedaría la estructura principal:

mi-proyecto/
├── pom.xml                 (Archivo de definición del proyecto)
├── src/
│   ├── main/
│   │   ├── java/           (Código fuente Java de la aplicación)
│   │   └── resources/      (Archivos de recursos, ej: properties, XMLs)
│   └── test/
│       ├── java/           (Código fuente Java de los tests unitarios)
│       └── resources/      (Archivos de recursos para los tests)
└── target/                 (Directorio generado por Maven: clases compiladas, JARs, etc.)

¿Qué ventajas aporta esta estructura?

Cualquier desarrollador familiarizado con Maven puede entender rápidamente la estructura del proyecto.
Los plugins de Maven saben dónde encontrar el código y los recursos sin configuración adicional.

¡Manos a la Obra! Creando Nuestro Primer Proyecto Maven en IntelliJ IDEA

Ahora, vamos a crear un proyecto «Hola Mundo» con Maven usando IntelliJ IDEA.

Abrir IntelliJ IDEA.
Crear un Nuevo Proyecto:
- Haz clic en File > New > Project…
- En el panel izquierdo, selecciona Maven.
- Archetype (Plantilla): Maven utiliza «arquetipos» como plantillas para crear diferentes tipos de proyectos. Para un proyecto Java simple, puedes:
  - Marcar la casilla Create from archetype.
  - Seleccionar el arquetipo org.apache.maven.archetypes:maven-archetype-quickstart. Esto nos creará una estructura básica con una clase App.java y un test AppTest.java.
  - (Si no quieres usar un arquetipo, simplemente no marques la casilla. IntelliJ creará una estructura Maven mínima).
- Haz clic en Next.
- Project Settings:
  - Name: Dale un nombre a tu proyecto, por ejemplo, MiPrimeraAppMaven. Este se usará como artifactId por defecto.
  - Location: Elige dónde guardar tu proyecto.
  - GroupId: Introduce tu groupId, por ejemplo, com.miescuela.dam.
  - ArtifactId: Si no lo has cambiado en «Name», aquí puedes refinarlo.
  - Version: Deja la que viene por defecto (1.0-SNAPSHOT).
- Haz clic en Finish (o Create según tu versión de IntelliJ).

IntelliJ creará el proyecto y puede que tarde un poco la primera vez mientras configura todo y descarga lo necesario.

Explorando la Estructura del Proyecto Generado

Una vez creado, verás la siguiente estructura de carpetas en el panel «Project» (vista «Project Files»):

MiPrimeraAppMaven (o el nombre de tu proyecto)
- .idea: Carpeta de configuración específica de IntelliJ. (No la toques).
- src (Source: Código Fuente)
  - main
    - java: Aquí va tu código fuente principal (ej: com.miescuela.dam.App.java).
    - resources: Aquí irían archivos de configuración, imágenes, etc., que se empaquetan con tu aplicación.
  - test
    - java: Aquí van tus tests unitarios (ej: com.miescuela.dam.AppTest.java).
- pom.xml: ¡Nuestro archivo de configuración de Maven!

Abre el archivo pom.xml haciendo doble clic sobre él. Verás las coordenadas GAV que definiste, el arquetipo (si lo usaste) y algunas dependencias básicas como JUnit (para tests) si usaste el quickstart.

La Ventana «Maven» en IntelliJ: Tu Centro de Control

IntelliJ IDEA tiene una ventana específica para interactuar con Maven.

Para abrirla: Ve a View > Tool Windows > Maven. Normalmente aparece como una pestaña en el lateral derecho.
Funciones Clave:
- Reload All Maven Projects (Icono de Sincronización/Recarga): Este botón es MUY IMPORTANTE. Cada vez que hagas un cambio en tu archivo pom.xml (como añadir una dependencia o cambiar una propiedad), debes hacer clic en este botón para que IntelliJ y Maven lean los cambios y actualicen el proyecto. A veces, IntelliJ muestra una pequeña barra flotante preguntando «Load Maven Changes» cuando detecta cambios en el pom.xml.
- Lifecycle: Verás las fases del ciclo de vida de Maven (hablaremos de esto en otra sesión).
- Plugins: Los plugins que usa tu proyecto.
- Dependencies: Una lista de todas las dependencias de tu proyecto.

Ajustando Nuestro pom.xml (Ej: Versión de Java)

Vamos a asegurarnos de que nuestro proyecto está configurado para Java 1.8.

Abre tu pom.xml.
Busca la sección <properties>. Si no existe, puedes añadirla dentro de la etiqueta <project> (generalmente antes de <dependencies> o <build>).
Asegúrate o añade las siguientes líneas dentro de <properties>, teniendo en cuenta que:
- maven.compiler.source: Le dice al compilador de Maven qué versión de Java usa tu código fuente.
- maven.compiler.target: Le dice al compilador qué versión de bytecode de Java debe generar (para qué versión de JVM es compatible).

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
</properties>

¡Importante! Después de guardar el pom.xml, haz clic en el botón «Load Maven Changes» (o el icono de recarga) en la ventana Maven o en la notificación que aparece.

Ejecutando Nuestra Primera Aplicación

Si usaste el arquetipo maven-archetype-quickstart, tendrás una clase App.java con un método main que imprime «Hello World!».

Ve a src/main/java.
Expande tu paquete (ej: com.miescuela.dam).
Haz clic derecho sobre App.java.
Selecciona Run ‘App.main()’.

Deberías ver «Hello World!» en la consola «Run» de IntelliJ. Esto confirma que tu código Java básico funciona. De momento, esta ejecución es la estándar de IntelliJ, no estamos usando Maven para ejecutarla directamente (aunque Maven sí ha compilado el código si fuera necesario).

Resumen de esta introducción a Maven

¡Enhorabuena! En esta primera sesión has aprendido:

Qué es Maven y los problemas que resuelve (gestión de dependencias, estandarización).
El papel fundamental del archivo pom.xml.
Las coordenadas Maven (GAV): groupId, artifactId, version.
Cómo crear un proyecto Maven básico desde IntelliJ IDEA.
La estructura de carpetas de un proyecto Maven.
Cómo usar la ventana Maven en IntelliJ y la importancia de recargar los cambios del pom.xml.
Cómo especificar la versión de Java en el pom.xml.

En la próxima sesión, nos sumergiremos en la gestión de dependencias. Aprenderemos cómo añadir librerías externas a nuestro proyecto.

¡Hasta la próxima y no dudéis en dejar vuestras preguntas!

Modo Debug

Ejecuta, falla, aprende…