Maven : Faire un plugin

La constitution d’un plugin maven est souvent une étape indispensable pour régler certaines problématiques de nos projets.

En réaliser un n’est pas très compliqué, cela consiste essentiellement en un packaging maven un peu particulier et en la définition d’un point d’entrée spécifique, le MOJO.

Le packaging doit être de type maven-plugin, il suffit donc de créer un projet maven classique intégrant ce packaging [1]. Attention par contre car le nommage de votre plugin conditionnera la commande qu’il faudra employer pour l’appeler.

Ainsi, imaginons un plugin maven permettant d’extraire les données du projet (issu du pom, on va pas faire trop compliqué….).

Ainsi on va définir notre projet maven comme suit:

<groupid>org.tc.maven.plugin</groupid>
<artifactid>tc-project-info-extractor-maven-plugin</artifactid>
<name>${project.artifactId}-${project.version}</name>
<version>${build}${snapshot}</version>
<packaging>maven-plugin</packaging>

On va utilise le plugin maven maven-plugin-plugin [2] :

<plugin>
<groupid>org.apache.maven.plugins</groupid>
<artifactid>maven-plugin-plugin</artifactid>
<version>3.5.1</version>
</plugin>

On va ajouter des dépendances maven qui nous permettront de construire notre Mojo:

<dependencies>
 <dependency>
  <groupid>org.apache.maven.plugin-tools</groupid>
  <artifactid>maven-plugin-annotations</artifactid>
  <version>3.3</version>
  <scope>provided</scope>
 </dependency>
 <dependency>
  <groupid>org.apache.maven</groupid>
  <artifactid>maven-plugin-api</artifactid>
  <version>3.2.3</version>
 </dependency>
 <dependency>
  <groupid>org.apache.maven</groupid>
  <artifactid>maven-project</artifactid>
  <version>2.2.1</version>
 </dependency>
</dependencies>

Et c’est tout pour avoir une build par défaut sachant que pour appeler notre plugin pendant un build il faudra appliquer soit le nom complet du plugin :

$ mvn org.tc.maven.plugin:tc-project-info-extractor-maven-plugin:extract

soit son nom court:

$ mvn tc-project-info-extractor:extract

Le nom court étant la simple réduction du nom de l’artifactId sans son extends maven-plugin.

Alors dans cette commande on identifie le mot clef extract. Ce mot clef est le goal de notre plugin (bien sur on peut en définir plusieurs). Ce goal, nous allons le voir est directement relié à notre Mojo, maven se chargeant lorsque l’on appelle ce goal d'exécuter le Mojo associé.

Voyons donc comment construire ce Mojo. Un Mojo [6] est un simple Pojo avec un M pour Maven. Ce Mojo va hériter de la classe AbstractMojo nous incitant à définir la classe exécute qui servira de point d’entrée pour l'exécution du plugin pour le goal associé. Pour définir justement le goal associé, on va s’appuyer l’annotation @Mojo et utiliser @Component pour injecter le projet maven dans notre mojo (en profitant des fonctionnalités d’injection de dépendance de plexus, nous y reviendrons).

A noter qu’il existe les annotations @Execute permettant de forker l'exécution du build maven et @Parameter qui permet de rendre d’injecter des données au plugin au moment de son appel (soit via -DmonParam soit directement dans le pom sous la forme de valeur de configuration) mais on entrera pas dans les détails de ces dernières.

@Mojo(name = "extract", defaultPhase = LifecyclePhase.CLEAN)
public class ProjectExtractorMojo extends AbstractMojo {

    @Component
    MavenProject project;

    @Override
    public void execute() throws MojoExecutionException, MojoFailureException {
        getLog().info("ProjectExtractorMojo execution begin");
        getLog().info(project.getName());
        try {
            final BufferedWriter bos = new BufferedWriter(new FileWriter("target/resultFile.csv", true));
            bos.newLine();
            bos.write(project.getPackaging());
            ...
            bos.write(project.getName());
            bos.flush();
            bos.close();
        } catch (final Exception e) {
            e.printStackTrace();
        }
        ...
        getLog().info("ProjectExtractorMojo execution finish");
    }
}

Voila, à l'exécution de la commande maven, le mojo sera exécuté générant un fichier csv dans lequel il déposera pour chaque projet les caractéristiques de celui ci. Ca ne fait pas grand chose mais ca mange pas de pain. A bientôt et pour ceux qui voudront d’autres références, elles sont ici:

Références

[1] http://maven-guide-fr.erwan-alliaume.com/maven-guide-fr/site/reference/writing-plugins-sect-plugin-prefix.html
[2] https://maven.apache.org/plugin-tools/maven-plugin-plugin/examples/using-annotations.html#POM_configuration
[3] https://dzone.com/articles/a-simple-maven-3-plugin
[4] https://www.codeproject.com/Articles/1013928/Maven-Plugin-Development
[5] http://maven.apache.org/guides/plugin/guide-java-plugin-development.html
[6] http://maven.apache.org/plugin-developers/
[7] https://maven.apache.org/plugin-tools/maven-plugin-plugin/descriptor-mojo.html#skipErrorNoDescriptorsFound