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

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

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> </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,
  
• avec les fichiers POM des projets parents,
  
• ainsi que le super POM.
  

Le fichier POM final hérite:

• les valeurs des propriétés du projet,
  
• 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.6.2.jar".
"org/apache/maven/model/pom-4.0.0.xml": pom-4.0.0.xml

Un projet Maven est identifié par les trois 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.
  Par exemple le groupId peut être composé du nom de domaine de l'entreprise plus une suite de mots qui identifient un ensemble de projets : 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/"
  
  |+ ${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 : maven-help-plugin
  
  L'identifiant du projet correspond à un répertoire créés dans le dossier : "${HOME}/.m2/repository/[GROUP_PATH]/"
  
  |+ ${HOME} |+ .m2 |+ repository |+ org |+ apache |+ maven |+ plugins |+ maven-help-plugin
  
• version
  Un projet peut avoir plusieurs versions.
  Chaque nouvelle version du projet correspond à un répertoire créés dans le dossier : "${HOME}/.m2/repository/[GROUP_PATH]/[ARTIFACT_ID]/"
  
  |+ ${HOME} |+ .m2 |+ repository |+ org |+ apache |+ maven |+ plugins |+ maven-help-plugin |+ 2.1.1
  

Note :
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", ...

Pour modifier ces attributs, il faut modifier les éléments suivants dans le fichier "pom.xml" :

<groupId>org.apache.maven.plugins</groupId> <artifactId>maven-help-plugin</artifactId> <version>2.1.1</version> <packaging>maven-plugin</packaging>

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>

Pour exécuter un but d'un plugin on utilise le préfixe du plugin concaténé avec le nom du but.
Pour passer des valeurs à des paramètres d'un but on utilise la syntaxe "-Dparam_name=param_value".
Par exemple, pour exécuter le but "describe" du plugin "maven-help-plugin" on utilise la syntaxe suivante :
mvn help:describe -Dplugin=archetype -Ddetail=true

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>

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.

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