Voir la page suivante pour une description détaillée de Maven : http://maven.apache.org/what-is-maven.html

Voir la page suivante pour installer et configurer Maven : Installer et configurer Maven

Maven est un outil de gestion de projet, basé sur le concept de "Project Object Model" (POM).
Maven permet de construire un projet, générer des rapports, générer des documentations, ...

Maven est basé sur les concepts suivants :

• Structure de repértoire standardisé (source,test,resources, ...)
• Gestion déclarative des dependences (pom.xml)
• Plugins
• Archetypes (modèles)

Intégration avec des services externes :

• Maven SCM Plugin (source code management)
• Maven release Plugin
• Maven Wagon Plugin (http, ftp, ...)

Pour créer un projet Maven, il est possible d'utiliser la commande "mvn archetype:generate".

La commande "mvn archetype:generate" utilise le plugin "archetype" et le but (goal) "generate".

$ mvn archetype:generate \ -DarchetypeGroupId=org.apache.maven.archetypes \ -DarchetypeArtifactId=maven-archetype-quickstart \ -DarchetypeVersion=1.4 \ -DgroupId=mtitek.maven.samples \ -DartifactId=mtitek-maven-samples \ -Dpackage=mtitek.maven.samples \ -Dversion=1.0.0-SNAPSHOT \ -DinteractiveMode=false
Notes :
Sur Linux, le caractère "\" permet d'écrire une commande sur plusieurs lignes.
Sur Windows, il faut utiliser le caractère "^".

Si vous exécutez la commande "mvn archetype:generate", une liste des prototypes (archetypes) disponibles pour la création du projet sera affichée:

$ mvn archetype:generate [INFO] Scanning for projects... [INFO] [INFO] ------------------< org.apache.maven:standalone-pom >------------------- [INFO] Building Maven Stub Project (No POM) 1 [INFO] --------------------------------[ pom ]--------------------------------- [INFO] [INFO] >>> maven-archetype-plugin:3.1.2:generate (default-cli) > generate-sources @ standalone-pom >>> [INFO] [INFO] <<< maven-archetype-plugin:3.1.2:generate (default-cli) < generate-sources @ standalone-pom <<< [INFO] [INFO] [INFO] --- maven-archetype-plugin:3.1.2:generate (default-cli) @ standalone-pom --- [INFO] Generating project in Interactive mode [INFO] No archetype defined. Using maven-archetype-quickstart (org.apache.maven.archetypes:maven-archetype-quickstart:1.0) Choose archetype: 1: remote -> am.ik.archetype:elm-spring-boot-blank-archetype (Blank multi project for Spring Boot + Elm) 2: remote -> am.ik.archetype:maven-reactjs-blank-archetype (Blank Project for React.js) ... 2494: remote -> xyz.luan.generator:xyz-generator (-) 2495: remote -> za.co.absa.hyperdrive:component-archetype (-) Choose a number or apply filter (format: [groupId:]artifactId, case sensitive contains): 1420:

Chaque projet Maven vient avec un fichier de configuration "pom.xml" qui contient la liste des propriétés du projet : son identifiant, l'identifiant de son groupe, sa version, le type du package, ses dépendances, ses options de construction, …

Ce fichier se trouve sur la racine du projet. Voici un exemple du fichier "pom.xml" du projet "mtitek-maven-samples" :

<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>mtitek.maven.samples</groupId> <artifactId>mtitek-maven-samples</artifactId> <version>1.0-SNAPSHOT</version> <!-- <packaging>jar</packaging> --> <!-- si packaging n'est pas spécifié, sa valeur par défaut est jar --> </project>
Les commandes Maven sont toujours exécutées sur la version effective du fichier "pom.xml".

Le fichier POM final est le résultat de la fusion:

• du fichier POM du projet,
  
• des fichiers POM des projets parents,
  
• ainsi que le super POM.
  

En plus des valeurs des propriétés du projet, le fichier POM final hérite:

• les propriétés de ses projets parents,
  
• les propriétés du super POM,
  
• les propriétés des fichiers de configuration de Maven.
  

