Gestion de l’automatisation avec Maven

Introduction

Maven est un outil qui permet de gérer et d’automatiser certaines tâches lors du développement de projets logiciel, comme :

  • Compiler les fichiers sources
  • Récupérer les dépendances (bibliothèques externes) de l’application (ce qui devient rapidement nécessaire quand on développe avec plusieurs bibliothèques dépendantes d’autres nombreuses bibliothèques)
  • Générer le fichier JAR de l’application finale
  • Générer la documentation (Javadoc)
  • Produire un site web pour le projet
  • Déployer l’application sur un serveur

Ce ne sont là que les fonctionnalités de base de Maven. Comme vous le verrez, Maven peut aussi, grâce à des plugins:

  • Produire des rapports de respect des règles syntaxiques du code source
  • Détecter les sections de codes propices aux bugs
  • Produire une version PDF de la documentation et du site web (pratique pour produire le rapport final de votre projet)

Maven ressemble à l’outil Ant, il est aussi basé sur des fichiers de configuration au format XML.
Maven utilise un paradigme connu sous le nom de Project Object Model (POM) afin d’écrire un projet logiciel, ses dépendances avec des modules externes et l’ordre à suivre pour sa production. Il est livré avec un grand nombre de tâches pré-définies, comme la compilation de code Java ou encore sa modularisation.

Maven est un outil très riche qui gagne beaucoup de terrain. C’est aussi un outil jeune, mais dont l’évolution est remarquable.
Un élément clé et relativement spécifique de Maven est son aptitude à fonctionner en réseau. Une des motivations historiques de cet outil est de fournir un moyen de synchroniser des projets indépendants : publication standardisée d’information, distribution automatique de modules jar.

Ainsi en version de base, Maven peut dynamiquement télécharger du matériel sur des entrepôts logiciels connus. Il propose ainsi la synchronisation transparente de modules nécessaires.

Maven se charge de la construction de l’infrastructure d’un projet et facilite le travail des équipes de développement qui peuvent se concentrer entièrement sur les problématiques du projet.

Site Officiel

Vous trouverez le site officiel de Maven à l’adresse suivante : http://maven.apache.org/

Wikipédia

Je vous invite à consulter les articles français et anglais de la célèbre encyclopédie Wikipédia à propos de Maven.

Tutoriel

Nous allons voir dans ce tutoriel de manière très simple comment débuter avec Maven. Dans un premier temps nous allons créer un projet Maven en ligne de commande, pour bien comprendre la démarche effectuée, puis on installera l’un des plug-ins Eclipse m2eclipse pour continuer le tutoriel et montrer comment utiliser Maven plus en détail.

Téléchargement/installation Maven

Voici la démarche à suivre pour télécharger/installer Maven 2.

Sous Ubuntu

Nous allons utiliser le gestionnaire de paquet qui va nous aider à installer Maven sans le moindre effort. Pour cela :

  1. Ouvrir une console
  2. Installer le JDK Java et Maven2 en tapant la commande :
  3. sudo apt-get install sun-java6-jdk maven2
  4. Saisir le mot de passe utilisateur
  5. Le gestionnaire de paquet va ensuite demander confirmation pour installer les paquets Maven2, il suffit d’appuyer sur la touche de la lettre “O” du clavier puis “entrer”. Maven2 va se télécharger et s’installer sans que l’on ait à se soucier de quoi que ce soit.
  6. Vérifier que Maven est bien installé en tapant dans la console la commande :
  7. mvn –version
  8. S’il indique qu’il ne trouve pas la variable JAVA_HOME, il suffit d’éditer le fichier environment avec la commande :
  9. sudo gedit ~/.bashrc
  10. On ajoute à la fin du fichier les lignes :
  11. export JAVA_HOME= »/usr/lib/jvm/java-6-sun/ »
    export JDK_HOME= »${JAVA_HOME} »
    export PATH= »${JAVA_HOME}/bin:${PATH} »
  12. On sauvegarde alors le fichier. Mais il faut relancer la session pour que les modifications soient effectives.
  13. Si vous voulez éviter de relancer la session vous pouvez taper directement les commandes précédentes dans la console (attention, il faut modifier le fichier .bashrc si l’ont veut conserver les modifications lors de la prochaine ouverture de session).

