1. Introducción
Maven ofrece una gran variedad de complementos para ayudarnos con la construcción de nuestro proyecto. Sin embargo, podemos encontrar casos en los que estos complementos no sean suficientes y tengamos que desarrollar los nuestros.
Afortunadamente, Maven proporciona algunas herramientas útiles para ayudarnos en este proceso.
En este tutorial, seremos bastante prácticos y mostraremos paso a paso cómo crear un complemento de Maven desde cero.
También mostraremos cómo usarlo en nuestros proyectos y cómo crear documentación para él.
2. Creación de un complemento
Durante este tutorial, desarrollaremos un complemento llamado counter-maven-plugin que contará la cantidad de dependencias que contiene un proyecto. Es muy importante seguir la convención de nomenclatura de complementos que recomienda Maven cuando elegimos el nombre de nuestro complemento.
Ahora que sabemos lo que vamos a desarrollar, lo siguiente que debemos hacer es crear un proyecto Maven. En pom.xml definiremos el groupId , artifactId y la versión de nuestro complemento:
4.0.0 com.baeldung counter-maven-plugin maven-plugin 0.0.1-SNAPSHOT counter-maven-plugin Maven Mojo //maven.apache.org 1.8 1.8 Observe que configuramos el paquete en maven-plugin .
En este caso, hemos creado el proyecto manualmente, pero también podríamos hacerlo usando maven-archetype-mojo :
mvn archetype:generate -DgroupId=com.baeldung -DartifactId=counter-maven-plugin -Dversion=0.0.1-SNAPSHOT -DarchetypeGroupId=org.apache.maven.archetypes -DarchetypeArtifactId=maven-archetype-mojoAl hacer esto, debemos actualizar las versiones predeterminadas de las dependencias para usar las más recientes.
3. Creando un Mojo
Ahora es el momento de crear nuestro primer mojo. Mojo es una clase de Java que representa un objetivo que ejecutará nuestro complemento . Un complemento contiene uno o más mojos.
Nuestro mojo se encargará de contar el número de dependencias de un proyecto.
3.1. Agregar dependencias
Antes de crear el mojo, necesitamos agregar algunas dependencias a nuestro pom.xml :
org.apache.maven maven-plugin-api 3.6.3 org.apache.maven.plugin-tools maven-plugin-annotations 3.6.0 provided org.apache.maven maven-project 2.2.1 La dependencia maven-plugin-api es necesaria y contiene las clases e interfaces necesarias para crear nuestro mojo . La dependencia maven-plugin-annotations es útil para usar anotaciones en nuestras clases. La dependencia del proyecto maven nos permite acceder a la información sobre el proyecto en el que incluimos el complemento.
3.2. Creando la clase Mojo
¡Ahora estamos listos para crear nuestro mojo!
Un mojo tiene que implementar la interfaz de Mojo . En nuestro caso, extenderemos desde AbstractMojo por lo que solo tendremos que implementar el método de ejecución :
@Mojo(name = "dependency-counter", defaultPhase = LifecyclePhase.COMPILE) public class DependencyCounterMojo extends AbstractMojo { // ... }Como podemos ver, dependencia-contador es el nombre del objetivo. Por otro lado, lo hemos adjuntado a la fase de compilación de forma predeterminada, por lo que no necesariamente tendremos que especificar una fase al usar este objetivo.
Para tener acceso a la información del proyecto, tenemos que agregar un MavenProject como parámetro:
@Parameter(defaultValue = "${project}", required = true, readonly = true) MavenProject project;Este objeto será inyectado por Maven cuando se cree el contexto.
En este punto, podemos implementar el método de ejecución y contar el número de dependencias del proyecto:
public void execute() throws MojoExecutionException, MojoFailureException { List dependencies = project.getDependencies(); long numDependencies = dependencies.stream().count(); getLog().info("Number of dependencies: " + numDependencies); }El método getLog () proporciona acceso al registro de Maven. El AbstractMojo ya maneja su ciclo de vida.
3.3. Agregar parámetros
El parámetro que agregamos antes es de solo lectura y el usuario no puede configurarlo. Además, Maven lo inyecta, por lo que podríamos decir que es algo especial.
En esta sección, vamos a agregar un parámetro donde los usuarios pueden especificar el alcance de las dependencias que queremos contar.
Por lo tanto, creemos un parámetro de alcance en nuestro mojo:
@Parameter(property = "scope") String scope;Solo hemos establecido el atributo de propiedad . Nos permite establecer esta propiedad a través de la línea de comandos o una propiedad pom . Para el resto de los atributos, estamos de acuerdo con los valores predeterminados.
Ahora modificaremos nuestro método de ejecución para usar este parámetro y filtraremos las dependencias al contar:
public void execute() throws MojoExecutionException, MojoFailureException List dependencies = project.getDependencies(); long numDependencies = dependencies.stream() .filter(d -> (scope == null Los tipos de parámetros más avanzados se explican en la documentación oficial.
4. Prueba del complemento
Terminamos con el desarrollo del complemento. ¡Probémoslo para ver si funciona!
En primer lugar, tenemos que instalar el complemento en nuestro repositorio local:
mvn clean installEn las siguientes secciones, primero veremos cómo ejecutar nuestro complemento desde la línea de comandos. Luego, también cubriremos cómo usarlo en un proyecto de Maven.
4.1. Ejecutando nuestro complemento
Podemos ejecutar el objetivo de un complemento en la línea de comando especificando su nombre completo:
mvn groupId:artifactId:version:goalEn nuestro caso, se ve así:
mvn com.baeldung:counter-maven-plugin:0.0.1-SNAPSHOT:dependency-counterSin embargo, si hemos seguido la convención de nomenclatura de complementos que mencionamos al comienzo de este tutorial, Maven resolverá el prefijo de nuestro complemento y podemos acortar el comando:
mvn counter:dependency-counterTenga en cuenta que este comando utiliza la última versión del complemento. Además, tenga en cuenta que tenemos que agregar nuestro groupId al pluginGroups de nuestro settings.xml para que Maven también busque en este grupo:
com.baeldung Si revisamos la salida del comando, podemos ver que el complemento contó el número de dependencias en el pom.xml de nuestro complemento:
[INFO] Scanning for projects... [INFO] [INFO] ----------------------------------- [INFO] Building counter-maven-plugin Maven Mojo 0.0.1-SNAPSHOT [INFO] ----------------------------[ maven-plugin ]---------------------------- [INFO] [INFO] --- counter-maven-plugin:0.0.1-SNAPSHOT:dependency-counter (default-cli) @ counter-maven-plugin --- [INFO] Number of dependencies: 3 [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------ [INFO] Total time: 0.529 s [INFO] Finished at: 2019-11-30T20:43:41+01:00 [INFO] ------------------------------------------------------------------------También podemos establecer el parámetro de alcance a través de las propiedades de la línea de comando:
mvn counter:dependency-counter -Dscope=testObserve que el nombre del alcance es el que definimos en el atributo de propiedad de nuestro parámetro en el mojo.
4.2. Usando nuestro complemento en un proyecto
¡Probemos ahora nuestro complemento usándolo en un proyecto!
Vamos a crear un proyecto Maven muy simple con algunas dependencias que contará nuestro complemento:
4.0.0 com.baeldung example pom 0.0.1-SNAPSHOT org.apache.commons commons-lang3 3.9 junit junit 4.12 test Lo último es agregar nuestro complemento a la compilación. Tenemos que establecer explícitamente que queremos ejecutar el objetivo del contador de dependencias :
com.baeldung counter-maven-plugin 0.0.1-SNAPSHOT dependency-counter test Observe que hemos especificado el parámetro de alcance en el nodo de configuración . Además, no hemos especificado ninguna fase porque nuestro mojo está adjunto a la fase de compilación por defecto.
Ahora, solo necesitamos ejecutar la fase de compilación para ejecutar nuestro complemento:
mvn clean compileY nuestro complemento imprimirá el número de dependencias de prueba :
[INFO] Scanning for projects... [INFO] [INFO] ------------------------------------------------ [INFO] Building example 0.0.1-SNAPSHOT [INFO] --------------------------------[ pom ]--------------------------------- [INFO] [INFO] --- maven-clean-plugin:2.5:clean (default-clean) @ example --- [INFO] [INFO] --- counter-maven-plugin:0.0.1-SNAPSHOT:dependency-counter (default) @ example --- [INFO] Number of dependencies: 1 [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------ [INFO] Total time: 0.627 s [INFO] Finished at: 2019-11-25T18:57:22+01:00 [INFO] ------------------------------------------------------------------------En este tutorial, no cubrimos cómo escribir pruebas unitarias o de integración para nuestro complemento, pero Maven proporciona algunos mecanismos para hacerlo.
5. Agregar documentación
Cuando creamos un complemento de Maven, es importante generar documentación para que sea más fácil para otras personas usarlo .
Cubriremos brevemente cómo generar esta documentación con maven-plugin-plugin .
maven-plugin-plugin ya está incluido en el proyecto, pero lo actualizaremos para usar la última versión.
Además, haremos lo mismo para maven-site-plugin :
org.apache.maven.plugins maven-plugin-plugin 3.6.0 org.apache.maven.plugins maven-site-plugin 3.8.2 Luego, debemos asegurarnos de haber agregado javadoc a nuestro Mojo y también agregar algunos metadatos en el pom.xml del complemento:
Baeldung //www.baeldung.com/ Después de eso, necesitamos agregar una sección de informes en nuestro pom.xml :
org.apache.maven.plugins maven-plugin-plugin report Finally, we'll generate the documentation with the maven site command:
mvn siteInside the target folder, we can find a site directory with all the HTML files generated. The plugin-info.html is the one containing the plugin documentation:
More options to add to our documentation can be found on the Maven plugin documentation guide.
6. Conclusion
In this tutorial, we've shown how to create a Maven plugin. We first implemented a simple plugin, which helped us see a typical Maven plugin project structure. Then, we covered some of the tools that Maven provides to help us develop plugins.
We've kept it simple to make things clearer, but at the same time, we've provided some useful links with the necessary information on how to create a more powerful plugin.
Como siempre, el código fuente completo de los ejemplos está disponible en GitHub.