Category Archives: Tutoriel Maven

Tuto Git – Utiliser Git avec eclipse

Objectif: Comprendre les procédures d’utilisation de Git pour gérer un projet développé avec eclipse. Le principal intérêt est un meilleur confort avec l’interface graphique mais aussi une utilisation integrée à cet IDE. Pré-requis: Etre familier avec Git et son utilité (cf. articles précédents à ce sujet).

1. Créer un projet Java Maven autonome.

Le menu à utiliser est : File / New / Maven Project Tuto gitSi le sous-menu “Maven project” n’apparaît pas dans votre version d’eclipse, utiliser le sous-menu “Other..” qui donne accès à cette fonctionnalité. Ce menu affiche la fenêtre: mTuto gitIl suffit de clicker sur “Next”, car on souhaite utiliser un archetype de création de projet. Tuto gitUn archetype Maven est un assitant qui facilite la création d’un gabarit de projet. Sélectionner “quickstart” qui permet la création d’un projet autonome simple. Tuto gitSaisir le “Groupe Id” (généralement le domaine de l’oganisme pour l’unicité universelle) et l'”Artifact Id” (généralement le nom de l’application). Après cliquer sur  “Finish” pour créer le projet. Tuto gitLe nouveau projet est prêt à l’emploi, il est exécutable immédiatement et sans aucune modification (mais bien entendu ne fait rien d’autre que d’afficher “Hello world”).

2. Gérer le projet avec Git

Dans l’explorateur de projets, sélectionner le projet “calcul” et utiliser le menu contextuel d’eclipse (click sur le bouton droit de la souris). Tuto gitDans le menu “Team“, sélectionner le sous-menu “Share project“, ceci lance la procédure d’integration du projet à Git. Tuto gitSélectionner la case à cocher “Use or create repository in parent folder of project“, l’affichage devient: Tuto gitEnsuite utiliser le bouton “Create repository“.. Tuto gitA l’étape suivante, il faut cocher l’unique projet à prendre en compte et ensuite utiliser le bouton “Finish“. Cette procédure permet de mettre le projet calcul sous le contrôle de Git.

3.Commiter le projet.

Le projet calcul étant sous le contrôle de Git, si on active le menu contextuel “Team” (cf. paragraphe 2,; étape 1) on constate que les commandes de Git sont maintenant disponibles. git-firstcommitOn reconnait notamment les commandes:
  • Commit” : permet de valider des modifications de fichiers (équivalent de “git commit“).
  • Add to index” : permet d’ajouter des fichiers à l’index (équivalent de “git add“).
On va utiliser le menu “CommitTuto gitTout d’abord il faut ajouter les fichiers à l’index. On sélectionne les fichiers puis on utilise le menu contextuel (click droit) “Add to index“. Bien entendu on aurait pu utiliser le menu de cette fonctionnalité dès le départ, mais on procédant ainsi, on fait tout dans la même fenêtre (équivalent de “git commit -a“) Tuto gitEnfin, on saisit le message du commit et on actionne le bouton “Commit“. Ceci valide les fichiers sélectionnés dans le dépôt local de Git.]]>

Tutoriel Maven – Mettre en place un dépôt personnel

Objectif: Cette 4eme partie de la série “tutoriel maven” a pour objectif de montrer comment mettre en place un dépôt maven personnel public. Pour cela, nous verrons la manière avec la quelle Maven prend en compte ses dépôts lors de la construction d’un logiciel cible. Pré-requis: Maven et Java sont installés sur la machine cible munie de l’OS GNU/Linux Debian, Ubuntu ou compatibles. cf. l’article sur l’installation de Maven 3. Pour construire un logiciel cible, Maven télécharge et installe tout ce dont il a besoin pour accomplir cette tâche. Ces besoins sont principalement:

  • Les librairies dont dépend l’application: déclarées dans la section <dependencies></dependencies> du fichier pom.xml du projet.
  • Les plugin Maven qui accomplissent différentes tâches nécessaires à la construction de la cible : déclarés dans la section <plugins></plugins> du fichier pom.xml du projet.