Pour afficher la version effective du fichier "pom.xml" vous pouvez exécuter la commande mvn help:effective-pom à partir du dossier du projet.

Dans Eclipse (m2e), il suffit d'ouvrir le fichier "pom.xml" du projet et cliquer sur l'onglet "Effective POM".

Note :
Le super POM de Maven se trouve dans le fichier:
"${MAVEN_HOME}/lib/maven-model-builder-3.8.6.jar:/org/apache/maven/model/pom-4.0.0.xml".
Voir le fichier: pom-4.0.0.xml

Un projet Maven est identifié par les quatre attributs suivants :

• groupId
  Un projet Maven appartient à un groupe identifié par un identifiant unique (groupId).
  Un groupe peut contenir plusieurs projets.
  L'identifiant du groupe de projets doit typiquement être une suite de mots séparés par un point.
  Le groupId peut être composé du nom de domaine de l'entreprise plus une suite de mots qui identifient un ensemble de projets.
  
  Par exemple : org.apache.maven.plugins
  
  Les mots composants l'identifiant du groupe de projets correspondent à des répertoires créés dans le dossier : "${HOME}/.m2/repository/"
  
  Par exemple : ${HOME}/.m2/repository/org/apache/maven/plugins
  
  |+ ${HOME} |+ .m2 |+ repository |+ org |+ apache |+ maven |+ plugins
  
• artifactId
  Un projet est identifié par un identifiant (artifactId) unique à l'intérieur d'un groupe de projets.
  Typiquement l'identifiant du projet est composés d'une suite de mots séparés par le caractère "-".
  Ces mots peuvent correspondre à une partie des mots composants l'identifiant du groupe de projets, plus des mots spécifiques au projet.
  
  Par exemple : maven-help-plugin
  
  L'identifiant du projet correspond à un répertoire créé dans le dossier du groupe: "${HOME}/.m2/repository/[GROUP_PATH]/"
  
  Par exemple : ${HOME}/.m2/repository/org/apache/maven/plugins/maven-help-plugin
  
  |+ ${HOME} |+ .m2 |+ repository |+ org |+ apache |+ maven |+ plugins |+ maven-help-plugin
  
• version
  Un projet peut avoir plusieurs versions.
  
  La version d'un projet est typiquement définit comme suit: MajorVersion.MinorVersion.IncrementalVersion-qualifier
  
  Les valeurs de MajorVersion, MinorVersion, et IncrementalVersion sont numériques.
  La valeur de qualifier est une chaîne de caractères.
  
  Exemples : 1, 1.0, 1.0.1, 1.0.1-SNAPSHOT, 1.0.1-23, 1.0.1-beta, 1.0.1-beta-23
  
  La version qui sera considérée par Maven comme la plus récente est celle qui a La plus grande valeur pour MajorVersion, sinon la plus grande valeur pour MinorVersion, sinon la plus grande valeur pour IncrementalVersion, sinon Maven compare les valeurs de qualifier mais comme il s'agit de chaînes de caractères, il faut s'assurer que le format est consistant pour toutes les versions sinon une version plus ancienne peut être choisi par Maven.
  
  Il faut noter que les versions avec qualifier sont considérées plus anciennes que la même version qui n'a pas de qualifier.
  
  Il faut aussi noter que les versions qui ne respectent pas le standard Maven seront comparées comme des chaînes de caractères. Cela peut entraîner, dans certains cas, qu'une version plus ancienne est choisi, par Maven, au lieu d'une version plus rècente. Cela peut également avoir un impact sur le comportement de certains plugins maven (release, version, ...).
  
  Ajouter SNAPSHOT à une version permet à Maven d'assigner une date aux composantes des projets quand ils sont deployés. Ainsi, quand on référence une composante comme dépendance, Maven va chercher la version avec la date plus rècente.
  
  Chaque nouvelle version du projet correspond à un répertoire créé dans le dossier : "${HOME}/.m2/repository/[GROUP_PATH]/[ARTIFACT_ID]/"
  Par exemple : ${HOME}/.m2/repository/org/apache/maven/plugins/maven-help-plugin/2.1.1
  
  |+ ${HOME} |+ .m2 |+ repository |+ org |+ apache |+ maven |+ plugins |+ maven-help-plugin |+ 2.1.1
  