Sous Windows

  1. Il faut tout d’abord télécharger l’archive de Maven
  2. On décompresse cette archive dans le répertoire C:\Program Files\Apache Software Foundation. Le sous répertoire apache-maven-2.0.9 sera créé à partir de l’archive. Si vous n’avez pas de logiciel de décompression d’installé, vous pouvez télécharger et installer un utilitaire comme 7zip.
  3. On ajoute la variable d’environnement M2_HOME en ouvrant les propriétés du système (à l’aide du raccourci clavier touche Windows + Pause), dans la fenêtre ouverte on clique sur l’onglet Avancé, puis sur le bouton Variables d’Environnement, et on ajoute la variable M2_HOME dans les variables utilisateur avec la valeur C:\Program Files\Apache Software Foundation\apache-maven-2.0.9. Assurez vous de supprimer les guillemets autour du chemin même s’il contient des espaces.
  4. Dans la même fenêtre, ajouter la variable d’environnement M2 aux variables utilisateur avec la valeur %M2_HOME%\bin
  5. Optionnel : à partir de la même fenêtre, on peut ajouter la variable d’environnement MAVEN_OPTS aux variables utilisateur pour spécifier des propriétés de la JVM comme par exemple les valeurs -Xms256m -Xmx512m. Cette variable d’environnement peut être utilisée pour fournir des options supplémentaires à Maven.
  6. à partir de la même fenêtre mettez à jour/ créez la variable d’environnement Path dans les variables d’environnement utilisateur pour y rajouter %M2% afin de rendre la commande mvn disponible en ligne de commande depuis une console.
  7. toujours dans cette fenêtre, vérifier que vous avez bien la variable JAVA_HOME qui existe et qu’elle contient l’emplacement du JDK, par exemple C:\Program Files\Java\jdk1.5.0_02 et que %JAVA_HOME%\bin fait partie de la variable d’environnement Path.
  8. Vérifier que Maven est bien installé en tapant dans la console (pour ouvrir une console sous windows, raccourci clavier Windows + R, on tape cmd puis on fait Entrer) la commande :
  9. mvn –version

Débuter avec Maven

Créer son premier projet Maven

Nous allons nous lancer dans la création de notre premier projet Maven. Pour créer ce projet, nous allons faire appel au mécanisme d’archetype. Un archetype est défini comme un modèle réutilisable. Dans Maven, un archetype est un template (une trame en français) d’un projet qui est combiné avec des informations entrées par l’utilisateur pour produire un projet Maven qui a été assemblé pour les besoins spéficiques de l’utilisateur. Nous allons voir comment le mécanisme d’archetype fonctionne, pour en savoir plus sur les archetypes, vous pouvez consulter cette page de la documentation officielle.

  • Pour commencer ouvrez Eclipse
  • Après il faut créer un projet Maven comme ceci :
    • clic droit dans Eclipse
    • New -> Other
    • Maven -> Maven Project
    • Puis faire ceci :



Pour en savoir plus sur les conventions de nommage avec Maven, vous pouvez lire ce court chapitre du site officiel de Maven.

  • Lorsque la tâche est achevée on obtient un projet sf-tutorial-maven avec l’arborescence suivante :


Nous allons nous intéresser maintenant au fichier XML pom.xml qui a été généré, il contient en principe les lignes suivantes :

<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>tutorial-maven</groupId>
  <artifactId>sf-tutorial-maven</artifactId>
  <version>0.0.1-SNAPSHOT</version>
    <name>sf-tutorial-maven</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.4</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

Le fichier pom.xml,  à la racine du projet,  contient son Project Object Model (POM). Chaque projet ou sous-projet est configuré par un POM qui contient les informations nécessaires à Maven pour gérer le projet ( nom du projet, numéro de version, dépendances vers d’autres projets, bibliothèques nécessaires à la compilation, noms des contributeurs …).

