Plugins de Maven

Los plugins de Maven son componentes ejecutables que amplían la funcionalidad de Maven. Cada plugin contiene uno o más objetivos (goals), que se utilizan para ejecutar tareas específicas (como compilar, probar, empaquetar, etc.).

Relación entre plugins y ciclo de vida:

  • Ciclo de vida (Lifecycle): define el orden de las fases (phase) de construcción.

  • Plugin: proporciona la implementación concreta (goal) para completar las tareas de estas fases.

Maven tiene los siguientes tres ciclos de vida estándar:

  • clean: manejo de la limpieza del proyecto
  • default (o build): manejo del despliegue del proyecto
  • site: manejo de la creación de documentación del sitio del proyecto

Cada ciclo de vida contiene una serie de fases (phase). Estas fases son equivalentes a la interfaz unificada que proporciona Maven, y su implementación la realizan los plugins de Maven.

Cuando ingresamos el comando mvn, por ejemplo,mvn clean, clean se corresponde con la fase clean del ciclo de vida Clean. Pero la operación concreta de clean esmaven-clean-pluginquien la implementa.

Por lo tanto, la implementación concreta de cada fase del ciclo de vida de Maven se realiza mediante plugins de Maven.

Maven es en realidad un marco de trabajo que depende de la ejecución de plugins; cada tarea se realiza realmente mediante plugins. Los plugins de Maven se utilizan normalmente para:

  • Crear archivos JAR
  • Crear archivos WAR
  • Compilar archivos de código
  • Pruebas unitarias de código
  • Crear documentación del proyecto
  • Crear informes del proyecto

Un plugin normalmente proporciona un conjunto de objetivos, y se puede ejecutar utilizando la siguiente sintaxis:

<code>mvn [plugin-name]:[goal-name]</code>

Por ejemplo, un proyecto Java se puede compilar utilizando el compile-goal de maven-compiler-plugin, con el siguiente comando:

<code>mvn compiler:compile</code>

Mecanismo central de los plugins

Coordenadas del plugin

Al igual que las dependencias, los plugins también se identifican de forma única mediante groupId, artifactId y version:

PropiedadDescripciónValores comunes
groupIdOrganización del pluginorg.apache.maven.plugins(Plugin oficial)
artifactIdNombre del pluginmaven-compiler-plugin
versionVersión del plugin3.8.1

Objetivos del plugin (Goals)

Cada plugin puede contener múltiples objetivos, por ejemplo:

  • maven-compiler-plugin:

    • compile: compila el código principal

    • testCompile: compila el código de prueba

  • maven-surefire-plugin:

    • test: ejecuta las pruebas unitarias

Métodos de vinculación de plugins

1. Vinculación integrada

Maven ya ha vinculado previamente objetivos de plugins a las fases del ciclo de vida:

Fase del ciclo de vidaObjetivo de plugin vinculado
compilemaven-compiler-plugin:compile
testmaven-surefire-plugin:test
packagemaven-jar-plugin:jar(omaven-war-plugin:war)

2. Vinculación personalizada

Configuración explícita en pom.xml:

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>
            <executions>
                <execution>
                    <phase>compile</phase>  <!-- 绑定到 compile 阶段 -->
                    <goals>
                        <goal>compile</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Plugins oficiales comunes

Relacionados con la compilación

PluginFunciónObjetivos comunes
maven-compiler-pluginCompilar código Javacompile, testCompile
maven-resources-pluginProcesar archivos de recursosresources, testResources

Ejemplo de configuración:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.8.1</version>
    <configuration>
        <source>11</source>  <!-- Java 版本 -->
        <target>11</target>
    </configuration>
</plugin>

Relacionados con las pruebas

PluginFunciónObjetivos comunes
maven-surefire-pluginEjecutar pruebas unitariastest
maven-failsafe-pluginEjecutar pruebas de integraciónintegration-test

Configuración para omitir pruebas:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.22.2</version>
    <configuration>
        <skipTests>true</skipTests>  <!-- 跳过测试 -->
    </configuration>
</plugin>

Relacionados con el empaquetado

PluginFunciónObjetivos comunes
maven-jar-pluginEmpaquetar archivos JARjar
maven-war-pluginEmpaquetar archivos WARwar
maven-assembly-pluginEmpaquetado personalizadosingle

Configuración de JAR ejecutable:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>3.2.0</version>
    <configuration>
        <archive>
            <manifest>
                <mainClass>com.example.Main</mainClass>  <!-- 指定主类 -->
            </manifest>
        </archive>
    </configuration>
</plugin>

Relacionados con el despliegue

