Maven es una herramienta de gestión y comprensión de proyectos que proporciona una forma de ayudar a los desarrolladores a gestionar la construcción, reporte y documentación de un proyecto desde una información central. Maven utiliza un archivo de configuración llamado pom.xml (Project Object Model) para gestionar las dependencias del proyecto, la compilación, las pruebas y el despliegue.

1. POM (Project Object Model): Es el archivo principal de configuración de Maven (pom.xml). Contiene información sobre el proyecto y las configuraciones de construcción.
2. Dependencias: Librerías externas que el proyecto necesita para compilar y ejecutar.
3. Repositorios: Lugares donde Maven busca las dependencias. Pueden ser locales (en tu máquina) o remotos (en internet).
4. Plugins: Extensiones que permiten a Maven realizar tareas adicionales como compilación, empaquetado, pruebas, etc.
5. Ciclo de Vida de Construcción: Conjunto de fases que definen el proceso de construcción de un proyecto.

Instalación de Maven

1. Descargar Maven: Visita Apache Maven y descarga la última versión.
2. Configurar Variables de Entorno:
   • Añade MAVEN_HOME apuntando al directorio de Maven.
   • Añade MAVEN_HOME/bin al PATH.

Verificación de la Instalación

Abre una terminal y ejecuta:

Deberías ver la versión de Maven y la configuración de Java.

Un proyecto Maven típico tiene la siguiente estructura de directorios:

Para crear un nuevo proyecto Maven, usa el siguiente comando:

Esto generará un proyecto básico con la estructura mencionada anteriormente.

El archivo pom.xml es el corazón de un proyecto Maven. Aquí hay un ejemplo básico:

Las dependencias se declaran en el archivo pom.xml dentro de la etiqueta <dependencies>. Aquí hay un ejemplo de cómo agregar una dependencia:

Maven busca dependencias en repositorios. Los repositorios pueden ser locales o remotos. El repositorio central de Maven es https://repo.maven.apache.org/maven2.

Los plugins son componentes que permiten a Maven realizar tareas adicionales. Aquí hay un ejemplo de cómo configurar el plugin de compilación de Maven:

Maven tiene un ciclo de vida de construcción que consta de varias fases. Las fases más comunes son:

• validate: Verifica que el proyecto es correcto y toda la información necesaria está disponible.
• compile: Compila el código fuente del proyecto.
• test: Ejecuta las pruebas unitarias.
• package: Empaqueta el código compilado en un formato distribuible, como un JAR.
• verify: Ejecuta cualquier verificación necesaria en los resultados del test.
• install: Instala el paquete en el repositorio local.
• deploy: Copia el paquete final a un repositorio remoto para compartirlo con otros desarrolladores.

Vamos a crear un proyecto Maven simple que utiliza JUnit para pruebas unitarias.

1. Crear el Proyecto:

   mvn archetype:generate -DgroupId=com.example -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
   

2. Modificar el Archivo POM:

   <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>my-app</artifactId>
       <version>1.0-SNAPSHOT</version>
   
       <dependencies>
           <dependency>
               <groupId>junit</groupId>
               <artifactId>junit</artifactId>
               <version>4.12</version>
               <scope>test</scope>
           </dependency>
       </dependencies>
   </project>
   

3. Escribir una Clase de Prueba:

   package com.example;
   
   import org.junit.Test;
   import static org.junit.Assert.assertEquals;
   
   public class AppTest {
       @Test
       public void testApp() {
           assertEquals(1, 1);
       }
   }
   

4. Compilar y Ejecutar Pruebas:

   mvn clean compile
   mvn test
   

1. Ejercicio 1: Crea un proyecto Maven que incluya una dependencia de log4j y configura un archivo de log básico.
2. Ejercicio 2: Modifica el archivo pom.xml para incluir el plugin de empaquetado maven-jar-plugin y genera un archivo JAR ejecutable.
3. Ejercicio 3: Configura un proyecto Maven para usar el plugin maven-surefire-plugin y ejecuta pruebas unitarias con JUnit 5.

Ejercicio 1

1. Crear el Proyecto:

   mvn archetype:generate -DgroupId=com.example -DartifactId=my-log-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
   

2. Modificar el Archivo POM:

   <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>my-log-app</artifactId>
       <version>1.0-SNAPSHOT</version>
   
       <dependencies>
           <dependency>
               <groupId>log4j</groupId>
               <artifactId>log4j</artifactId>
               <version>1.2.17</version>
           </dependency>
       </dependencies>
   </project>
   

3. Configurar log4j: Crea un archivo log4j.properties en src/main/resources:

   log4j.rootLogger=DEBUG, stdout
   
   log4j.appender.stdout=org.apache.log4j.ConsoleAppender
   log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
   log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n
   

4. Escribir una Clase de Prueba:

   package com.example;
   
   import org.apache.log4j.Logger;
   
   public class App {
       private static final Logger logger = Logger.getLogger(App.class);
   
       public static void main(String[] args) {
           logger.debug("Debug Message");
           logger.info("Info Message");
           logger.error("Error Message");
       }
   }
   

5. Compilar y Ejecutar:

   mvn clean compile
   mvn exec:java -Dexec.mainClass="com.example.App"
   

Ejercicio 2

1. Modificar el Archivo POM:

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

2. Empaquetar el Proyecto:

   mvn clean package
   

3. Ejecutar el JAR:

   java -jar target/my-log-app-1.0-SNAPSHOT.jar
   

Ejercicio 3

1. Modificar el Archivo POM:

   <dependencies>
       <dependency>
           <groupId>org.junit.jupiter</groupId>
           <artifactId>junit-jupiter-api</artifactId>
           <version>5.7.0</version>
           <scope>test</scope>
       </dependency>
       <dependency>
           <groupId>org.junit.jupiter</groupId>
           <artifactId>junit-jupiter-engine</artifactId>
           <version>5.7.0</version>
           <scope>test</scope>
       </dependency>
   </dependencies>
   
   <build>
       <plugins>
           <plugin>
               <groupId>org.apache.maven.plugins</groupId>
               <artifactId>maven-surefire-plugin</artifactId>
               <version>2.22.2</version>
               <configuration>
                   <includes>
                       <include>**/*Test.java</include>
                   </includes>
               </configuration>
           </plugin>
       </plugins>
   </build>
   

2. Escribir una Clase de Prueba:

   package com.example;
   
   import org.junit.jupiter.api.Test;
   import static org.junit.jupiter.api.Assertions.assertEquals;
   
   public class AppTest {
       @Test
       public void testApp() {
           assertEquals(1, 1);
       }
   }
   

3. Ejecutar Pruebas:

   mvn clean test
   

Maven es una herramienta poderosa para la gestión de proyectos Java. Facilita la gestión de dependencias, la compilación, las pruebas y el despliegue de aplicaciones. Con una comprensión básica de su estructura y funcionamiento, puedes mejorar significativamente tu flujo de trabajo de desarrollo. En el siguiente módulo, exploraremos cómo construir aplicaciones del mundo real utilizando Maven y otros frameworks populares de Java.