CommentCaMarche
Recherche
Posez votre question »

Débuter avec Maven

Mars 2015


Présentation de Maven


Maven est un outil de gestion de projets Java et Java EE, il permet notamment de :
  • créer une arborescence standard du code et de ses ressources
  • télécharger, mettre à jour et configurer les bibliothèques nécessaires au projet
  • compiler le projet, effectuer des tests unitaires sur le code et packager le résultat

Téléchargement et installation de Maven


Avertissement : L'utilisation de Maven requiert un accès internet ainsi que de l'espace disque pour conserver les fichiers téléchargés.

Le logiciel Maven est open source, il est disponible gratuitement sur le site officiel de la fondation Apache http://maven.apache.org/ sous les noms "binary.zip" pour Windows et "binary.tar.gz" pour Unix.

Une fois téléchargée, décompressez le contenu de l'archive dans un répertoire système ("C:\Program Files\Apache" par exemple), vous devez ensuite configurer la variable d'environnement MAVEN_HOME correspondant à ce répertoire et ajouter le sous-répertoire \bin à la variable d'environnement PATH.

Si vous n'avez pas installé de JDK pour éditer du code Java, c'est le moment de le faire en vous rendant sur le site officiel http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html Sur le même principe vous devez également configurer la variable JAVA_HOME correspondant au répertoire d'installation de la JDK, ainsi qu'ajouter le répertoire \bin à la variable d'environnement PATH.

En résumé, vous devriez avoir trois variables d'environnement, avec ces valeurs par exemple :

JAVA_HOME   C:\Program Files\Java\jdk1.7.0_25
MAVEN_HOME C:\Program Files\Apache\maven-3.1.0
PATH %JAVA_HOME%\bin;%MAVEN_HOME%\bin;%PATH%

Pour vérifier que tout est bien installé, vous pouvez ouvrir une invite de commande et taper ceci :

mvn --version
Cela générera normalement un affichage plus ou moins comme ceci, décrivant votre configuration :

Apache Maven 3.1.0 (2013-06-28 04:15:32+0200)
Maven home: C:\Program Files\Apache\maven-3.1.0\bin\..
Java version: 1.7.0_25, vendor: Oracle Corporation
Java home: C:\Program Files\Java\jdk1.7.0_25\jre
Default locale: fr_FR, platform encoding: Cp1252
OS name: "windows 7", version: "6.1", arch: "amd64", family: "windows"

Hello World avec Maven


Pour faire simple nous allons créer un projet "Hello World" avec Maven, et décortiquer son fonctionnement. Créez pour cela un répertoire dédié (l'emplacement n'a aucune importance).

Ouvrez une invite de commandes et déplacer vous jusqu'au dossier que vous venez de créer, nous allons enfin entrer dans le vif du sujet !

Génération de l'archetype


Pour l'instant nous avons un dossier vide, nous allons demander à Maven de créer tout seul (ou presque) un projet de base en tapant la commande suivante :