PluginFunciónObjetivos comunes
maven-install-pluginInstalar en el repositorio localinstall
maven-deploy-pluginDesplegar al repositorio remotodeploy

Formas de invocar plugins

Invocar mediante el ciclo de vida:

mvn compile  # 触发 maven-compiler-plugin:compile

Invocar directamente el objetivo del plugin:

mvn compiler:compile  # 直接调用编译目标

Configuración de parámetros de línea de comandos:

mvn compiler:compile -Dmaven.compiler.source=11

Configuración personalizada de plugins

Configuración de parámetros

Medianteconfigurationla etiqueta se configura:

<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>

Ejecución de múltiples objetivos:

<executions>
    <execution>
        <id>run-tests</id>
        <phase>test</phase>
        <goals>
            <goal>test</goal>
        </goals>
    </execution>
</executions>

Fundamentos del desarrollo de plugins

Concepto de Mojo

  • La clase Java que corresponde a un objetivo de plugin se llamaMojo(Maven plain Old Java Object)。

  • debe heredar deAbstractMojoe implementarexecute()el método.

Ejemplo sencillo de plugin

Ejemplo

@Mojo(name = "greet", defaultPhase = LifecyclePhase.COMPILE)
public class GreetingMojo extends AbstractMojo {
    @Parameter(property = "name", defaultValue = "World")
    private String name;

    public void execute() throws MojoExecutionException {
        getLog().info("Hello, " + name + "!");
    }
}

Empaquetar e instalar plugins

mvn clean install  # 将插件安装到本地仓库

Tipos de plugins

Maven proporciona los siguientes dos tipos de plugins:

Tipo Descripción
Build plugins Se ejecuta durante la construcción, y en el pom.xml elelemento se configura.
Reporting plugins Se ejecuta durante la generación del sitio, y en el pom.xml elelemento se configura.

A continuación se muestra una lista de algunos plugins comunes:

Plugin Descripción
clean Limpia los archivos de destino después de la construcción. Elimina el directorio de destino.
compiler Compila los archivos fuente de Java.
surefile Ejecuta pruebas unitarias de JUnit. Crea informes de pruebas.
jar Construye un archivo JAR a partir del proyecto actual.
war Construye un archivo WAR a partir del proyecto actual.
javadoc Genera Javadoc para el proyecto.
antrun Ejecuta un conjunto de tareas ant desde cualquier fase del proceso de construcción.

Ejemplo

Ya hemos utilizado ampliamente en nuestros ejemplosmaven-antrun-pluginpara mostrar datos en la consola. ConsulteMaven - Perfiles de construccióncapítulo. Para entender esta parte de una mejor manera, cree un archivo pom.xml en el directorio C:\MVN\project.

<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.companyname.projectgroup</groupId> <artifactId>project</artifactId> <version>1.0</version> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-antrun-plugin</artifactId> <version>1.1</version> <executions> <execution> <id>id.clean</id> <phase>clean</phase> <goals> <goal>run</goal> </goals> <configuration> <tasks> <echo>clean phase</echo> </tasks> </configuration> </execution> </executions> </plugin> </plugins> </build> </project>

A continuación, abra la terminal de comandos, navegue al directorio donde se encuentra pom.xml y ejecute el siguiente comando mvn.

mvn clean

Maven comenzará a procesar y mostrará la fase clean del ciclo de vida clean.

[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------
[INFO] Building Unnamed - com.companyname.projectgroup:project:jar:1.0
[INFO]    task-segment: [post-clean]
[INFO] ------------------------------------------------------------------
[INFO] [clean:clean {execution: default-clean}]
[INFO] [antrun:run {execution: id.clean}]
[INFO] Executing tasks
     [echo] clean phase
[INFO] Executed tasks
[INFO] ------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------
[INFO] Total time: < 1 second
[INFO] Finished at: Sat Jul 07 13:38:59 IST 2012
[INFO] Final Memory: 4M/44M
[INFO] ------------------------------------------------------------------

El ejemplo anterior demuestra los siguientes conceptos clave:

  • Los plugins se definen en pom.xml mediante el elemento plugins.
  • Cada plugin puede tener múltiples objetivos.
  • Puede definir la fase, y el plugin comenzará a procesar utilizando su elemento phase. Ya hemos utilizadocleanla fase.
  • Puede configurar las tareas que se ejecutarán vinculándolas a los objetivos del plugin. Ya hemos vinculadoechola tarea al objetivo de maven-antrun-pluginrunobjetivo.
  • Y eso es todo. Maven se encargará del resto. Descargará los plugins que no estén disponibles en el repositorio local y comenzará el procesamiento.
Otras extensiones