Java EE / Spring

Maven.

Introduction

Maven est un outil permettant de gérer les dépendances, la compilation, le "packaging" et bien d'autres choses ... Il s'utilise au moyen de fichier "pom" décrivant votre projet.
Maven est développé en Java et le script "mvn" utilise la variable d'environement "JAVA_HOME" pour déterminer quelle version de java doit être utilisée. Afin d'éviter tout soucis, initialiser cette variable dans votre ".bashrc" (linux) ou ".bash_profile" (mac) ou dans les propriétés systèmes sous windows.
export JAVA_HOME="/path/to/your/java/Home"

Page de téléchargement de maven : maven.apache.org/download.html
Archive maven 3.3.3 à extraire. Ajouter le répertoire bin à votre PATH, puis vérifier en tapant mvn -v ; vous devriez obtenir quelque chose de ce type :

Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T13:57:37+02:00)
Maven home: /Users/guillaume/install/apache-maven-3.3.3
Java version: 1.8.0_11, vendor: Oracle Corporation
Java home: /Library/Java/JavaVirtualMachines/jdk1.8.0_11.jdk/Contents/Home/jre
Default locale: fr_FR, platform encoding: UTF-8
OS name: "mac os x", version: "10.10.2", arch: "x86_64", family: "mac"

Le principal intérêt de maven est de gérer des dépendances vers des librairies. Ces librairies sont téléchargées depuis un "repository", généralement le repository "central" maven.
A l'université, les connexions sur le web doivent passer par le proxy cache. Pour que maven utilise le proxy, il faut modifier le fichier "settings.xml" situé dans votre 'HOME', dans le répertoire '.m2'

Contenu du fichier settings.xml pour la configuration proxy :

<settings>
  <proxies>
   <proxy>
      <active>true</active>
      <protocol>http</protocol>
      <host>cache-etu.univ-lille1.fr</host>
      <port>3128</port>
      <username></username>
      <password></password>
      <nonProxyHosts>localhost|127.0.0.1</nonProxyHosts>
    </proxy>
    <proxy>
       <active>true</active>
       <protocol>https</protocol>
       <host>cache-etu.univ-lille1.fr</host>
       <port>3128</port>
       <username></username>
       <password></password>
       <nonProxyHosts>localhost|127.0.0.1</nonProxyHosts>
     </proxy>
  </proxies>
</settings>

Lorsque vous n'êtes pas sur le réseau de l'université pensez à désactiver le proxy ! : <active>false</active>

Le répertoire .m2 contiendra normalement toutes les librairies téléchargées (dans 'repository') par maven au fur et à mesure de son utilisation. Il est possible que ce répertoire devienne assez lourd avec le temps ...
Afin de le pas encombrer votre compte unix avec ces fichiers, je vous recommande de modifier l'endroit où maven stockera les librairies. Ajouter ceci, en l'adaptant, dans votre fichier "settings.xml" :
<localRepository>/local/username/m2<localRepository>

Pom.xml

Il faut faire de votre projet java, un projet "maven". Cela se fait simplement en ajoutant un fichier "pom.xml" à la racine.
Un fichier pom décrit notre projet en "artefact", dans un "group" et possédant une "version".
Le projet étant "packagé" selon un format défini.

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org2001/XMLSchema-instance"
           xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apahe.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
      
  <groupId>fr.eservices.xxVotreNomxx</groupId>
  <artifactId>projet-jee</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

<project>

Le pom contiendra également le nom du projet et différentes informations nécessaires à la compilation ou au packaging de notre projet.
Le plus intéressant : cela contiendra des dépendances vers des librairies, qui elles-mêmes peuvent tirer d'autres dépendances transitives.
Les dépendances sont normalement présentes sur un serveur "central" maven. C'est un site regroupant toutes les librairies de projets qui souhaitent être diffusées/utilisées.
Il est aussi possible d'ajouter d'autres "repository" par de la configuration dans le pom, ou dans les settings de maven.