Qui dit téléchargement, dit source et emplacement d’installation. Par défaut, si rien n’est indiqué dans la section <repositories></repositories> de pom.xml du projet, le téléchargement se fait depuis l’adresse: http://repo.maven.apache.org/maven2 Par défaut également, la cible locale de ces téléchargements se trouve dans ~/.m2/repository (sous dossier .m2/repository du dossier personnel de l’utilisateur qui lance la construction, /home/xxxxxx, xxxxxx étant l’identifiant de cette personne sur la machine d’exécution). Cette cible locale, est le dépôt Maven local. A la construction du logiciel cible, Maven cherche d’abord ses besoins dans le dépôt local, s’il ne les trouve pas il les télécharge à partir de là où il pourrait les trouver. Passons à la pratique.

1. Sauvegarder le dépôt Maven local

Si Maven est déjà installé et qu’il a été utilisé, il convient de sauvegarder le dépôt actuel. A la fin des manipulations proposées, il sera possible de le rétablir tel qu’il était à l’origine.
mv ~/.m2/ ~/m2-save/

2. Télécharger les sources d’une librairie Java exemple et la construire

Exécuter les commandes suivantes l’une après l’autre:
mkdir tmp && cd tmp
wget http://meddeb.net/data/bee-src.tgz
tar xzvf bee-src.tgz
cd bee/
mvn package
Ce qui revient principalement à télécharger les sources d’un exemple à construire et lancer sa construction. Remarquer que Maven télécharge beaucoup de fichiers .jar depuis le dépôt de Maven par défaut, ensuite la construction échoue.
vi pom.xml
Remarquer qu’il n’y a aucune référence à un dépôt: la balise <repositories> n’est pas utilisée du tout.
ls -la ~/.m2
Remarquer que cet emplacement a été recrée et même alimenté.

3. Lancer une deuxième fois la reconstruction

mvn clean package
Cette fois Maven ne télécharge plus rien, car tout ce dont il a besoin existe déjà dans le dépôt local. La construction échoue toujours car la même librairie manquante est introuvable.

4. Modifier le dépôt local par défaut

sudo vi /etc/maven/settings.xml
Repérer la balise <localRepository>, dé-commenter la et saisir une emplacement correcte, par exemple: /home/votreidentifiant/maven-repo. Remplacer “votreidentifiant” par votre identifiant sur la machine utilisée. Ceci donne: <localRepository>/home/votreidentifiant/maven-repo</localRepository>
mvn clean package
Maven télécharge ses besoins à nouveau (car le nouveau dépôt est vide) et la construction échoue toujours à la fin.
ls -l ~/maven-repo
Le nouveau dépôt est créée.

5. Référencer un dépôt source dans pom.xml

vi pom.xml
Ajouter à la fin du fichier, avant la balise </project>
<repositories>
  <repository>
    <id>meddeb-net</id>
    <name>Meddeb.net Repository</name>
    <url>http://meddeb.net/maven</url>
  </repository>
</repositories>
Ensuite, construire
mvn clean package
Maintenant la construction réussit car la librairie qui manque se trouve dans ce dépôt personnel.

6. Mettre en place un dépôt personnel

Pour cela il faut disposer d’un site web accessible sur Internet. Créer sur le serveur de ce site un dossier maven/ à la racine. Ajouter à la fin de la section de pom.xml (de la librairie bee)
<extensions>
  <extension>
    <groupId>org.apache.maven.wagon</groupId>
    <artifactId>wagon-ftp</artifactId>
    <version>2.6</version>
  </extension>
</extensions>
Ensuite, ajouter à la fin de pom.xml (avant </project>) en remplaçant “domaine” par le nom de domaine approprié et en ajustant l’url pour l’adapter à l’url ftp d’accès au site utilisé.
<distributionManagement>
 <repository>
   <id>domaine-net</id>
   <url>ftp://ftp.domaine.net/maven</url>
 </repository>
</distributionManagement>
Enfin, ajouter dans le fichier ~/.m2/settings.xml
<settings>
  <servers>
    <server>
      <id>domaine-net</id>
      <username>ftp-user</username>
      <password>ftp-password</password>
    </server>
 </servers>
</settings>
id: le même utilisé dans pom.xml ftp-user: identifiant d’accès ftp au site ftp-password; mot de passe ftp d’accès au site ftp-user, ftp-password et l’url ftp du site sont fournie par votre hébergeur du site utilisé. Maintenant on peut déployer le fichier .jar résultat dans le dépôt personnel.
mvn package deploy
Pour installer dans le dépôt local:
mvn package install
]]>

Tutoriel Maven – Tests unitaires Java