• packaging
  L'attribut packaging définit le type du projet et permet de spécifier comment le projet va être construit.
  La valeur de cet attribut peut être : "jar" (par défaut), "war", "ejb", "ear", "pom", "maven-plugin", ...
  

Maven permet d'utiliser, dans le fichier POM, des variables prédéfinies ou personnalisées.
Si une référence d'une variable (élément du modèle POM ou propriété) est définie dans un fichier POM enfant, sa valeur sera utilisée à la place de sa valeur définie dans un projet parent.

Tout élément du modèle POM qui a une valeur simple peut être référencé en tant que variable.
Par exemple, pour utiliser l'élément <project><version> comme une variable, vous devez la référencée comme suit : ${project.version}

Pour référencer les propriétés définies dans le fichier settings.xml, il faut utiliser le préfixe "settings." (exemple: ${settings.localRepository}).

Pour référencer les valeurs des variables d'environnement, il faut utiliser le préfixe "env.". (exemple: ${env.HOME}).

Il est possible de référencer directement les propriétés systèmes (exemple: ${user.home}).

Il est possible de référencer directement une propriété définie dans le fichier pom.xml (<properties>) : ${property1}

Maven expose trois variables prédéfinies :

• project.basedir : Le chemin du dossier du projet (Par exemple : /home/mtitek/dev/mtitek-maven-samples).
  
  
• project.baseUri : Le chemin du dossier du projet, représenté sous la forme d'un URI (Par exemple : file:/home/mtitek/dev/mtitek-maven-samples/).
  
  
• maven.build.timestamp : La date (UTC) du début de la construction du project.
  
  

Le format de la date de construction du project peut être personnalisé en déclarant la propriété maven.build.timestamp.format:
<project> <properties> <maven.build.timestamp.format>yyyy-MM-dd'T'HH:mm:ss'Z'</maven.build.timestamp.format> <!-- valeur par défaut --> </properties> </project>
Le format de la date doit respecter la syntaxe définie pour SimpleDateFormat.

Voici la configuration par défaut des projets dans Maven :

• Le code source doit être placé dans le dossier : "${project.basedir}/src/main/java/".
  
  
• Le code source des tests unitaires doit être placé dans le dossier : "${project.basedir}/src/test/java/".
  
  
• Les fichiers de ressources doivent être placés dans le dossier : "${project.basedir}/src/main/resources/".
  
  
• Les fichiers de ressources des tests unitaires doivent être placés dans le dossier : "${project.basedir}/src/test/resources/".
  
  
• Maven génère le bytecode du code du projet dans le dossier : "${project.basedir}/target/classes/".
  
  
• Maven génère le bytecode du code de testes dans le dossier : "${project.basedir}/target/test-classes/".
  
  
• Maven génère le fichier qui package le projet (.jar, .war, .ear) dans le dossier : "${project.basedir}/target/".
  
  

Pour vérifier cette configuration, il faut afficher la version effective du fichier "pom.xml".

Voici une vue de la version effective du fichier "pom.xml" du projet "mtitek-maven-samples" :

<build> <sourceDirectory>/home/mtitek/dev/mtitek-maven-samples/src/main/java</sourceDirectory> <testSourceDirectory>/home/mtitek/dev/mtitek-maven-samples/src/test/java</testSourceDirectory> <outputDirectory>/home/mtitek/dev/mtitek-maven-samples/target/classes</outputDirectory> <testOutputDirectory>/home/mtitek/dev/mtitek-maven-samples/target/test-classes</testOutputDirectory> <resources> <resource> <directory>/home/mtitek/dev/mtitek-maven-samples/src/main/resources</directory> </resource> </resources> <testResources> <testResource> <directory>/home/mtitek/dev/mtitek-maven-samples/src/test/resources</directory> </testResource> </testResources> <directory>/home/mtitek/dev/mtitek-maven-samples/target</directory> <!-- ... -->

