Introducción a Maven

Apache Maven es una herramienta de automatización de construcción (build automation) para proyectos Java. Toma tu código fuente y produce un entregable (un archivo .jar o .war) orquestando todas las etapas: compilación, pruebas, empaquetado, gestión de dependencias.

En concreto, Maven responde a tres necesidades fundamentales:

El corazón de Maven es un archivo único, el pom.xml (Project Object Model), que describe el proyecto: su identidad, sus dependencias y la forma de construirlo. Es la «receta» que Maven ejecuta.

Sin Maven, construir un proyecto Java significa compilar a mano con javac, descargar cada biblioteca manualmente y gestionar uno mismo el classpath. Maven automatiza todo eso a partir de un solo archivo.

🔧 Mini-ejercicio — Cita las tres necesidades fundamentales a las que Maven responde.

Antes de Maven, cada proyecto Java se construía «a mano» o con scripts caseros. Eso planteaba varios problemas recurrentes:

La idea maestra: un desarrollador que se une a un proyecto Maven sabe de inmediato dónde está el código, dónde están las pruebas y cómo lanzar la construcción, da igual la empresa o el proyecto.

# Con Maven, construir un proyecto desconocido se resume a:
mvn package

Maven transforma «¿cómo se construye este proyecto?» —una pregunta que a veces costaba horas— en un solo comando universal.

🔧 Mini-ejercicio — Escribe el único comando que basta para construir un proyecto Maven desconocido.

mvn package

El principio central de Maven es «convención antes que configuración» (convention over configuration). En lugar de describirlo todo de forma explícita, Maven parte de valores por defecto sensatos. Si respetas las convenciones, casi no tienes nada que configurar.

Ejemplos de convenciones por defecto:

Comparemos las filosofías:

Siempre puedes redefinir las convenciones si hace falta, pero el 95 % de los proyectos se conforma con los valores por defecto. Menos configuración = menos bugs.

Todo proyecto Maven sigue la misma arborescencia. Conocerla permite navegar al instante en cualquier proyecto.

Detalle de las carpetas:

🔧 Mini-ejercicio — ¿En qué carpeta debes colocar una clase de prueba unitaria, y en cuál un archivo application.properties?

# Arborescencia típica vista en la línea de comandos
mon-projet/
├── pom.xml
├── src/
│   ├── main/
│   │   ├── java/        # ej. com/exemple/App.java
│   │   └── resources/   # ej. application.properties
│   └── test/
│       └── java/        # ej. com/exemple/AppTest.java
└── target/              # generado: no versionar (.gitignore)

⚠️ La carpeta target/ se regenera en cada build. Añádela a tu .gitignore: nunca se versionan los artefactos compilados.

Maven necesita un JDK (Java Development Kit) ya instalado, porque se apoya en el compilador javac. La variable JAVA_HOME debe apuntar a ese JDK.

Según tu sistema:

Instalación manual (todas las plataformas):

# 1. Verificar primero que Java está presente
java -version
# Debe mostrar una versión 17+ por ejemplo

# 2. Definir JAVA_HOME (ejemplo Linux/macOS)
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk

# 3. Descargar Maven desde maven.apache.org, descomprimir,
#    luego añadir la carpeta bin/ al PATH
export PATH=$PATH:/opt/apache-maven-3.9.6/bin

En Windows, JAVA_HOME se configura en «Variables de entorno». En Linux/macOS, añade la línea export a tu ~/.bashrc o ~/.zshrc para que sea permanente.

Una vez Maven instalado, se verifica que funciona y se genera un primer esqueleto de proyecto.

# Verificar la versión instalada
mvn -version

Salida típica:

Apache Maven 3.9.6
Maven home: /opt/apache-maven-3.9.6
Java version: 17.0.9, vendor: Eclipse Adoptium

Para generar un proyecto vacío que respete las convenciones, se usa un arquetipo (una plantilla):