Objectif: Ce tutoriel Maven concerne la mise en place de test unitaire java avec cet outil. Par défaut, à la génération d’un nouveau projet, Maven met en place tout ce qu’il faut pour intégrer un test unitaire java. Il s’agit de la branche test de l’arborescence créée, cf. l’article Tutoriel Maven 3 – partie 2. Dans ce tutoriel Maven on verra comment mettre en place ce test unitaire java, comment le contourner en cas de besoin et l’intérêt de cette fonctionnalité dans le processus de développement de logiciels. Pré-requis: le JDK est installé, cf. l’article: Installer Java sur Ubuntu ou compatible et Maven 3 est installé cf. l’artice: Tutoriel Maven 3 – partie 1

1. Maven test unitaire Java est mis en place par défaut à la génération du projet

mvn archetype:generate -DgroupId=com.example.calculateur \
    -DartifactId=calculteur -Dversion=1.0 -Dpackage=com.example.calculateur \
    -DinteractiveMode=false
ls calculateur/src/test/java/com/exemple/calculateur/
AppTest.java
La classe AppTest.java a été générée pour contenir le code des tests. La dépendance au framework JUnit a été rajoutée dans le fichier pom.xml
.....
<dependencies>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>3.8.1</version>
    <scope>test</scope>
  </dependency>
</dependencies>
.....

2. Simuler une erreur de test unitaire Java

Dans le code de la classe AppTest.java, repérer:
public void testApp()
{
   assertTrue( true );
}
Et modifier en:
public void testApp()
{
   assertTrue( false );
}
Après cela si on lance la reconstruction de l’application, l’opération échoue à cause de test non concluant.
mvn clean package
..
..
-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running com.exemple.calculateur.AppTest
Tests run: 1, Failures: 1, Errors: 0, Skipped: 0, Time elapsed: 0.46 sec <<< FAILURE!

Results :

Failed tests:   testApp(com.exemple.calculateur.AppTest)

Tests run: 1, Failures: 1, Errors: 0, Skipped: 0

[INFO] ------------------------------------------------------------------------
[INFO] BUILD FAILURE

3. Ajouter les fonctions de calcul à l’application

Ajouter une classe qui se charge des calculs: Calc.java et activer l’appel au calcul dans App.java
package com.exemple.calculateur;
public class Calc
{
  private int getInt(String s) {
    int resultat = -1;
    try {
      resultat = Integer.parseInt(s);
    }
    catch (NumberFormatException e) {
      resultat = -1;
    }
    finally {
      return resultat;
    }
  }
  public int somme(String s1, String s2)
  {
    int i1 = getInt(s1);
    int i2 = getInt(s2);
    int resultat = i1 + i2;
    return resultat;
  }
  public int multiplication(String m1, String m2)
  {
    int i1 = getInt(m1);
    int i2 = getInt(m2);
    int resultat = i1 * i2;
    return resultat;
  }
}
// Dans App.java
public static void main( String[] args )
{
  if (args.length != 3) {
    System.out.println("Opération non supportée.");
    System.exit(1);
  }
  String operation = args[1];
  Calc calc = new Calc();
  int resultat = -1;
  if (operation.equalsIgnoreCase("+")) {
    resultat = calc.somme(args[0], args[2]);
  } else if (operation.equalsIgnoreCase("x")) {
    resultat = calc.multiplication(args[0], args[2]);
  }
  if (resulat >= 0) {
    System.out.println("Résultat: " + resultat);
  } else System.out.println("Opération non supportée");
}
Ce code a été écrit pour répondre au cahier des charges suivant:
  1. Le calculateur peut effectuer les opérations d’addition et de multiplication.
  2. Les opérations ne portent que sur des nombres entiers positifs ou nul.
  3. On passe trois arguments au calculateur, dans l’ordre: 1er opérande, opération, 2eme opérande.
  4. En cas d’erreur d’utilisation le calculateur répond par le message “Opération non supportée”.

4. Ajouter le test unitaire Java en conformité avec le cahier des charges