Repository

Les dépendances seront stockée sur votre ordinateur dans un repository local, par défaut dans ~/.m2/repository.
Il est possible d'ajouter manuellement des librairies dans ce repository. Ce qui peut être utile pour les librairies qui ne sont pas fournies au format maven (avec un pom ou sur le repo central ...).

La conception interne de maven est modulaire et chaque "plugin" est responsable d'une fonctionnalité. Ces mêmes plugins sont également des artefacts maven disponibles sur le repo central et téléchargés au besoin.
Ainsi, c'est le plugin "install" qui va gérer les insersions dans le repo local.
Pour mettre un jar quelconque dans votre repo local on utilisera la commande :

mvn install:install-file -Dfile=fichier.jar -DgroupId=mon.groupe -DartifactId=nom-librairie -Dversion=version -Dpackaging=typeArtefact

Dépendances

Il faut distinguer différents ensembles de dépendances, nommés "scope" dans le vocabulaire maven.
» compile : (par défaut) indique que cette librairie est nécessaire pour la compilation et à l'exécution.
» runtime : uniquement nécessaire à l'exécution.
» provided : sera disponible à l'exécution mais n'est pas fourni par ce projet. Exemple : le "servlet-api" est fourni par tomcat et n'est pas amené par notre projet web. "servlet-api" est donc "provided". Cette librairie reste nécessaire à la compilation.
» test : librairie nécessaire uniquement dans l'exécution de tests unitaires. Exemple : junit.
» system : librairie disponible à travers le système de fichier local. Ce type de dépendance n'est pas tiré depuis les repository distants. A éviter, sauf si vous comitter vos librairies avec le projet (c'est mal ...)

Maven gère le classpath pour vous lors des phases de compilation et d'exécution.
Les dépendances directes et transitives sont toutes ajoutées au classpath.
Les dépendances "compile", "runtime" sont transitives. Le scope "test" est par contre limité à votre projet.

Les dépendances se gèrent dans la sections "dependencies". Pour chaque dépendance, il faut indiquer le groupId, l'artifactId, la version et le scope (par défaut compile).
Exemple de dépendance pour ajouter junit pour nos tests :

  <dependencies> 
    ...
    <dependency> 
      <groupId>junit</groupId> 
      <artifactId>junit</artifactId> 
      <version>4.12</version> 
      <scope>test</scope> 
    </dependency> 
    ...
  </dependencies>

Structure des dossiers

Par convention, maven supposera une certaine structure de dossier de votre projet :

