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 :
| Attribut | Description | Valeurs courantes |
|---|---|---|
groupId | Organisation du plugin | org.apache.maven.plugins(Plugins officiels) |
artifactId | Nom du plugin | maven-compiler-plugin |
version | Version du plugin | 3.8.1 |
Objectifs du plugin
Chaque plugin peut contenir plusieurs objectifs, par exemple :
maven-compiler-plugin:compile: Compiler le code principaltestCompile: 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 vie | Objectif de plugin lié |
|---|---|
compile | maven-compiler-plugin:compile |
test | maven-surefire-plugin:test |
package | maven-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
| Plugin | Objectif | Objectifs courants |
|---|---|---|
maven-compiler-plugin | Compiler le code Java | compile, testCompile |
maven-resources-plugin | Traiter les fichiers de ressources | resources, 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
| Plugin | Objectif | Objectifs courants |
|---|---|---|
maven-surefire-plugin | Exécuter les tests unitaires | test |
maven-failsafe-plugin | Exécuter les tests d'intégration | integration-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
| Plugin | Objectif | Objectifs courants |
|---|---|---|
maven-jar-plugin | Empaqueter les fichiers JAR | jar |
maven-war-plugin | Empaqueter les fichiers WAR | war |
maven-assembly-plugin | Packaging 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
| Plugin | Objectif | Objectifs courants |
|---|---|---|
maven-install-plugin | Installer dans le dépôt local | install |
maven-deploy-plugin | Déployer vers le dépôt distant | deploy |
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 de
AbstractMojoet implémenter laexecute()méthode.
Exemple simple de plugin
Exemple
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 |
| Plugins de reporting | Exécutés lors de la génération du site et configurés dans le pom.xml |
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.
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.