Maven offre des services (compilation, build, rapport, ...) en utilisant des plugins.
Un plugin est un programme qui implémente des fonctionnalités qui sont groupées en tâches (ou unités de travail).
Dans Maven ces tâches sont appelées des buts (goals).
Un plugin expose ses buts en utilisant le fichier "plugin.xml" se trouvant dans le répertoire "META-INF\maven" du fichier jar du plugin.

Par exemple le fichier "plugin.xml" du plugin "maven-help-plugin-2.1.1" a le format suivant :

<?xml version="1.0" encoding="UTF-8"?> <plugin> <name>Maven Help Plugin</name> <description>...</description> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-help-plugin</artifactId> <version>2.1.1</version> <goalPrefix>help</goalPrefix> <!-- ... --> <mojos> <mojo> <goal>describe</goal> <!-- ... --> <parameters> <parameter> <name>artifactId</name> <type>java.lang.String</type> <required>false</required> <!-- ... --> </parameter> <!-- ... --> </parameters> <configuration> <artifactId implementation="java.lang.String">${artifactId}</artifactId> <!-- ... --> </configuration> <!-- ... --> </mojo> <!-- ... --> </mojos> <dependencies> <!-- ... --> </dependencies> </plugin>

Un plugin spécifie un préfixe (ou alias) en utilisant l'élément "goalPrefix".
Par exemple, le plugin "maven-help-plugin" utilise le préfixe suivant : <goalPrefix>help</goalPrefix>

Maven sauvegarde la liste des plugins ainsi que leurs préfixes dans le fichier "maven-metadata-central.xml"
Il y a deux copies de ce fichier :

• L'une se trouve dans le dossier "${HOME}/.m2/repository/org/apache/maven/plugins/" qui contient la liste des plugins "core".
  
  
• L'autre se trouve dans le dossier "${HOME}/.m2/repository/org/codehaus/mojo/" qui contient la liste des plugins "non-core".
  
  

Ce fichier a le format suivant :
<?xml version="1.0" encoding="UTF-8"?> <metadata> <plugins> <plugin> <name>Maven Help Plugin</name> <artifactId>maven-help-plugin</artifactId> <prefix>help</prefix> </plugin> <!-- ... --> </plugins> </metadata>
Pour exécuter un but d'un plugin on utilise le préfixe du plugin concaténé avec le nom du but.
Par exemple, pour exécuter le but "help" du plugin "maven-help-plugin" (dont le préfixe est help) on utilise la syntaxe suivante :
$ mvn help:help
Il est aussi possible d'utiliser les coordonnées du plugin ("groupId":"artifactId":"version") pour exécuter un but du plugin:
$ mvn org.apache.maven.plugins:maven-help-plugin:help $ mvn org.apache.maven.plugins:maven-help-plugin:3.3.0:help
Si un projet définit plusieurs exécutions (avec des configuration différentes) pour un but dans le fichier pom, il est possible de spécifier une exécution en ajoutant son identifiant (id) après le nom du but, séparé par le caractère '@':
$ mvn plugin-prefix:plugin-goal@goal-execution-id
Pour passer des valeurs à des paramètres d'un but on utilise la syntaxe "-Dparam_name=param_value" :
$ mvn help:help -Ddetail=true $ mvn org.apache.maven.plugins:maven-help-plugin:3.3.0:help -Ddetail=true
Tous les paramètres (en mode écriture) du plugin peuvent être initialisés dans le fichier pom du projet dans la section "<configuration>" du plugin :
... <configuration> <detail>true</detail> </configuration> ...
Les paramètres qui peuvent être initialisés dans la ligne de commande ou dans le fichier pom du projet dans la section "<properties> sont ceux qui définissent un attribut "property" (User property).

Par exemple le paramètre "detail" peut être initialisé dans la ligne de commande :
$ mvn help:help -Ddetail=true ... Available parameters: detail (Default: false) If true, display all settable properties for each goal. User property: detail ...
Il peut être aussi initialisé dans le fichier pom du projet dans la section "<properties> :
... <properties> <detail>true</detail> </properties> ...

