Java

Maven Build Plugins

📘 Guía Lectiva: Introducción al Uso de Plugins y la Sección en Maven

🔧 ¿Qué es la sección `<build>` en Maven?

La sección <build> dentro de pom.xml indica a Maven cómo debe construirse tu proyecto. Esta sección permite especificar:

📂 Dónde está el código fuente.
🗂️ Dónde se generarán los archivos compilados.
🔌 Qué plugins usar y cómo configurarlos.

📄 Ejemplo de estructura básica:

<build>
  <sourceDirectory>src/main/java</sourceDirectory>
  <outputDirectory>target/classes</outputDirectory>
  <plugins>
    <!-- Aquí van los plugins -->
  </plugins>
</build>

🔌 ¿Qué son los plugins en Maven?

Los plugins en Maven son herramientas que se integran en el ciclo de vida del proyecto para realizar tareas específicas como:

Compilar el código Java.
Ejecutar pruebas unitarias.
Empaquetar el proyecto como .jar o .war.
Analizar el código con herramientas como Checkstyle o PMD.
Generar documentación.

Maven no ejecuta estas tareas por sí solo; usa plugins para realizar cada acción.

🌀 Fases del ciclo de vida de Maven

Maven tiene un ciclo de vida estándar dividido en fases. Algunos ejemplos comunes:

Fase	Descripción
`validate`	Verifica si el proyecto está correcto.
`compile`	Compila el código fuente.
`test`	Ejecuta las pruebas unitarias.
`package`	Empaqueta el proyecto (por ejemplo, en un `.jar`).
`install`	Instala el `.jar` en tu repositorio local.
`deploy`	Lo despliega a un repositorio remoto.

⚙️ Plugins comunes y su fase predeterminada

Plugin	Fase asociada	Tarea (goal)
`maven-compiler-plugin`	`compile`	`compile`
`maven-surefire-plugin`	`test`	`test`
`maven-jar-plugin`	`package`	`jar`
`maven-install-plugin`	`install`	`install`
`maven-deploy-plugin`	`deploy`	`deploy`

🧠 ¿Cómo saber en qué fase se ejecuta un plugin?

✅ Opción 1: Leer la documentación oficial

Cada plugin de Maven tiene su documentación en línea con información sobre en qué fase se ejecuta su “goal” por defecto.

✅ Opción 2: Usar el comando `mvn help:describe`

Este comando te permite inspeccionar cualquier plugin:

mvn help:describe -Dplugin=compiler

📄 Ejemplo práctico de `<build>` con plugins

<build>
  <plugins>
    <!-- Compilación del código -->
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>3.11.0</version>
      <configuration>
        <source>1.8</source>
        <target>1.8</target>
      </configuration>
    </plugin>

    <!-- Empaquetado como archivo JAR ejecutable -->
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-jar-plugin</artifactId>
      <version>3.3.0</version>
      <configuration>
        <archive>
          <manifest>
            <mainClass>com.ejemplo.Main</mainClass>
          </manifest>
        </archive>
      </configuration>
    </plugin>
  </plugins>
</build>

🧰 ¿Se pueden crear plugins personalizados?

¡Sí! Si necesitas lógica específica no disponible en los plugins existentes, puedes crear tu propio plugin Maven.

📦 Pasos para crear un plugin propio:

Crear un proyecto Maven.

Agregar dependencia:

<dependency>
  <groupId>org.apache.maven</groupId>
  <artifactId>maven-plugin-api</artifactId>
  <version>3.8.1</version>
</dependency>

Escribir tu clase con la anotación @Mojo:

@Mojo(name = "saluda", defaultPhase = LifecyclePhase.COMPILE)
public class SaludoMojo extends AbstractMojo {
  public void execute() {
    getLog().info("¡Hola desde mi plugin personalizado!");
  }
}

Compilar y empaquetar.
Instalar el plugin y usarlo en otro proyecto.

Overwriting build on pom.xml

Por defecto, Maven tiene comportamientos predefinidos para compilar, empaquetar, y ejecutar proyectos. Pero estos plugins permiten ajustar y extender ese comportamiento según tus necesidades.

Algunos ejemplos de plugins utilizados:

🔹 `<plugin>`: spring-boot-maven-plugin

Grupo: org.springframework.boot
Propósito: Permite empaquetar una aplicación Spring Boot como un “fat jar” (jar ejecutable con todas sus dependencias incluidas) y ofrece comandos como mvn spring-boot:run.
Configuración personalizada:
```
<excludes>
    <exclude>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </exclude>
</excludes>
```
Esto excluye lombok del jar final, ya que Lombok solo se necesita en tiempo de compilación (es un procesador de anotaciones). No hace falta en tiempo de ejecución, así que se evita incluirlo innecesariamente.

🔹 `<plugin>`: maven-compiler-plugin

Grupo: org.apache.maven.plugins
Versión: 3.11.0
Propósito: Controla la compilación del código Java.

Configuración personalizada:

<source>${java.version}</source>
<target>${java.version}</target>
<encoding>${project.build.sourceEncoding}</encoding>
<annotationProcessorPaths>
    <path>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>${lombok.version}</version>
    </path>
</annotationProcessorPaths>

Se establecen las versiones de Java a usar para fuente y bytecode (source y target).
Se configura Lombok como procesador de anotaciones, para que funcione correctamente durante la compilación.

🔹 `<plugin>`: exec-maven-plugin

Grupo: org.codehaus.mojo
Versión: 1.4.0
Propósito: Permite ejecutar clases Java desde Maven sin necesidad de empaquetar el proyecto.
Configuración personalizada:
```
<mainClass></mainClass>
```
- Aquí se espera que especifiques la clase principal que contiene el método public static void main(String[] args).
- Si se descomenta o se rellena con algo como:
```
<mainClass>com.cristianpeter.url.shortener.Application</mainClass>
```
  entonces puedes ejecutar el proyecto con:
```
mvn exec:java
```