Ce test doit contrôler le fonctionnement des méthodes de la classe Calc qui effectue le calcul et constitue le cœur de cette application. Commençons par la méthode Calc.somme(String s1, String s2). Dans AppTest.java on va modifier le code, cette fois pour inclure les tests.
public void testApp()
{
  Calc calc = new Calc();
  assertEquals(calc.somme("321", "425"), 746);
  assertTrue(calc.somme("abc", "cba") < 0);
  assertTrue(calc.somme("abc", "653") < 0);
  assertTrue(calc.somme("-145", "153") < 0);
}
A la construction de l’application le troisième test échoue. En révisant le code de la classe Calc, on s’aperçoit de l’erreur et on corrige le code de la méthode Calc.somme(String s1, String s2)
public int somme(String s1, String s2)
{
  int resultat = -1;
  int i1 = getInt(s1);
  int i2 = getInt(s2);
  if ((i1 >= 0) && (i2 >= 0)) resultat = i1 + i2;
  return resultat;
}
Après cette correction, la construction de l’application se fait sans échec. Vous pouvez vous exercer en mettant en place les tests pour la deuxième méthode de multiplication.

5. Désactiver le test unitaire Java

Dans certains cas, on pourrais avoir besoin de désactiver la phase de test afin de forcer la construction de l’application. Cela peut se faire de deux façons.

5.1. En ligne de commande

mvn -Dmaven.test.skip=true package

5.2. En modifiant le fichier pom.xml

Dans le fichier pom.xml du projet, ajouter la référence au plug-in surefire. Remarquer le paramètre: <skipTests>true</skipTests>
<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-surefire-plugin</artifactId>
  <version>2.18.1</version>
  <configuration>
    <skipTests>true</skipTests>
  </configuration>
</plugin>
]]>

Tutoriel Maven 3 – partie 2

Objectif de la partie 2 du tutoriel Maven: Cette 2eme partie du tutoriel Maven vise à construire pas à pas une application java qui s’exécute simplement en ligne de commande en invoquant le nom du fichier. L’application ne fait qu’afficher un message sur la console (sortie standard) mais peut servir de point de départ afin de construire ce type d’application. Prére-requis: le JDK est installé, cf. l’article: Installer Java sur Ubuntu ou compatible et Maven 3 est installé cf. l’artice: Tutoriel Maven 3 – partie 1

1. Première partie de ce tutoriel Maven: génerer un squelette d’application en ligne de commande

La commande à utiliser est:
mvn archetype:generate -DgroupId=com.example.hello \
    -DartifactId=helloworld -Dversion=1.0 -Dpackage=com.example.helloworld \
    -DarchetypeArtifactId=maven-archetype-quickstart \
    -DinteractiveMode=false
Remplacer: com.exemple.hello, helloworld, 1.0, com.example.helloworld  par les valeurs personnalisées de votre choix. Ceci crée l’arborescence de code source Java suivante: tutoriel maven structure helloworldIl s’agit de l’arborescence par défaut d’un projet Java Maven. Les codes source sont dans un dossier qui s’appelle src. Deux branches sont sous src:
  • test: contient les sources des test unitaires. Ce sujet ne sera pas abordé pour le moment.
  • main: contient les sources de l’application (dans le sous dossier java)
On remarque aussi la génération d’une classe Java unique qui constitue le point d’entrée de l’application App.java.

1.1. Construire l’application

Depuis le dossier helloworld/ de l’application:
mvn package
Ceci génère le fichier jar de l’application: helloworld-1.0.jar dans le sous-dossier target/

1.2. Exécuter cette application modèle

Depuis le dossier helloworld/ de l’application:
java -cp target/helloworld-1.0.jar com.example.helloworld.App
Hello World !
On est encore loin du but car il a fallu invoquer java avec deux paarmètres: le classpath et la classe principale.

2. Deuxième partie de ce tutoriel Maven: créer un jar exécutable

Pour cela on va utiliser le plug-in maven-assembly-plugin. On modifie donc le fichier pom.xml généré pour y ajouter toute la partie entre les balises <build>
 <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>com.example.hello</groupId>
  <artifactId>helloworld</artifactId>
  <packaging>jar</packaging>
  <version>1.0</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>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-assembly-plugin</artifactId>
        <configuration>
          <archive>
            <manifest>
              <mainClass>com.example.helloworld.App</mainClass>
            </manifest>
          </archive>
          <descriptorRefs>
             <descriptorRef>jar-with-dependencies</descriptorRef>
          </descriptorRefs>
          <appendAssemblyId>false</appendAssemblyId>
        </configuration>
        <executions>
          <execution>
            <id>make-assembly</id>
            <phase>package</phase>
            <goals>
              <goal>single</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>