Dans certains cas on aura besoin de grouper l'exécution de plusieurs buts en une seule ligne de commande.
Par exemple, pour exécuter, en une seule ligne de commande, le but "compile" du plugin "compiler" et le but "jar" du plugin "jar" , on utilisera la syntaxe : mvn compiler:compile jar:jar

Voici la sortie d'exécution de cette commande sur le projet "mtitek-maven-samples" :

[INFO] ------------------------------------------------------------------------ [INFO] Building mtitek-maven-samples 1.0-SNAPSHOT [INFO] ------------------------------------------------------------------------ [INFO] [INFO] --- maven-compiler-plugin:2.3.2:compile (default-cli) @ mtitek-maven-samples --- [INFO] [INFO] --- maven-jar-plugin:2.3.2:jar (default-cli) @ mtitek-maven-samples --- [INFO] [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------
On peut constater que la construction du projet a exécutée :

• en premier le but "compile" du plugin "maven-compiler-plugin" (version 2.3.2),
  
  
• et en deuxième le but "jar" du plugin "maven-jar-plugin" (version 2.3.2).
  
  

L'ordre d'exécution des buts dépend de leurs positions dans la ligne de commande.
L'ordre est important pour une exécution correcte des buts, car un but peut dépendre du résultat d'exécution d'un autre but.
Par exemple, on ne peut pas packagé un projet Java, s'il n'a pas été compilé en premier.

L'exécution de plusieurs buts en une seule ligne de commande est utile, mais peut être peu pratique, par exemple, dans des cas où on devrait manipuler des lignes de commandes différentes pour chaque projet, en plus de gérer des paramètres spécifiques à chaque but.

Maven, offre la possibilité d'utiliser des alias qui correspondent à des cycles de vies de construction d'un projet Maven.
Chaque cycle de vie est composé de plusieurs phases qui sont composées à leurs tours de plusieurs buts.

Voir la page suivante pour plus de détails sur les phases de chaque cycle de vie : http://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html

Maven offre trois cycles prédéfinis :

• clean : ce cycle de vie gère le nettoyage d'un projet.
  
  
• default : ce cycle de vie gère le déploiement d'un projet.
  
  
• site : ce cycle de vie gère la création de la documentation (site) d'un projet.
  
  

Les phases du cycle de vie "clean" sont :

• pre-clean
• clean
• post-clean

Les phases du cycle de vie "default" sont :

• validate
• initialize
• generate-sources
• process-sources
• generate-resources
• process-resources
• compile
• process-classes
• generate-test-sources
• process-test-sources
• generate-test-resources
• process-test-resources
• test-compile
• process-test-classes
• test
• prepare-package
• package
• pre-integration-test
• integration-test
• post-integration-test
• verify
• install
• deploy

Les phases du cycle de vie "site" sont :

• pre-site
• site
• post-site
• site-deploy

Les phases de chaque cycle de vie sont définies dans un ordre prédéfini : l'exécution des phases se fait selon cet ordre.
En plus, lorsqu'une phase bien particulière est spécifiée dans une ligne de commande, alors avant que celle-ci soit exécutée, Maven va s'assurer que toutes les autres phases, qui ont un ordre inferieure à cette phase, soient exécutées en premier.

Pour exécuter la phase "install" ainsi que les phases qui la précède, il suffit d'exécuter la commande : mvn install
Voici la sortie d'exécution de cette commande sur le projet "mtitek-maven-samples" :

[INFO] ------------------------------------------------------------------------ [INFO] Building mtitek-maven-samples 1.0-SNAPSHOT [INFO] ------------------------------------------------------------------------ [INFO] [INFO] --- maven-resources-plugin:2.5:resources (default-resources) @ mtitek-maven-samples --- [INFO] [INFO] --- maven-compiler-plugin:2.3.2:compile (default-compile) @ mtitek-maven-samples --- [INFO] [INFO] --- maven-resources-plugin:2.5:testResources (default-testResources) @ mtitek-maven-samples --- [INFO] [INFO] --- maven-compiler-plugin:2.3.2:testCompile (default-testCompile) @ mtitek-maven-samples --- [INFO] [INFO] --- maven-surefire-plugin:2.10:test (default-test) @ mtitek-maven-samples --- [INFO] [INFO] --- maven-jar-plugin:2.3.2:jar (default-jar) @ mtitek-maven-samples --- [INFO] [INFO] --- maven-install-plugin:2.3.1:install (default-install) @ mtitek-maven-samples --- [INFO] [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------

Certaines phases ont par défaut des buts associés à elles.

• Les phases du cycle de vie "clean" :
  
  phase but ---------------------- ------------------------------------- clean clean:clean
  
• Les phases du cycle de vie "site" :
  
  phase but ---------------------- ------------------------------------- site site:site site-deploy site:deploy

Un point qui influence l'exécution des phases du cycle de vie "default" est le type de packaging (jar, war, …) : chaque type de package peut nécessiter l'exécution de la totalité ou une partie des phases du cycle de vie.
Le type de package choisi va assigner les buts pour chaque phase.

• "jar", "war", "ejb", "rar": Ce type de packaging nécessite l'exécution des phases et buts suivants :
  
  phase but ---------------------- ------------------------------------- process-resources resources:resources compile compiler:compile process-test-resources resources:testResources test-compile compiler:testCompile test surefire:test package jar:jar / war:war / ejb:ejb / rar:rar install install:install deploy deploy:deploy
  
• "ear": Ce type de packaging nécessite l'exécution des phases et buts suivants :
  
  phase but ---------------------- ------------------------------------- generate-resources ear:generate-application-xml process-resources resources:resources package ear:ear install install:install deploy deploy:deploy
  
• "pom": Ce type de packaging nécessite l'exécution des phases et buts suivants :
  
  phase but ---------------------- ------------------------------------- package site:attach-descriptor install install:install deploy deploy:deploy
  
• "maven-plugin": Ce type de packaging nécessite l'exécution des phases et buts suivants :
  
  phase but ---------------------- ------------------------------------- generate-resources plugin:descriptor process-resources resources:resources compile compiler:compile process-test-resources resources:testResources test-compile compiler:testCompile test surefire:test package jar:jar + plugin:addPluginArtifactMetadata install install:install deploy deploy:deploy

Par défaut Maven va associer un ou plusieurs buts des plugins Maven à une phase.
Vous pouvez voir la configuration par défaut associée à votre projet en consultant la version effective du fichier "pom.xml".
Vous pouvez aussi vérifier les détails des buts exécutés en ajoutant l’option "-X" à la commande "mvn".

La configuration par défaut peut être modifiée dans le fichier "pom.xml".
Vous pouvez aussi ajouter de nouveaux buts de d’autres plugins et les associer à une phase spécifique du package (jar, war, ejb, ear, ...) choisi pour votre projet.

Par exemple, pour un projet dont le package est "jar", Maven va associer le but "jar" du plugin "maven-jar-plugin" à la phase "package" (id: "default-jar").

Dans l’exemple suivant, on va modifier l'exécution par défaut du plugin "maven-jar-plugin" (id: "default-jar") pour ajouter une configuration au but "jar" pour renommer le fichier ".jar" généré à "${project.artifactId}-default-${project.version}.jar".
Aussi on va associer à la phase "package" une exécution pour le but "run" du plugin "maven-antrun-plugin" (id: "echo-package-name"): affichage des coordonnées du projet "groupId":"artifactId":"packaging":"version".

<build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-jar-plugin</artifactId> <version>3.0.2</version> <executions> <execution> <id>default-jar</id> <configuration> <finalName>${project.artifactId}-default-${project.version}</finalName> </configuration> </execution> </executions> </plugin> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-antrun-plugin</artifactId> <version>1.8</version> <executions> <execution> <id>echo-package-name</id> <phase>package</phase> <goals> <goal>run</goal> </goals> <configuration> <target> <echo>project coordinates: ${project.groupId}:${project.artifactId}:${project.packaging}:${project.version} </echo> </target> </configuration> </execution> </executions> </plugin> </plugins> </build>