POM est l’unité de travail basique de Maven. Il est important de comprendre que Maven fonctionne par nature autour de la notion de projet avec une approche orientée objet car chaque POM hérite des propriétés du POM parent. Si une propriété est redéfinie dans le POM du projet, elle écrase celle qui est définie dans le projet parent. Ceci introduit le concept de réutilisation de configuration.

Dans notre exemple, le fichier est très simple, mais il contient les éléments clés d’un POM que nous allons détailler afin de mieux comprendre à quoi ils correspondent :

  • project : C’est l’élément racine de tout fichier pom.xml dans Maven.
  • modelVersion : Cet élément indique quelle version de l’objet modèle est utilisée dans ce POM. La version du modèle en lui même change très rarement mais est nécessaire afin d’assurer la stabilité d’utilisation si les développeurs du projet Maven décident de changer le modèle.
  • groupId : Cet élément indique l’identifiant unique de l’organisation ou groupe qui a créé le projet. Le groupId est un des identifiants clé d’un projet et est typiquement basé sur le nom de domaine complet de votre organisation. Par exemple org.apache.maven.plugins est le groupId pour tous les plug-ins Maven.
  • artifactId : Cet élément indique le nom de base unique de l’artefact principal généré dans ce projet. L’artefact principal d’un projet est typiquement un fichier JAR. Les artefacts secondaires comme les répertoires sources intègrent aussi l’artifactId comme une partie de leur nom final. Un artefact de base produit par Maven aurait un nom de la forme <artifactId>-<version>.<extension>, par exemple myapp-1.0.jar.
  • packaging : Cet élément spécifie le type de package à utiliser pour cet artefact (comme JAR, WAR, EAR, etc.). Cela n’indique pas seulement si l’artefact produit sera un JAR, WAR, ou EAR mais peut aussi indiquer un cycle de vie spécifique à utiliser dans le processus de développement. La valeur par défaut du packaging est le JAR, il n’est pas nécessaire de le préciser systématiquement.
  • version : Cet élément renseigne la version de l’artefact générée par le projet. Maven s’efforce d’aider les développeurs dans la gestion des versions et on verra souvent le terme SNAPSHOT dans une version, ce qui indique qu’un projet est en phase de développement.
  • name : Cet élément spécifie le nom du projet. Il est très souvent utilisé durant la génération de documentation de Maven.
  • url : Cet élément indique l’adresse où le site du projet peut être trouvé. Il est très souvent utilisé durant la génération de documentation de Maven.
  • description : Cet élément fournit une description rapide pour le projet. Il est très souvent utilisé durant la génération de documentation de Maven.

Si vous voulez connaître tous les éléments qui existent pour les POM, vous pouvez consulter la POM Refecence.

Le cycle de vie d’un projet Maven

Maven 2.0 est basé sur le concept du cycle de vie du développement (ou plus communément appelé en anglais Build Lifecycle)du projet. Le processus de développement et de distribution est clairement défini pour un projet.
Pour les personnes développant le projet, cela leur permet de ne devoir retenir que l’ordre des tâches à exécuter pour construire le projet, et le POM assurera le bon fonctionnement de ces tâches.

Maven propose trois cycles de vie préfabriqués : default, clean, et site.

  • default : le cycle de vie default prend en charge le déploiement du projet.
  • clean : le cycle de vie clean prend en charge le nettoyage du projet.
  • site : le cycle de vie site prend en charge la création du site pour la documentation du projet.

Un cycle de vie du développement est composé de phases.
Chacun de ces cycles de vie est défini par une liste de différentes phases du développement, dans lesquels elles représentent une étape dans le cycle de vie.