Ensuite, après la reconstruction du fichier jar, l’exécution devient plus simple. On n’a plus à indiquer le nom de la classe principale. Le jar est exécutable de lui même.
mvn clean package
java -jar target/helloworld-1.0.jar
Hello World!
Il reste, toutefois, encore une étape pour atteindre l’objectif de n’invoquer que le nom du fichier.

3. Troisième partie de ce tutoriel Maven: créer un fichier exécutable.

3.1. Créer un script shell de démarrage

Dans un éditeur de texte, insérer le script suivant puis enregistrer sous le nom de boot.sh dans le dossier helloworld/
#!/bin/sh
EXEC=`which "$0" 2>/dev/null`
[ $? -gt 0 -a -f "$0" ] && EXEC="./$0"
java=java
if test -n "$JAVA_HOME"; then
  java="$JAVA_HOME/bin/java"
fi
exec "$java" $java_args -jar $EXEC "$@"
exit 1

3.2. Créer un fichier exécutable manuellement

Maintenant si on exécute la commande:
cat boot.sh target/helloworld-1.0.jar > hello && chmod +x hello
On obtient un fichier exécutable autonome hello, qui peut être exécuté tout simplement par:
./hello
Hello World!

3.3. Créer le fichier exécutable par Maven

Pour inclure cette dernière tâche au cycle de vie Maven de notre projet, on utilise le plug-in exec-maven-plugin. Pour cela on rajoute cette portion de code au fichier pom.xml. Insérer juste après le dernier plug-in ajouté.
<plugin>
  <groupId>org.codehaus.mojo</groupId>
  <artifactId>exec-maven-plugin</artifactId>
  <version>1.3.2</version>
  <executions>
    <execution>
      <phase>package</phase>
      <goals>
        <goal>exec</goal>
      </goals>
    </execution>
  </executions>
  <configuration>
    <executable>buildexec.sh</executable>
  </configuration>
</plugin>
Remarquez le buildexec.sh inclu dans la balise <executable>. Il s’agit du script que Maven va exécuter pour générer le fichier final et qu’on doit créer. Ce fichier doit effectuer les mêmes tâches que la commande manuelle effectuée précédemment. Il doit inclure donc
#!/bin/sh
cat boot.sh target/helloworld-1.0.jar > hello
chmod +x hello
A l’aide d’un éditeur de texte, créer ce fichier et le rendre exécutable:
chmod +x buildexec.sh
Enfin Maven pourra créer le fichier hello exécutable java autonome.
mvn package
./hello
Hello World!
]]>

Tutoriel Maven 3 – partie 1

Objectif de la partie 1 du tutoriel Maven:  Installer Maven 3 afin de l’utiliser dans un environnement de développement. Cible: Système Linux Ubuntu ou compatible, notamment Debian pour les machines serveurs (Maven-Debian constitue un couple parfait pour monter un serveur de build et test unitaires pour le développement).

1. Installer Maven 3

sudo apt-get install maven
Remarquer qu’il ne faut pas indiquer la version 3 de Maven dans cette commande.

2. Vérifier l’installation

mvn -version
L’installation et la configuration de Maven a été correctement effectuée si la réponse débute par la ligne (remarquer le numéro de version 3.x.x):
Apache Maven 3.x.x
A défaut de ce résultat, notamment si on obtient “Apache Maven 2.x.x” il convient d’effectuer une étape supplémentaire de configuration pour activer la version 3 de Maven.

2. Configurer l’installation de Maven

sudo update-alternatives --config mvn
  Selection    Path                       Priority   Status
------------------------------------------------------------
* 0            /usr/share/maven2/bin/mvn   200       auto mode
  1            /usr/share/maven/bin/mvn    150       manual mode
  2            /usr/share/maven2/bin/mvn   200       manual mode

Press enter to keep the current choice[*], or type selection number:
La réponse à la commande: sudo update-alternatives –config mvn , montre l’existence d’une autre version installée en tant que version par défaut. Il convient de modifier la configuration par défaut vers la la ligne qui contient: /usr/share/maven/bin/mvn (dans l’exemple la ligne 1). Taper donc 1 et Entrée. Remarque: La désinstallation de la version 2 de Maven par:
sudo apt-get remove maven2
Définira automatiquement la version 3 comme version par défaut. Ceci peut constituer une alternative à la configuration.]]>