Maven en 5 minutes

A quoi sert ce foutu machin que les développeurs Java utilisent ?
Quelles avantages à l'utiliser dans vos projets ? 

Maven est un outil open source d’automatisation de production (très bien ! merci pour l'explication...). En gros, c'est un outil qui vous affranchira de tout plein de taches qui prennent du temps et qui peuvent être automatisées.

Les fondamentaux de Maven

Maven est un outil qui offre la possibilité de générer des sources, compiler du code, tester du code, importer des bibliothèques, exécuter des taches à travers des plugins et tout un tas d'autres choses.

Maven utilise un paradigme connu sous le nom de Project Object Model (POM) afin de décrire un projet logiciel, ses dépendances avec des modules externes et l'ordre à suivre pour automatiser sa production.

Tout projet Maven embarque un fichier descriptif nommé pom.xml qui est situé à sa racine.

L'exécution d'un fichier pom.xml avec la commande mvn aura pour effet de lancer les différentes phases du cycle d'exécution de Maven. Le cycle d'exécution par défaut est le suivant.

L'exécution de la commande mvn package aura pour effet d'exécuter toutes les phases du cycle qui précèdent la phase package (elle inclue). La ré-exécution automatique de toutes les phases permet de repérer des problèmes de compilation, des régression sur les tests, ou toute chose stupide que vous auriez pu introduire dans votre code.

Tout projet Maven est identifié par un triplet :

• groupId (Identifiant de votre groupe de projets, ex : org.blogdugX.monProjet),
• artefactId (identifiant de votre projet, ex : blogdugX-model)
• version (ex : 2.0, 2.0.1, 1.3.3), qui est définit dans le fichier pom.xml.

La structure d'un fichier pom.xml ressemble à ça :

<project> <!-- Balise principale d'un fichier pom -->

  <groupId>org.blogdugX.monProjet</groupId>  <!-- mon groupId -->
  <artifactId>blogdugX-model</artifactId>  <!-- mon artefactId -->
  <version>0.1</version>  <!-- la version de mon projet -->

  <packaging>jar</packaging> 

  <dependencies>
    <!-- Ici les dépendances de mon projet -->
  </dependencies>

  <build>
  <plugins>
    <!-- Ici les plugins qui seront attachés à des phases du cycle d'exécution -->
  </plugins>
  </build>

</project>

Maven et la gestion des dépendances

Le succès de Maven réside en grande partie dans sa capacité à gérer les importations de modules externes.

On entend par modules externes, les librairies et projets Java nécessaires à l'exécution de votre programme.

Par exemple, si vous souhaitez déployer des webservices, vous aurez besoin d'une implémentation de webServices telle que CXF, si vous souhaitez structurer votre appli avec Spring, vous aurez besoin d'une référence à des libraires de Spring dans votre projet, etc...

Pour faire référence à une librairies externe, vous devrez définir une dépendance dans votre fichier pom.xml de la manière suivante.

<dependencies>

<dependency>
  <groupId>commons-lang</groupId>
  <artifactId>commons-lang</artifactId>
  <version>2.1</version> 
</dependency>

<dependency>
  <groupId>org.apache.tomcat</groupId>
  <artifactId>servlet-api</artifactId>
  <version>6.0.36</version>
  <scope>provided</scope>
</dependency>

[...]

</dependencies>
 

Lors de l'exécution de votre fichier pom.xml par Maven, les projets seront rapatriés automatiquement et les références à votre projet créées. Si les projets rapatriés nécessitent d'autres projets pour s'exécuter, ceux-ci seront également récupérés.

La balise <version> des dépendances est facultative, par défaut Maven charge la dernière version du projet disponible.

Il est est de même pour la balise <scope>, qui définit la portée de la dépendance. Par défaut sa valeur est 'compile', ce qui signifie que la librairie sera embarquée dans le packaging final.
Les autres valeurs possibles sont :

• test : librairie utilisé uniquement pour les tests,
• provided : librairie nécessaire à la compilation du projet mais non nécessaire à l'exécution car fournit par l'environnement,
• runtime : librairies nécessaires à l'exécution mais non à la compilation

Mais quelle librairies dois-je importer ? Qu'est ce que je mets dans ce <artifactId> et ce <version> ?
Et si mon projet n'est pas encore sous Maven, comment retrouver les projets Maven équivalents ?

Ne vous inquiètez pas, tout est prévu ! Pour trouver des dépendances existantes, il existe des sites qui recensent toutes les librairires disponibles sur les repository public. Parmi eux, on peux citer http://search.maven.org/ ou http://mvnrepository.com/

Les plugins Maven

Il est possible de customiser le build Maven en attachant des traitements supplémentaires, que l'on appelle des plugins, aux phases du cycle d'exécution.
Pour cela, on utilise la balise <build> et l'on y place des <plugin></plugin> à l'intérieur.
Un exemple est plus parlant :

<build>
  <plugins>
  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>2.0</version>
    <configuration>
      <executable><!-- path-to-javac --></executable>
      <compilerVersion>1.3</compilerVersion>
    </configuration>
  </plugin>
  </plugins>
</build>

Le plugin maven-compiler-plugin est utilisé pour compiler les sources de votre projet.
Dans cet exemple, on précise que l'on souhaite compiler le code en version java 3.

Un autre exemple :

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-antrun-plugin</artifactId>
  <executions>
  <execution>
    <phase>initialize</phase>
    <configuration>
    <tasks>
      <ant antfile="path/to/build.xml" />
    </tasks>
    </configuration>
    <goals>
      <goal>run</goal>
    </goals>
  </execution>
  </executions>
  <dependencies>
    <dependency>
      <groupId>org.apache.ant</groupId>
      <artifactId>ant-nodeps</artifactId>
      <version>1.7.0</version>
    </dependency>
  </dependencies>
</plugin>

Dans cet exemple, on utilise le plugin maven-antrun-plugin, qui permet d'exécuter des tâches ant.
Ce plugin nécessite une dépendance vers la librairie org.apache.ant pour fonctionner.

La liste de tous les plugins officiels de Maven est disponible sur http://maven.apache.org/plugins/.
Il existe cependant de nombreux autres plugins permettant d'effectuer toute sorte de tâche pour votre projet.
Le projet Mojo en référence un certains nombre, voir http://mojo.codehaus.org/. Vous en trouverez d'autres sur code.google.com ou sur github.com.

Maven et les archetype

Un autre grand intérêt de Maven est le plugin Archetype.
Archetype est un outil permettant de générer des squelettes de projets à partir de templates que l'on nomme des archetypes.

La commande pour créer un projet à partir d'un archetype est la suivante :

mvn archetype:create -DarchetypeGroupId=groupIdDeLArchetype -DarchetypeArtifactId=artefactIdDeLArchetype
-DgroupId=groupIdDeVotreProjet -DartifactId=artefactIdDeVotreProjet
-Dversion=versionDeVotreProjet

Il existe des archetypes pour quasiment tous les frameworks et les librairies java (en vrac on peut citer GWT, Appfuse, CXF, JSF, Wicket, Tapestry, et tant d'autres !)

Vous trouverez peut être votre bonheur sur http://docs.codehaus.org/display/MAVENUSER/Archetypes+List qui en liste un certain nombre. L'intérêt d'utiliser un archetype maven est de démarrer d'un projet correctement structuré que vous allez pouvoir modifier et enrichir par la suite. Vous économisez du temps de réflexion sur l'achitecture initiale de votre projet et vous disposez d'une configuration directement fonctionnelle.

Le documentation du plugin archetype est disponible à l'adresse http://maven.apache.org/archetype/maven-archetype-plugin/