Par exemple le cycle de vie default contient les phases de développement suivantes :

  • validate : valide un projet en vérifiant qu’il est correct et que toutes les informations nécessaires sont présentes.
  • compile : compile le code source du projet.
  • test : test le code source compilé en faisant appel aux tests unitaires à partir du Framework JUnit. Ces tests ne requièrent pas que le code soit packagé ou déployé.
  • package : rassemble le code source compilé et le package pour l’inclure dans un format distribuable comme par exemple un fichier JAR par défaut.
  • integration-test : transforme et déploie le package si nécessaire dans l’environnement de test.
  • verify : exécute n’importe quel contrôle pour vérifier que le package est bien valide et respecte les critères de qualité.
  • install : installe le package dans le repository local, pour pouvoir être utilisé comme dépendance dans d’autres projets locaux.
  • deploy : s’effectue dans un environnement d’intégration ou de production, copie les packages finaux dans le repository distant pour être partagé avec d’autres développeurs/projets.

Ces phases de développement (en plus des autres phases qui n’apparaissent pas ici) sont exécutées dans l’ordre une à une pour accomplir le cycle de vie par défaut. Pour plus d’information sur le cycle de vie allez consulter la page suivante de la documentation officielle de Maven.

Installer Maven sous Eclipse

Maintenant que l’on a vu comment créer un projet Maven en ligne de commande, et compris les principes du POM dans Maven, nous allons continuer le tutoriel avec un plug-in d’intégration de Maven dans Eclipse, pour se faciliter la vie, et voir ce que Maven permet de faire.
Il existe plusieurs plug-ins pour intégrer Maven à Eclipse. Nous allons pour ce tutoriel installer le plug-in m2eclipse. Pour l’installer il suffit de procéder de la manière suivante :

  • On lance Eclipse
  • On clique sur le menu Help → Software Updates…
  • Dans la nouvelle fenêtre Software Updates and Add-ons on clique sur l’onglet Available Software
  • On clique ensuite sur le bouton Add site… et on ajoute successivement les url suivantes :

http://m2eclipse.sonatype.org/sites/m2e
http://m2eclipse.sonatype.org/sites/m2e-extras

  • On Valide en cliquant sur OK
  • De nouveaux sites apparaissent alors dans la liste de la fenêtre Software Updates and Add-ons
  • On clique alors sur la petite flèche en face des nouvelles adresses ajoutées pour déplier les différents plug-ins disponibles.
  • On coche ensuite Maven Integration et Maven Integration for WTP (Optional) dans Maven Projtects Configurators.
  • On clique sur la flèche en face du site Web Tools (WTP) Update Site.
  • On coche Web Tools Platform (WTP) 3.03.
  • On lance ensuite l’installation de tous ces plug-ins en cliquant sur Install….
  • Eclipse va alors demander d’accepter les termes/conditions d’utilisation, puis télécharger le tout et demander de redémarrer Eclipse pour que les changements prennent effet.
  • On redémarre donc Eclipse à la fin de l’installation.

Une fois l’installation des plug-ins finie, il faut configurer le plug-in m2eclipse. En effet, par défaut ce plug-in embarque une version 3 de maven. Or nous avons installé manuellement la version 2. Il va donc falloir indiquer à m2eclipse quelle version de maven il doit utiliser.
Dans un premier temps, il faut trouver où maven à été installé. Par exemple dans /usr/share/maven2.
Maintenant que l’on sait où a été installé maven, il faut l’indiquer dans eclipse.

  • Pour cela aller dans Window → Preference
  • Puis dans l’onglet Maven → Installations.
  • Dans la nouvelle fenêtre cliquer sur Add… et indiquer où se trouve l’installation de maven.
  • Appliquer les changements.

De plus, pour ne pas avoir de warning lors de l’exécutions des tâches maven il faut indiquer où se trouve le fichier setting.xml

  • Pour cela aller dans Window → Preference
  • Puis dans l’onglet Maven → User Settings
  • Renseigner le champ User Settings avec /usr/share/maven2/conf/settings.xml si /usr/share/maven2 correspondait au dossier où est installé maven.