• src
  • main
    • java : les sources principales
    • resources : les fichiers de configuration et autre. Tout sera inclus dans la librairie (donc dans le accessible via le classpath)
    • webapp (dans le cas d'un war) : les fichiers, autres que les class et resources, inclus dans le war
  • test
    • java
    • resources

Vous trouverez dans ce fichier pom.xml une structure de base décrivant votre projet.
Vous pouvez ensuite executer mvn dependency:resolve pour résoudre et télécharger toutes les dépendances.
Elles se rangeront dans votre repo local qui pourra vite devenir assez volumineux si vous travaillez régulièrement avec maven sur différents projets.
Rappel : vous pouvez modifier votre .m2/settings.xml pour modifier l'emplacement où maven rangera toutes les dépendances.
Visualisez l'arbre des dépendances avec mvn dependency:tree.

Déployer votre artefact

• copie dans un répertoire local (qui serait exposé avec apache par exemple),
• A travers une connexion FTP
• Copie avec le protocol SSH
• Copie avec le protocol HTTP : suppose que vous ayez un serveur webdav ou une application web compatible comme Nexus

<distributionManagement> 
  <repository> 
    <id>id-repository</id>
    <url>ftp://server/path</url>
  </repository> 
</distributionManagement>

<build> 
  <extensions> 
    <extension> 
      <groupId>org.apache.maven.wagon</groupId>
      <artifactId>wagon-ftp</artifactId>
      <version>1.0-beta-6</version> 
    </extension> 
  </extensions> 
</build>

<settings> 
... 
  <servers> 
    <server> 
      <id>id-repository</id> 
      <username>yourLogin</username> 
      <password>yourPassword</password> 
    </server> 
  </servers> 
... 
</settings>

Ajouter un repository

Sans configuration particulière, maven recherche d'abord les artefacts dans votre repository local, puis dans le repository central maven (https://repo.maven.apache.org/maven2).
Il est possible de modifier votre configuration globale pour ajouter un repository dans le settings.xml, mais ce repository sera utilisé pour tous vos projets, ce n'est pas nécessairement une solution idéale.
Il est aussi possible d'ajouter un repository dans le pom de votre projet dans la section "repositories".
Voici un exemple, que vous pourrez adapter ...

<repository> 
  <id>id-repository</id> 
  <name>Name of your repository</name> 
  <url>http://host:port/path/to/maven/</url> 
  <snapshots> 
    <enabled>true</enabled> 
  </snapshots> 
</repository>

La notion de "snapshot" indique à maven que les versions d'artefact "-SNAPSHOT" seront mises à jour. Il lui sera nécessaire de vérifier la dernière version disposible de l'artefact de temps en temps afin de mettre votre repository à jour.
Les versions "stable" d'artefact ne sont pas sensées changer. Une fois l'artefact déployé sur un repository, vous devriez immédiatement l'augmenter de version et lui ajouter le suffixe -SNAPSHOT.
Maven ne téléchargera pas un artefact "stable" qu'il possède en local.

Lorsque vous re-définissez les repositories dans votre pom vous devrez aussi ajouter le central maven, sinon seul votre nouveau repository sera consulté. Le central maven peut être ajouté comme un autre repository à la liste :

<repository> 
  <id>central2</id> 
  <name>Maven Central repo</name> 
  <url>http://central.maven.org/maven2/</url> 
</repository>

Le plugin maven d'eclipse

Eclipse, comme de nombreux IDE, inclut maintenant un plugin pour faciliter la gestion des projets maven.
Il suffit de passer par le menu "Import" < "Maven" < "Existing maven projects".
L'édition du pom est facilitée par un menu présentant les différentes sections, tout en permettant d'éditer directement le source xml du fichier.

Ce plugin est fort pratique mais a tendance à consommer beaucoup de mémoire, notamment lors de l'indexation des artefacts disponibles sur les repositories... Et cela peut amener eclipse à planter faute de mémoire suffisante.
Pour cette raison, il peut être intéressant d'utiliser le plugin eclipse de maven. Celui-ci génère les fichiers compatibles pour l'import de projet classique JAVA dans éclipse. (voir ci dessous).
Ou alors de cocher l'option "Do not automatically update dependencies from remote repositories" dans "Préférences" < "Maven".

Le plugin eclipse de maven

Un plugin permet de mettre à jour les dépendances d'éclipse en fonction de ce que contient le pom.xml.
Je parle ici d'un plugin eclipse pour maven, à ne pas confondre avec l'inverse (ex: plugin m2e d'eclipse).
Ce plugin va en fait mettre à jour (ou créer) les fichiers .project et .classpath utilisés par eclipse.
Cela permettra d'ajouter les dépendances dans le classpath d'eclipse.
Pour cela utilisez mvn eclipse:eclipse
Et rafraîchissez votre projet avec F5, ou clic droit/refresh.

Il faudra également définir la variable "M2_REPO" dans votre workspace pour indiquer à eclipse où est rangé le repository maven.
Rendez-vous dans Outils (ou Eclipse) / Préférence / Java / Build Path / Classpath Variables.
Ajouter une variable "M2_REPO" qui pointe vers "home"/.m2/repository

• Sommaire
• Plan du site
• Github