mvn archetype:generate
Maven devrait alors se connecter au dépôt central http://repo.maven.apache.org/ et commencer à télécharger un grand nombre de fichiers POM (Project Object Model) et JAR (Java ARchiver) qui lui sont utiles. Ceux-ci seront ensuite stockés par défaut dans votre dossier "Mes Documents" dans un répertoire nommé ".m2". En stockant ces fichiers sur le disque, Maven n'aura alors plus besoin de les télécharger lors de la prochaine utilisation et ira directement les consulter dans le dépôt local.
Si vous travaillez au sein d'une entreprise (ou d'une université par exemple), celle-ci est peut-être équipée d'un dépôt d'entreprise qui stocke sur un serveur tous les fichiers téléchargés par Maven au sein du réseau et les redistribue aux utilisateurs qui en ont besoin en local sans avoir à repasser par le dépôt central (sauf lors d'une première demande) ce qui permet d'accélérer l'accès aux fichiers.

Ceci étant dit, vos téléchargements devraient maintenant être terminés et Maven a du vous indiquer qu'il allait générer le projet en mode interactif.

C'est à dire qu'il va vous poser un certain nombre de questions auxquelles il va falloir répondre, le plus souvent parmi une liste de choix dont un par défaut.

Première question : choisir le type de projet. Ici Maven propose plusieurs centaines de types d'archetypes différents, voici un exemple d'affichage des dernières lignes que vous pourriez avoir :

823: remote -> ru.nikitav.android.archetypes:release (-)
824: remote -> ru.nikitav.android.archetypes:release-robolectric (-)
825: remote -> se.vgregion.javg.maven.archetypes:javg-minimal-archetype (-)
826: remote -> sk.seges.sesam:sesam-annotation-archetype (-)
827: remote -> tk.skuro:clojure-maven-archetype (A simple Maven archetype for Clojure)
828: remote -> uk.ac.rdg.resc:edal-ncwms-based-webapp (-)

Choose a number or apply filter (format: [groupId:]artifactId, case sensitive contains): 294:

Les lignes 1 à 828 sont tous les choix possibles de projets. Remarque : la liste des projets peut varier au cours du temps alors vous n'en aurez peut-être pas 828, mais ça n'a aucune importance. Ici nous allons uniquement nous intéresser au choix par défaut proposé (294 dans l'exemple) dont voici la description :

294: remote -> org.apache.maven.archetypes:maven-archetype-quickstart (An archetype which contains a sample Maven project.)

Entrons donc cette valeur par défaut afin de dire à Maven d'utiliser l'archetype "quickstart".

S'en suit une deuxième question concernant la version de l'archetype que nous voulons utiliser. Là encore nous allons prendre la valeur par défaut qui correspond en général à la dernière version stable. Maven peut alors télécharger le projet. Mais il faut le personnaliser.

La question suivante concerne le "groupId" il s'agit du nom de votre groupe, par exemple celui de Maven est "org.apache.maven", ici vous pouvez donc mettre ce que vous voulez à condition de respecter la syntaxe attendu, c'est à dire des lettres minuscules sans accent ni espace séparés par des points. Pour l'exemple je vais mettre "org.ccm.maven"

Vient ensuite l'"artifactId", il s'agit tout simplement du nom du projet, je mettrais ici "helloworld".

La question suivante concerne la version du projet. Maven utilise beaucoup les numéros de versions, il est donc important de comprendre qu'à chaque fois que vous générerez votre projet Maven, son numéro de version est susceptible d'être incrémenté. En précisant qu'il s'agit d'une version "snapshot" on s'assure que le projet sera bien considéré comme étant en cours de développement et donc que sa version ne sera pas incrémentée. Laissons alors cette valeur par défaut "1.0-SNAPSHOT".

Enfin une question concernant le package des sources du projet, par défaut Maven propose de mettre le même nom que pour le groupId : "org.ccm.maven"

Petit récapitulatif et demande de confirmation avec un "Y" et voilà notre premier projet Maven créé !

Remarque : il aurait été possible d'obtenir la même chose sans passer par le mode interactif, dans ce cas il faut préciser les différents paramètres obligatoires, Maven complétant les paramètres manquant avec les valeurs par défaut. Ce qui donne :

mvn archetype:generate -DarchetypeArtifactId=maven-archetype-quickstart -DgroupId=org.ccm.maven -DartifactId=helloworld -DinteractiveMode=false

Arborescence du projet


Voici l'architecture du projet telle que générée avec maven-archetype-quickstart et les valeurs des paramètres passés en mode interactif plus haut :

helloworld
|- pom.xml
|- src
|- main
| |- java
| |- org
| |- ccm
| |- maven
| |- App.java
|- test
|- java
|- org
|- ccm
|- maven
|- AppTest.java

Nous avons donc 12 dossiers et 3 fichiers, dont voici le détail :

helloworld/src/main/java/org/ccm/maven/App.java :

package org.ccm.maven;

/**
* Hello world!
*
*/
public class App
{
public static void main( String[] args )
{
System.out.println( "Hello World!" );
}
}

Rien de compliqué jusque là, Maven nous a simplement rempli le code d'un classique Hello World.

helloworld/src/main/java/org/ccm/maven/App.java :

package org.ccm.maven;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

/**
* Unit test for simple App.
*/
public class AppTest
extends TestCase
{
/**
* Create the test case
*
* @param testName name of the test case
*/
public AppTest( String testName )
{
super( testName );
}

/**
* @return the suite of tests being tested
*/
public static Test suite()
{
return new TestSuite( AppTest.class );
}

/**
* Rigourous Test :-)
*/
public void testApp()
{
assertTrue( true );
}
}

Ici c'est un petit peu plus compliqué si vous ne connaissez pas JUnit, il s'agit d'une classe de test unitaire, cela permet de faire automatiquement quelques vérifications après chaque compilation pour s'assurer que les modifications apportées au code ne perturbent pas ce qui fonctionnait déjà.

Remarque : ici le test est bidon, il vérifie simplement que true vaut true, ce qui est évidemment correct.

Enfin, voici le coeur de Maven, qui contient toute la configuration du projet :

helloworld/pom.xml

<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/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.ccm.maven</groupId>
<artifactId>helloworld</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
<name>helloworld</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

Nous retrouvons notamment les différentes valeurs que nous avons paramétrées, ainsi que les dépendances à JUnit pour permettre de faire les tests. En configurant cette dépendance dans le pom, Maven sait qu'il devra aller télécharger la bibliothèque de JUnit et l'associer au projet afin que celui fonctionne. Vous n'avez donc pas à l'installer vous même !

Nous pouvons voir également la balise de packaging, qui est un jar. Cela signifie qu'après compilation le code sera archivé dans un fichier JAR.

Cependant il manque un petit quelque chose, en effet ce jar n'est pas exécutable ! Nous allons donc rajouter le point d'entrée en copiant ce bloc dans le pom.xml (par exemple entre l'url et les properties)

  <build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<configuration>
<archive>
<manifest>
<addClasspath>true</addClasspath>
<mainClass>org.ccm.maven.App</mainClass>
</manifest>
</archive>
</configuration>
</plugin>
</plugins>
</build>

Compilation et exécution du programme


Maintenant que notre code source est complet et que la configuration du projet est terminée, nous allons pouvoir demander à Maven de construire le projet. Pour cela ouvrez une invite de commande dans le dossier "helloworld" et entrez cette commande :

mvn package
Cela va entraîner différentes actions, la validation du projet (qui va notamment aller télécharger tous les fichiers qui pourraient être manquants), la compilation du projet, l'exécution des tests unitaires et la création des archives jar. Notez que si l'une de ces étapes échoue, alors les suivantes ne seront pas exécutées.

Un nouveau dossier est apparu dans votre répertoire helloworld, il s'agit de "target", celui-ci contient les classes compilées (dans "classes" pour le programme et "test-classes" pour les tests unitaires), les rapports de tests ("surefire-reports"), ainsi que l'archive "helloworld-1.0-SNAPSHOT.jar" et des propriétés de compilation (dans "maven-archiver").

Vous pouvez donc maintenant lancer le programme avec la commande :

java -jar target/helloworld-1.0-SNAPSHOT.jar
Le résultat sera donc comme prévu : Hello World!

Pour aller plus loin

  • La description du projet via le fichier pom.xml permet notamment de s'affranchir de l'installation des dépendances. Si vous voulez basculer votre projet d'une machine à une autre, il n'y a qu'à copier les sources du projet. La régénération du projet se fera alors à l'identique sans problème de configuration.
  • Une fois la compilation et le packaging terminé, Maven peut déployer l'application directement sur le serveur et faire des tests d'intégrité afin de vérifier qu'il cohabite bien avec les autres applications de son environnement.
  • Maven est supporté par Eclipse et Netbeans, vous pourrez donc à terme vous passer de l'invite de commandes et retrouver les fonctionnalités de Maven directement dans votre IDE préféré.
  • Ant est un projet similaire à Maven. Ils peuvent parfois se retrouver associés.
Pour une lecture illimitée hors ligne, vous avez la possibilité de télécharger gratuitement cet article au format PDF :
Debuter-avec-maven.pdf

A voir également

Réalisé sous la direction de , fondateur de CommentCaMarche.net.

Maven - Getting started
Par jak58 le 22 août 2013
Iniciarse con Maven
Par Carlos-vialfa le 24 août 2013
A ferramenta Maven: primeira utilização
Par ninha25 le 22 août 2013
Publié par KX
Ce document intitulé «  Débuter avec Maven  » issu de CommentCaMarche (www.commentcamarche.net) est mis à disposition sous les termes de la licence Creative Commons. Vous pouvez copier, modifier des copies de cette page, dans les conditions fixées par la licence, tant que cette note apparaît clairement.