Si vous n’utilisez pas le plugin m2eclipse, il faut savoir que :
Eclipse a besoin de connaitre le chemin vers le dépôt local de Maven. C’est le répertoire dans lequel toutes les dépendances seront téléchargées. Il suffit pour cela de définir la varible M2_REPO. On peut la définir avec la commande suivante depuis une console :
mvn -Declipse.workspace=/home/nprouteau/workspace eclipse:add-maven-repo
On peut aussi la définir à partir directement dans Eclipse à partir de l’interface via le menu Window → Preferences puis Java → Build Path → Classpath Variables page.
Nous voila prêts pour la suite du tutoriel sous Eclipse !

Utiliser Maven sous Eclipse

On va tout d’abord récupérer le projet que nous avons précédemment créé en lignes de commande (remarque : Il est tout à fait possible de créer son projet directement dans Eclipse avec les plug-ins que l’ont vient d’installer, en faisant File → New → Other → Maven Project).
Il faut importer notre projet Maven créé précédemment dans Eclipse :

  • On va dans le menu File → Import → Maven Projects
  • On sélectionne le répertoire correspondant à notre projet Maven créé précédemment dans le workspace (par exemple dans notre cas /home/user/workspace/sf-tutorial-maven)
  • En principe il va trouver le fichier pom.xml, on vérifie qu’il est bien coché dans la liste, puis on valide en cliquant sur Finish.

Nous sommes désormais prêts pour travailler sur notre premier projet Maven avec Eclipse !
Une nouvelle option Maven est disponible dans le menu contextuel lorsqu’on clique droit sur un projet dans le Package Explorer. Elle propose les nouvelles options de Maven disponibles pour le projet.

Editer le POM du projet

Le plugin m2eclipse permet de modifier facilement le POM du projet Maven. Pour cela il suffit de double cliquer sur le fichier pom.xml. On aura alors accès à une interface similaire à celle affichée ci dessous.

Lancer les tâches Maven

Il est aussi possible de lancer les tâches Maven du cycle de vie du projet en faisant un clic droit Run As sur le fichier pom.xml dans le package explorer. Nous allons par exemple lancer la tâche Maven Test. On obtient alors en principe l’affichage suivante dans la console :

[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------------
[INFO] Building sf-tutorial-maven
[INFO] 
[INFO] Id: tutorial-maven:sf-tutorial-maven:jar:0.0.1-SNAPSHOT
[INFO] task-segment: [test]
[INFO] ------------------------------------------------------------------------
[INFO] [resources:resources]
[INFO] Using default encoding to copy filtered resources.
[INFO] [compiler:compile]
[INFO] Nothing to compile - all classes are up to date
[INFO] [resources:testResources]
[INFO] Using default encoding to copy filtered resources.
[INFO] [compiler:testCompile]
[INFO] Nothing to compile - all classes are up to date
[INFO] [surefire:test]
url = http://repo1.maven.org/maven2
Downloading: http://repo1.maven.org/maven2/org/apache/maven/surefire/surefire-junit4/2.4.2/surefire-junit4-2.4.2.pom
1K downloaded
url = http://repo1.maven.org/maven2
Downloading: http://repo1.maven.org/maven2/junit/junit/4.0/junit-4.0.pom
210b downloaded
url = http://repo1.maven.org/maven2
Downloading: http://repo1.maven.org/maven2/org/apache/maven/surefire/surefire-junit4/2.4.2/surefire-junit4-2.4.2.jar
11K downloaded
url = http://repo1.maven.org/maven2
Downloading: http://repo1.maven.org/maven2/junit/junit/4.0/junit-4.0.jar
103K downloaded
[INFO] Surefire report directory: /home/jmigaud/scub-foundation/workdir/workspace-maven/sf-tutorial-maven/target/surefire-reports
 
-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running TestMaven
début du Test
Méthode du Test
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.021 sec
 
Results :
 
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
 
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 2 seconds
[INFO] Finished at: Tue Nov 20 15:34:35 CET 2012
[INFO] Final Memory: 3M/78M
[INFO] ------------------------------------------------------------------------

Télécharger les sources

Les sources du projet Eclipse pour ce tutoriel sont téléchargeables sur Source Forge à l’adresse suivante.