# Genera un proyecto «quickstart» estándar
mvn archetype:generate \
  -DgroupId=com.exemple \
  -DartifactId=mon-app \
  -DarchetypeArtifactId=maven-archetype-quickstart \
  -DinteractiveMode=false

El primer mvn es lento: Maven descarga sus propios plugins en una caché local (~/.m2/repository). Los builds siguientes son mucho más rápidos.

🔧 Mini-ejercicio — Escribe el comando que muestra la versión de Maven instalada (y la de Java).

mvn -version

Question 1

¿Qué designa el archivo pom.xml en un proyecto Maven?

a) El código fuente principal de la aplicación

b) El Project Object Model: la receta que describe el proyecto y su build

c) El resultado compilado del proyecto

d) Un archivo de logs

Question 2

¿Dónde espera Maven encontrar por defecto el código fuente principal?

a) code/

b) target/main

c) src/main/java

d) java/source

Question 3

¿Qué significa «convención antes que configuración»?

a) Hay que configurarlo todo de forma explícita

b) Maven usa valores por defecto sensatos, lo que reduce la configuración necesaria

c) Nunca se puede cambiar el comportamiento de Maven

d) Maven no tiene archivo de configuración

Question 4

¿Qué carpeta genera Maven automáticamente y no debe versionarse?

a) src/main/java

b) src/test/java

c) target/

d) resources/

Question 5

¿Qué necesita Maven para funcionar?

a) Un servidor web

b) Un JDK instalado y JAVA_HOME configurado

c) Una base de datos

d) Node.js

Corrigé

1. b — El pom.xml es el Project Object Model: identidad, dependencias y receta de build.
2. c — Por convención, el código principal está en src/main/java.
3. b — Las convenciones por defecto reducen la configuración; se pueden redefinir.
4. c — target/ se regenera en cada build y no se versiona.
5. b — Maven necesita un JDK y JAVA_HOME apuntando a ese JDK.

Consigna

Verifica tu instalación de Maven, genera un proyecto «quickstart» llamado mon-app en el grupo com.exemple, luego constrúyelo y localiza el artefacto producido.

Corrección — Secuencia de comandos esperada

# 1. Verificar Maven y Java
mvn -version

# 2. Generar el proyecto a partir del arquetipo quickstart
mvn archetype:generate \
  -DgroupId=com.exemple \
  -DartifactId=mon-app \
  -DarchetypeArtifactId=maven-archetype-quickstart \
  -DinteractiveMode=false

# 3. Entrar en el proyecto e inspeccionar la estructura
cd mon-app
ls -R          # o «tree» si está disponible

# 4. Construir el proyecto
mvn package

# 5. Localizar el artefacto generado
ls target/

Resultado esperado:

target/
├── classes/
├── mon-app-1.0-SNAPSHOT.jar   <-- el artefacto producido
└── ...
BUILD SUCCESS

La arborescencia generada debe contener:

mon-app/
├── pom.xml
└── src/
    ├── main/java/com/exemple/App.java
    └── test/java/com/exemple/AppTest.java

Si mvn package muestra BUILD SUCCESS y aparece un .jar en target/, tu cadena Maven está operativa. El sufijo -SNAPSHOT indica una versión en curso de desarrollo (véase la lección 02).

Puntos a recordar

1. Maven es una herramienta de automatización de build para Java: compila, prueba, empaqueta y gestiona las dependencias.
2. El pom.xml es la receta única que describe el proyecto y su build.
3. Convención antes que configuración: los valores por defecto minimizan lo que debes escribir.
4. Estructura estándar: src/main/java, src/test/java, src/main/resources, salida en target/.
5. Maven necesita un JDK y JAVA_HOME; se verifica con mvn -version.

A continuación

Lección 02 — El archivo pom.xml: diseccionar en detalle la receta de Maven — coordenadas del proyecto, propiedades y herencia parent.