Plugins Maven

Les plugins Maven sont des composants exécutables qui étendent les fonctionnalités de Maven. Chaque plugin contient un ou plusieurs objectifs, utilisés pour exécuter des tâches spécifiques (telles que la compilation, les tests, le packaging, etc.).

La relation entre les plugins et le cycle de vie :

  • Cycle de vie : Définit l'ordre des phases de construction

  • Plugin : Fournit des implémentations concrètes (objectifs) pour accomplir les tâches de ces phases

Maven dispose des trois cycles de vie standard suivants :

  • clean: Gère le nettoyage du projet
  • default (ou build): Gère le déploiement du projet
  • site: Gère la création de la documentation du site du projet

Chaque cycle de vie contient une série de phases. Ces phases sont équivalentes aux interfaces unifiées fournies par Maven, et la mise en œuvre de ces phases est assurée par les plugins Maven.

Lorsque nous saisissons une commande mvn, par exemplemvn clean, clean correspond à la phase clean du cycle de vie Clean. Cependant, l'opération spécifique de clean repose surmaven-clean-pluginpour l'implémenter.

Par conséquent, l'implémentation spécifique de chaque phase du cycle de vie Maven est réalisée par des plugins Maven.

Maven est en fait un framework qui s'appuie sur des plugins pour son exécution. Chaque tâche est en fait accomplie par des plugins. Les plugins Maven sont couramment utilisés pour :

  • Créer des fichiers jar
  • Créer des fichiers war
  • Compiler des fichiers de code
  • Effectuer des tests unitaires sur le code
  • Créer la documentation du projet
  • Créer des rapports de projet

Les plugins fournissent généralement une collection d'objectifs et peuvent être exécutés en utilisant la syntaxe suivante :

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

Par exemple, un projet Java peut utiliser l'objectif compile de maven-compiler-plugin pour compiler, en utilisant la commande suivante :

<code>mvn compiler:compile</code>

Mécanisme central des plugins

Coordonnées du plugin

Comme les dépendances, les plugins sont également identifiés de manière unique par groupId, artifactId et version :

AttributDescriptionValeurs courantes
groupIdOrganisation du pluginorg.apache.maven.plugins(Plugins officiels)
artifactIdNom du pluginmaven-compiler-plugin
versionVersion du plugin3.8.1

Objectifs du plugin

Chaque plugin peut contenir plusieurs objectifs, par exemple :

  • maven-compiler-plugin:

    • compile: Compiler le code principal

    • testCompile: Compiler le code de test

  • maven-surefire-plugin:

    • test: Exécuter les tests unitaires

Méthodes de liaison du plugin

1. Liaison intégrée

Maven a pré-lié les objectifs de plugin aux phases du cycle de vie :

Phase du cycle de vieObjectif de plugin lié
compilemaven-compiler-plugin:compile
testmaven-surefire-plugin:test
packagemaven-jar-plugin:jar(oumaven-war-plugin:war)

2. Liaison personnalisée

Configurer explicitement dans 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 officiels courants

Liés à la compilation

PluginObjectifObjectifs courants
maven-compiler-pluginCompiler le code Javacompile, testCompile
maven-resources-pluginTraiter les fichiers de ressourcesresources, testResources

Exemple de configuration :

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

Liés aux tests

PluginObjectifObjectifs courants
maven-surefire-pluginExécuter les tests unitairestest
maven-failsafe-pluginExécuter les tests d'intégrationintegration-test

Configuration pour ignorer les tests :

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

Lié au packaging

PluginObjectifObjectifs courants
maven-jar-pluginEmpaqueter les fichiers JARjar
maven-war-pluginEmpaqueter les fichiers WARwar
maven-assembly-pluginPackaging personnalisésingle

Configuration JAR exécutable :

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

Lié au déploiement

PluginObjectifObjectifs courants
maven-install-pluginInstaller dans le dépôt localinstall
maven-deploy-pluginDéployer vers le dépôt distantdeploy

Méthodes d’invocation de plugin

Invoquer via le cycle de vie :

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

Invoquer directement un objectif de plugin :

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

Configuration des paramètres de ligne de commande :

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

Configuration personnalisée de plugin

Configuration des paramètres

Viaconfigurationparamètres de balise :

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

Exécution multi-objectifs :

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

Bases du développement de plugins

Concept de Mojo

  • La classe Java correspondant à un objectif de plugin est appelée unMojo(Maven plain Old Java Object)。

  • Doit hériter deAbstractMojoet implémenter laexecute()méthode.

Exemple simple de plugin

Exemple

@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 + "!");
    }
}

Empaquetage et installation des plugins

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

Types de plugins

Maven fournit les deux types de plugins suivants :

Type Description
Plugins de build Exécutés au moment du build et configurés dans le pom.xmlélément.
Plugins de reporting Exécutés lors de la génération du site et configurés dans le pom.xmlélément.

Voici une liste de quelques plugins couramment utilisés :

Plugin Description
clean Nettoie les fichiers cibles après le build. Supprime le répertoire target.
compiler Compile les fichiers source Java.
surefile Exécute les tests unitaires JUnit. Crée des rapports de tests.
jar Construit un fichier JAR à partir du projet actuel.
war Construit un fichier WAR à partir du projet actuel.
javadoc Génère la Javadoc pour le projet.
antrun Exécute un ensemble de tâches Ant à n'importe quelle phase du processus de construction.

Exemple

Nous avons déjà largement utilisé dans nos exemplesmaven-antrun-pluginpour afficher des données dans la console. Veuillez vous référer au chapitreMaven - Profils de construction. Comprenons ce contenu de manière plus approfondie. Créez un fichier pom.xml dans le répertoire 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> <objectifs> <objectif>exécuter</objectif> </objectifs> <configuration> <tâches> <echo>phase clean</echo> </tâches> </configuration> </exécution> </exécutions> </plugin> </plugins> </construire le> </projet>

Ensuite, ouvrez un terminal de commande, accédez au répertoire où se trouve pom.xml, et exécutez la commande mvn suivante.

mvn clean

Maven commencera le traitement et affichera la phase clean du cycle de vie 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] ------------------------------------------------------------------

L'exemple ci-dessus illustre les concepts clés suivants :

  • Les plugins sont définis dans pom.xml à l'aide de l'élément plugins.
  • Chaque plugin peut avoir plusieurs objectifs.
  • Vous pouvez définir une phase, et le plugin utilisera son élément phase pour commencer le traitement. Nous avons utilisé lacleanphase.
  • Vous pouvez configurer les tâches à exécuter en les liant aux objectifs du plugin. Nous avons lié laechotâche à l'objectifrundu plugin maven-antrun-plugin.
  • C'est tout. Maven s'occupera du reste. Il téléchargera les plugins qui ne sont pas disponibles dans le référentiel local et commencera le traitement.
Autres extensions