Initiation à Maven

Généralités sur Apache Maven

Dans l’ère de l’industrialisation du développent des applications, Maven est devenu l’un des outils indispensables pour les développeurs d’applications. Ce tutoriel « initiation à Maven » a été réalisé afin de donnée un aperçu sur cet outil merveilleux développé par la fondation Apache.

Maven n’est pas simplement un outil de construction de projets développé par la fondation Apache, c’est aussi un logiciel basé sur le concept de POM (Project Object Model) pour la gestion automatisée de projets Java.

L’objectif de Maven est de faciliter la production de projets  basés sur le langage Java et il fournit de l’aide sur :

• La construction d’un projet
• La documentation sur le projet
• Le rapport sur le projet
• La gestion des dépendances du projet
• La gestion des versions du projet
• La distribution du projet.

Au-delà de son apparence, Maven est aussi extensible, nous pouvons étendre ses fonctionnalités grâce à son système de gestion de modules complémentaires.

Ainsi, Maven fournit beaucoup d’avantage dans tous les processus de construction de  projets logiciels par l’usage d’une convention de standardisation et d’une directive de bonnes pratiques pour accélérer le cycle de développement d’un logiciel tout en minimisant les risques d’erreurs.

 

Pré requis

Dans la suite de ce document nous allons voir  Maven, par conséquent  nous devons avoir une notion sur l’installation d’une application sur un ordinateur,  la manipulation des variables d’environnement, le développement de logiciel, le concept orienté objet et une notion sur J2EE.

Prise en main et installation de Maven

Cette section nous montrera les bases nécessaires pour débuter à Maven 3.3. Nous entamerons l’installation de cet outil sur différents types de système d’exploitation et nous montrerons comment créer et compiler et vérifier un projet.

Le concept  POM, le cycle de vie de la construction d’un projet et les profils de construction seront aussi discutés dans cette section.

Installation de Maven

Comme Maven est un outil basé sur Java, il est obligatoire d’avoir le JDK version 1.7 ou plus installée sur votre système d’exploitation.

La commande java -version permet de vérifier que Java est bien installée sur votre ordinateur :

• Sous Windows

C:\>java –version

• Sous Linux

$java –version

• Sous Mac

machine:~user$java –version

Pour la suite, nous supposons que le JDK est bien installé, le variable d’environnement java JAVA_HOME est bien configuré et  le chemin des fichiers binaire a été bien ajouté à la variable d’environnement PATH :

• Sous Windows

C:\>setx JAVA_HOME "C:\Program Files\Java\jdk1.8.0_31"

C:\>setx PATH “%PATH%;%JAvA_HOME\bin”

• Sous Linux

#export JAVA_HOME = /usr/local/java-current

#export PATH=$PATH:$JAVA_HOME/bin/

• Sous Mac

machine:~user$export JAVA_HOME=/Library/Java/Home

 

Pour pouvoir installer  Maven,  il faut aller sur  http://maven.apache.org/download.cgi et de télécharger le fichier adéquat à votre système d’exploitation :

• Pour Windows : apache-maven-3.3.9-bin.zip            (8,22 Mo)
• Pour Linux et Mac : apache-maven-3.3.9-bin.tar.gz       (8,10 Mo)

Installation de Maven sous Windows

Etape1 : Décompresser le fichier  apache-maven-3.3.9-bin.zip  vers le répertoire  C:\Program Files

Etape2 : Configurer les variables d’environnement de Maven : M2_HOME, M2 et MAVEN_OPTS et PATH :

• M2_HOME  spécifie l’emplacement de Maven

C:\>setx M2_HOME "C:\Program Files\apache-maven-3.3.9"

• M2 indique l’emplacement des fichiers binaire de Maven

C:\>setx M2 %M2_HOME%\bin

• MAVEN_OPTS définit la taille de la mémoire utilisée par Maven

C:\>setx MAVEN_OPTS "-Xms512m –Xmx1024m"

• PATH définit le variable d’environnement de Windows

C:\>setx PATH "%M2%;%PATH%"

Installation sous Linux

Etape1 : Décompresser le fichier  apache-maven-3.3.9-bin.tar.gz  vers le répertoire  /usr/local/apache-maven

#mkdir  /usr/local/apache-maven

#tar –xzf apache-maven-3.3.9-bin.tar.gz  /usr/local/apache-maven

Etape2 : Configurer  M2_HOME, M2 et MAVEN_OPTS et PATH :

• M2_HOME 

#export M2_HOME=/usr/local/apache-maven apache-maven-3.3.9

• M2

#export M2=$M2_HOME/bin

• MAVEN_OPTS

#export MAVEN_OPTS=-Xms512m –Xmx1025m

• PATH

#export PATH=$M2:$PATH

Installation sous Mac

Etape1 : Décompresser le fichier  apache-maven-3.3.9-bin.tar.gz  vers le répertoire  /usr/local/apache-maven

machine:~user$mkdir  /usr/local/apache-maven

machine:~user$tar –xzf apache-maven-3.3.9-bin.tar.gz /usr/local/apache-maven

Etape2 : Configurer  M2_HOME, M2 et MAVEN_OPTS et PATH :

• M2_HOME 

machine:~user$export M2_HOME=/usr/local/apache-maven apache-maven-3.3.9

• M2

machine:~user$export M2=$M2_HOME/bin

• MAVEN_OPTS

machine:~user$export MAVEN_OPTS=-Xms512m –Xmx1025m

• PATH

machine:~user$export PATH=$M2:$PATH

 Vérification de l’installation d’Apache Maven

Pour vérifier que Maven est bien installé sur votre système d’exploitation, nous lançons la commande  mvn –version :

• Dans l’invite de commandes Windows

C:\>mvn –version

• Sous un terminal Linux

$java –version

• Sous un terminal Mac

machine:~user$java –version

Comment créer un nouveau projet avec Maven ?

Dans cette partie, nous allons voir comment créer un nouveau projet avec Maven. La commande pour créer un projet est identique pour tous les systèmes d’exploitation mais dans notre document, nous choisissons l’environnement Windows.

Pour créer un projet avec Maven sous Windows nous suivons les étapes ci-dessous :

Etape1 : Créer un répertoire pour contenir le projet, mettons TestMaven comme nom.

C:\>md TestMaven

Etape2 : Se déplacer vers le répertoire nouvellement créé

C:\>cd TestMaven

Etape3 : Créer le projet sous Maven

C:\TestMaven>mvn archetype:generate

Remarque :

• archetype est un module complémentaire de Maven pour spécifier le type de projet et son structure.
• Si nous lançons la commande archetype:generate pour la première fois Maven télécharge les fichiers relatifs à archetype et les mettre dans le répertoire C:\Users\userName\.m2\repository

Etape4 : Choisir l’archetype correspondant à notre projet

Dans notre test nous allons créer un projet de type quickstart  qui correspond au nombre  7

Remarque :

• Ce numéro dépend de votre installation.

Etape5 : Définir le groupId de notre projet, c’est l’identité du responsable du projet.

Prenons  fortoLab.app comme groupId

Etape6 : Définir l’artifactId , c’est le nom de notre projet.

Nous allons créer un projet qui manipule les nombres complexe alors nous appellerons notre projet  Complexe.

Etape7 : Définir la version du projet

Pour la version, nous choisissons la nomenclature proposée par Maven: 1.0-SNAPSHOT

Etape8 : Définir le package.

Dans notre exemple mettons fortoLab.app.complexe

Etape9 : Accepter les paramètres en validant par Y

Après avoir effectué les paramétrages, Maven nous fait un résumé sur les informations concernant notre projet.

Résultat :

Figure  : Résumé sur le  projet « Complexe »

Notre projet ainsi créé, Maven génère tout les répertoires et fichiers pour notre projet dans le répertoire de travail.

En tapant la commande tree dans l’invite de commande nous aurons l’arborescence de notre projet.

C:\TestMaven>tree

Résultat:

Figure : Arborescence du projet « Complexe »

Compiler et tester un projet Maven

Cette partie du document nous montrera comment compiler et tester un projet mais tout d’abord créons nos codes.

Environnement de travail et codes

De nombreux éditeurs de code Java peuvent être utilisés avec Maven mais nous utilisons l’éditeur Eclipse.

Afin qu’Eclipse puisse charge le projet Maven, nous devons faire appel au module complémentaire eclipse . Pour se faire nous lançons la commande mvn eclipse :eclipse dans un invite de commande sous  le répertoire de notre projet.

C:\TestMaven>cd Complexe

C:\TestMaven\Complexe>mvn eclipse:eclipse

Résultat:

Figure : Résultat de l’installation du module eclipse.

Remarque :

• Deux fichiers .classpath et .project indispensables à eclipse sont créés dans le répertoire de notre projet.

Nos codes sont présentés ci-dessous :

Code : ComplexeMetier.java

package fortoLab.app.complexe;

public class ComplexeMetier {
 public double module(double re,double im){
 return Math.sqrt(Math.pow(re, 2)+Math.pow(im,2));
 }
 
 public double cosinus(double re,double im){
 return re/(Math.sqrt(Math.pow(re, 2)+Math.pow(im,2)));
 }
 
 public double sinus(double re,double im){
 return im/(Math.sqrt(Math.pow(re, 2)+Math.pow(im,2)));
 }
}

Code : ComplexeMetierTest.java

package fortoLab.app.complexe;

import junit.framework.TestCase;

public class ComplexeMetierTest extends TestCase {
 private ComplexeMetier metier;

 protected void setUp() throws Exception {
 super.setUp();
 metier = new ComplexeMetier();
 }
 public void testModule(){
 assertTrue(metier.module(1, 0)==1);
 }
 public void testCosinus(){
 assertTrue(metier.cosinus(1, 0)==1);
 }
 public void testsinus(){
 assertTrue(metier.sinus(0, 1)==1);
 }
}

Compilation du projet avec Maven

Comme nous venons de créer nos codes sources, nous avons besoin de compiler notre projet en utilisant la commande Maven : mvn compile

C:\TestMaven\Complexe>mvn compile

Résultat :

Figure : Résultat de la compilation de notre projet

Remarques:

• Si nous n’avons pas encore compilé un projet avec Maven, il télécharge vers notre répertoire de stockage le module complémentaire compile.
• Maven crée un répertoire nommé target  qui contiendra les classes compilées.

Test du projet avec Maven

Pour tester notre projet Maven a un module nommé test pour effectuer cette tâche. La commande est :

C:\TestMaven\Complexe>mvn test

Résultat :

Figure : Résultat du test unitaire avec Maven

Remarque:

• Comme dans la phase de compilation, si c’est le premier test, Maven télécharge le module complémentaire test.

Maven et  le Project Object Model (POM)

Project Object Model (POM) ou Modèle Objet de Projet est un concept de base et abstrait qui indique à Maven ce qu’il faut faire. POM est concrétisé par un fichier XML nommé pom.xml qui contient toutes les informations que Maven a besoin concernant un projet.

POM se divise en quatre grandes parties de description :

Informations de base 

Cette partie contient les identités du projet, la gestion des dépendances et les détails des héritages.

Elle est caractérisée par les balises :

• <groupId></groupId>

Informe sur le nom du groupe responsable du projet

• <artifactId></artifactId>

Donne le nom ou l’identité du projet.

• <version></version> 

Informe sur la version de l’application

• <packaging></packaging>

Définit le type de compression du projet, nous pouvons choisir entre jar et war

• <dependencies></dependencies>

Détermine les dépendances du projet

• <parent></parent>

Indique les informations l’héritage du projet

• <dependencyManagement></dependencyManagement>

Balise contenant les dépendances alternatives

• <modules></modules>

Informe sur les modules que  le projet a besoin

• <properties></properties>

Indique les propriétés du projet

Configuration de la production

• <build></build>

Spécifie comment produire le projet

• <reporting></reporting>

Spécifie le rapport que nous voulons générer pour le projet

Meta Données du projet

• <name></name>

Contient le nom explicite du projet

• <description></description>

Cette balise nous permet d’insérer une description du projet

• <url></url>

Encapsule l’URL du site web du projet

• <inceptionYear></inceptionYear>

Indique l’année du commencement du projet

• <licenses></licenses>

Informe sur le type de la licence

• <organization></organization>

Enferme le nom du propriétaire du projet

• <developers></developers>

Encapsule les informations sur les développeurs et contributeurs du projet

• <contributors></contributors>

Liste les informations sur contributeurs

 Environnement de la production

• <issueManagement></issueManagement>

Spécifie le moyen dont Maven gèrera les problèmes

• <ciManagement></ciManagement>

Contient les informations sur le CI server (Continuous Integration server)

• <mailingLists></mailingLists>

Liste des adresses électronique des contactes

• <scm></scm>

Indique les informations sur la gestion de la chaîne logistique

• <prerequisites></prerequisites>

Informe sur les besoins du projet

• <repositories></repositories>

Informe Maven sur l’emplacement des dépendances

• <pluginRepositories></pluginRepositories>

Informe Maven sur l’emplacement des modules complémentaires

Remarque :

Toutes ces balises ne sont pas forcement obligatoires. Nous les utilisons selon les besoins du projet.

Dans notre projet nommé Complexe le fichier pom.xml se présente comme suit :

<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/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>

 <groupId>fortoLab.app</groupId>
 <artifactId>Complexe</artifactId>
 <version>1.0-SNAPSHOT</version>
 <packaging>jar</packaging>

 <name>Complexe</name>
 <url>http://maven.apache.org</url>

 <properties>
 <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 </properties>

 <dependencies>
 <dependency>
 <groupId>junit</groupId>
 <artifactId>junit</artifactId>
 <version>3.8.1</version>
 <scope>test</scope>
 </dependency>
 </dependencies>
</project>

Interprétation :

• <groupId>fortoLab.app</groupId> : le groupe fortoLab est responsable du projet
• <artifactId>Complexe</artifactId> : le projet porte le nom de Complexe
• <version>1.0-SNAPSHOT</version> : Le projet est à la version 1.0
• <packaging>jar</packaging> : le projet sera compressé au format jar
• <name>Complexe</name> : Informe sur le nom explicite du projet
• <url>http://maven.apache.org</url>: URL par défaut du projet
• <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> : Indique le codage des textes, notre projet utilise le codage UTF-8
• <dependencies>…</dependencies> : Cette balise englobe les dépendances de notre projet. Dans notre projet, la phase de test a besoin de jUnit.

Maven et le cycle de vie des builds

Comme dans tout système de production, Maven respecte un cycle de vie bien harmonisé. Le cycle de vie de construction de projet Maven se décompose en trois cycles principaux : le cycle par défaut ou cycle de production, le cycle de nettoyage et le cycle site. Ces trois cycles se subdivisent à leur tour en plusieurs phases.

Le cycle de production

Ce cycle prend en main la compilation, le test et le déploiement d’un projet Maven. Il comporte en tout vingt phases mais nous citons ci-dessous les huit plus importantes :

• Validation

Nous vérifions si les paramètres et toutes les informations sont corrects.

• Compilation

Les codes sont convertis en bytecode Java.

• Test

Chaque unité compilée est testée avec un framework adéquat. Dans notre projet, nous avons utilisé JUnit

• Packaging

Les codes compilés sont encapsulés dans un fichier jar ou war ou ear; ce format est définie dans pom.xml.

• Test d’intégration

Le fichier précédemment généré est lancé dans un environnement de test d’intégration.

• Vérification

Cette phase consiste à vérifier si le projet répond aux attentes

• Installation

Maven fait la migration du fichier package validé dans le répertoire de dépôts local afin qu’il puisse être utilisé par d’autres projets.

• Déploiement

Maven partage le package final en le publiant vers un répertoire de dépôts commun.

Le cycle clean

Ce cycle est composé de trois phases dont l’objectif final est de supprimer automatiquement les fichiers générés par Maven durant la production si ceci est nécessaire.

Les trois phases sont :

• Pré-clean

Identification des éléments à retirer dans le projet avant la phase de nettoyage

• clean

Phase de suppression des fichiers identifiés durant la phase précédente

• Post-clean

Finalisation du nettoyage du projet.

Le cycle site

L’objectif de ce cycle est de générer une documentation, concernant un projet, consultable sur le web. Pour sa réalisation, le cycle site est constitué par les phases suivantes :

• Pré-site

Collecte de toutes les informations nécessaires pour construire les pages web.

• Site

Construction des pages web contenant les détails du projet.

• Post-site

Finalisation et vérification de la conformité des informations à publier sur le web.

• Déploiement

Intégration des pages web dans un server d’hébergement pour être consultables en ligne.

Remarque :

Les cycles clean et site ne sont pas obligatoires pour un projet Maven, leur application dépend uniquement du déroulement du projet et des besoins.

Maven et le Build Profile

Build Profiles sont des déclarations de basculement faites dans des fichiers de configuration de Maven.

L’objectif des ces spécifications est de garantir la portabilité d’un projet Maven.

Nous pouvons lister ci-dessous les différents types de profiles supportés par Maven 3.3 :

• Profile par Projet

Il est définit dans le fichier pom.xml

• Profile par Utilisateur

Il est intégré directement dans le fichier de configuration de Maven pour l’utilisateur, ce profil se trouve dans %USER_HOME%/.m2/settings.xml

• Profile Global

Ce profile est définit dans la configuration globale de Maven qui se trouve dans le fichier %M2_HOME%/conf/settings.xml

Nous pouvons basculer ou activer un profile par différents moyens :

• Explicitement en utilisant des commandes
  • Commandes pour activer les profile-1 et profile-2

mvn install -P profile-1,profile-2

• Commandes pour désactiver le profile-2

mvn install -P !profile-2

 

• A travers les configurations de Maven

Selon notre objectif, nous intégrons ces lignes de codes dans les fichiers  de configuration de Maven

Pour activer les profiles profile-1 et profile-2, nous ajoutons les codes suivants

<settings>
...
<activeProfiles>
<activeProfile>profile-1</activeProfile>
<activeProfile>profile-2</activeProfile>
</activeProfiles>
...
</settings>

• En se basant sur le variable d’environnement

Le basculement se fait à travers une spécification que nous déclarons entre la balise <activation>

L’exemple ci-dessous nous montre le basculement automatique entre les différentes distributions du JDK version 1.8 (JDK 8u5, JDK 8u11, JDK 8u20…)

<profiles>
<profile>
<activation>
<jdk>1.8</jdk>
</activation>
 ...
</profiles>

L’exemple suivant montre le basculement automatique entre les versions du JDK (JDK 1.5, JDK 1.6, JDK 1.7, JDK 1.8).

<profiles>
<profile>
<activation>
<jdk>[1.5,1.8]</jdk>
</activation>
 ...
</profiles>

• Par la configuration du système d’exploitation

Le code d’activation d’un profile en fonction du type de système d’exploitation est présenté dans l’exemple ci-dessous.

<profiles>
<profile>
<activation>
<os>
<name>Windows 7</name>
<family>Windows</family>
<arch>x64</arch>
<version>6.1.7600</version>
</os>
</activation>
...
</profile>
</profiles>

• Par l’absence de fichiers

Un profile peur être chargé si nous spécifions son activation par l’absence  d’un fichier spécifique.

Le code ci-dessous active un profile si la génération du fichier  C:\TestMaven\Complexe\.classpath échoue après le lancement de la commande mvn eclipse :eclipse

...

<profiles>
<profile>
<activation>
<file>
<missing>
C:\TestMaven\Complexe\.classpath
</missing>
</file>
</activation>
...
</profile>
</profiles>

Intégrations avec Maven

Actuellement de nombreux langages de programmation s’offrent aux développeurs dont la majorité est compatible avec le langage Java.

Pour faciliter les travails des développeurs, Maven intègre la plupart de ces langages sous forme de modules complémentaires.

Nous allons montrer comment intégrer le développement Scala, Groovy et Flex avec Maven et aussi la configuration des environnements de développement comme NetBeans et Eclipse.

Comment Intégrer le développement Scala avec Maven ?

Scala est langage de programmation multi-paradigme, extensible (« scalable » en anglais), compatibilité avec d’autres langages de programmation. Basé sur le langage Java, Scala hérite de ses bibliothèques, ses concepts et de sa machine virtuelle.

Actuellement, il est utilisé par la majorité des industries du développement de logiciels.

Maven offre un module complémentaire dédié pour Scala. Ainsi, nous n’avons pas besoins d’installer le langage Scala parce que Maven s’en chargera à notre place.

Dans la suite ce tutoriel, nous allons voir les configurations requise pour utiliser Scala, montrer comment intégrer  Scala dans un projet Maven.

Création d’un projet Scala avec Maven

Pour se faire nous devons générer un archetype projet Scala en utilisant la commande mvn archetype:generate

C:\TestMavent>mvn archetype:generate

Pour les paramètres du test de projet Scala nous allons mettre :

• archetype : scala-archetype-simple  

Dans notre système cet archetype correspond au numero 1432

• Version de l’archetype :

La version 1.0  correspond au nombre 1 alors nous mettons 1

• groupId : app
• artifactId : TestScala
• version : 0-SNAPSHOT
• package: app.testScala

Le projet ainsi créé, Maven nous donne un résumé

Figure : Résumé sur le projet « TestScala »

Nous utilisons la commande tree /F pour afficher l’arborescence et les fichiers créés par Maven pour notre projet testScala

C:\TestMaven>cd TestScala

C:\TestMaven\TestScala>tree /F

Résultat:

Figure : Arborescence du projet « TestScala »

Le fichier pom.xml de notre projet est configuré automatiquement par Maven pour charger le module complémentaire Scala pour le cycle de production.

Code : pom.xml

 <dependencies>
 <dependency>
 <groupId>org.scala-lang</groupId>
 <artifactId>scala-library</artifactId>
 <version>${scala.version}</version>
 </dependency>
 
 <build>
 <sourceDirectory>src/main/scala</sourceDirectory>
 <testSourceDirectory>src/test/scala</testSourceDirectory>
 <plugins>
 <plugin>
 <!-- see http://davidb.github.com/scala-maven-plugin -->
 <groupId>net.alchim31.maven</groupId>
 <artifactId>scala-maven-plugin</artifactId>
 <version>3.2.0</version>
 <executions>
 <execution>
 <goals>
 <goal>compile</goal>
 <goal>testCompile</goal>
 </goals>
 <configuration>
 <args>
 <arg>-make:transitive</arg>
 <arg>-dependencyfile</arg>
 <arg>${project.build.directory}/.scala_dependencies</arg>
 </args>
 </configuration>
 </execution>
 </executions>
 </plugin>
 ...
 </plugins>
 </build>
</project>

Pour tester notre projet, créons un code écrit en scala qui affiche « Bonjour ForToLab !».

Code : .App.scala

package fortoLab.app.testScala

/**
* @author FortoLab
*/
object App {
def foo(x : Array[String]) = x.foldLeft("")((a,b) => a + b)
def main(args : Array[String]) {
println( "Bonjour ForToLab !" )
println("concat arguments = " + foo(args))
}
}

Compilation du code Scala

Pour compiler notre code, nous utilisons la même commande vue auparavant.

C:\TestMaven\TestScala>mvn compile

Résultat :

Figure: Résultat de la compilation du projet TestScala

Test du projet TestScala

Pour lancer le test, nous lançons la commande suivante :

C:\TestMaven\ScalaTest>mvn test

Résultat :

Figure : Résultat du test Scala

Nous constatons bien que Maven gère facilement un projet en code Scala, mais toutefois, il existe des commandes qui viennent avec le module complémentaire Scala pour compiler, tester et lancer les bytecode  Scala :

• Pour compiler les codes sources Scala

C:\TestMaven\ScalaTest>mvn scala:compile

• Pour compiler les codes sources de test

C:\TestMaven\ScalaTest>mvn scala:testCompile

• Pour lancer l’exécution du test

C:\TestMaven\ScalaTest>mvn scala:run

 

D’autres commandes sont disponibles avec le module Scala mais nous mentionnons ci-dessous les plus fréquemment utilisées :

• Pour générer une documentation pour tous les codes sources Scala

C:\TestMaven\ScalaTest>mvn scala:doc

• Pour afficher l’aide sur le compilateur Scala

C:\TestMaven\ScalaTest>mvn scala:help

• Pour exécuter un script Scala

C:\TestMaven\ScalaTest>mvn scala:script

Intégration du développement Groovy avec Maven

Recommandations

Pour profiter pleinement les performances de Groovy avec Maven, il est conseillé d’installer la  Maven 3 et JDK7.

L’installation de Groovy sur votre poste de travail n’est pas nécessaire car c’est Maven qui gère le module complémentaire Groovy.

Création d’un projet Groovy avec Maven

Environnement de test

Déplaçons-nous vers le répertoire de test Maven

C:\>cd TestMaven

Génération du projet Groovy

Pour ce projet, nous choisissons l’archetype gmaven-archetype-basic version 1.0. Pour le groupId, artifactId, version et package nous mettons respectivement  fortoLab.app, TestGroovy, 1.0-SNAPSHOT et fortoLab.app.testGroovy.

Pour se faire, lançons la commande :

C:\TestMavent>mvn archetype:generate

Maven nous affiche le résumé ci-dessous.

Figure : Résumé sur la création du projet TestGroovy avec Maven

L’arborescence et les fichiers du projet TestGroovy sont présentés ci-dessous :

Figure : Présentation des fichiers du projet TestGroovy

Le module Groovy est bien intégré dans notre fichier pom.mxl, il est associé au cycle build de notre projet.

Code : pom.xml

...
<build>
<plugins>
<plugin>
<groupId>org.codehaus.groovy.maven</groupId>
<artifactId>gmaven-plugin</artifactId>
<version>1.0</version>
<executions>
<execution>
<goals>
<goal>generateStubs</goal>
<goal>compile</goal>
<goal>generateTestStubs</goal>
<goal>testCompile</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
...

Notre code Groovy se présente comme suit :

Code :Example.groovy

package fortoLab.app.testGroovy
class Example
{
def show() {
println 'Bonjour ForToLab !'
}
}

Compilation du projet

Pour la compilation des codes, nous lançons la commande mvn compile dans le répertoire du projet.

C:\TestMaven\TestGroovy>mvn compile

Résultat:

Figure : Etat de la Compilation de notre projet Groovy avec Maven

Test du projet Groovy avec Maven

En lançant la commande mvn test nous pouvons test si notre code fonctionne correctement.

C:\TestMaven\TestGroovy>mvn test

Résultat :

Figure : Résultat du test de notre code Groovy

Groovy offre une interface graphique pour nous aider à exécuter nos commandes groovy. Pour active l’interface graphique nous utilisons la commande mvn groovy :console

C:\TestMaven\TestGroovy>mvn groovy:console  

Une nouvelle fenêtre se  présente à l’utilisateur dont notre teste se déroule comme suit:

• Insertion de notre ligne de code dans la zone de saisie

println 'Bonjour ForToLab !'

• Test de notre script en suivant le menu

Script > Run

• Résultat :

 

Figure : Interface graphique de Groovy

Intégration du développement Flex avec Maven

Flex est un framework Open Source multi-plateforme, il permet de créer et de déployer des applications Internet riches en gardant une qualité d’affichage identique sur la majorité des navigateurs web et des systèmes d’exploitation. Maven propose un module complémentaire Flex pour gérer un projet de ce type.

Recommandations

Pour créer un projet Flex avec Maven, nous devons avoir ; de préférence, la version 3 de Maven et JDK 1.6 au minimum. Le Flex SDK est automatiquement inclus dans notre projet si c’est nécessaire.

Création d’un projet Flex avec Maven

Pour créer un projet Flex avec Maven, nous lançons la même commande mvn archtype:generate

Dans l’invite de commande Windows tapons les commandes suivantes :

C:\>cd TestMaven

C:\TestMavent>mvn archetype:generate

Pour ce projet, les parametres sont les suivants:

• archetype : flexmojos-archetypes-application

Cet archetype correspond au numero 574 1458

• Version de l’archetype :

Nous choisissons la version 7.1 de cet archetype qui correspond au nombre 6

• groupId : app
• artifactId : TestFlex
• version : 0-SNAPSHOT
• package: app.testFlex

La figure ci-dessous nous résume la création de notre projet Flex sous Maven

Figure : Résumé sur le projet Flex

Maven a créé l’arborescence du projet présentée ci-dessous :

Figure : Présentation des répertoires et fichiers du projet TestFlex

Nous constatons que notre projet contient une application  Flex nommée Main.xml  et un fichier de test nommé TestApp.as. Les codes de ces fichiers sont représentés ci-dessous :

Code : Main.xml

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute">
<mx:Text text="Bonjour ForToLab !"/>
</mx:Application>

Code :TestApp.as

package fortoLab.app.testFlex
{
import flexunit.framework.TestCase;
import Main;
public class TestApp extends TestCase
{
public function testNothing():void
{
trace("Bonjour ForToLab !");
}
}
}

Notre fichier pom.xml  déclare le module Flex de la manière suivante :

Code : pom.xml

...
<build>
...
<plugins>
<plugin>
<groupId>org.sonatype.flexmojos</groupId>
<artifactId>flexmojos-maven-plugin</artifactId>
<version>3.8</version>
<extensions>true</extensions>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>com.adobe.flex.framework</groupId>
<artifactId>flex-framework</artifactId>
<version>3.2.0.3958</version>
<type>pom</type>
</dependency>
<dependency>
<groupId>com.adobe.flexunit</groupId>
<artifactId>flexunit</artifactId>
<version>0.85</version>
<type>swc</type>
<scope>test</scope>
</dependency>
</dependencies>

Compilation du projet TestFlex

Procédons maintenant à la compilation de notre projet, nous utilisons la commande habituelle mvn compile sous une invite de commande dans le répertoire du projet :

C:\TestMavent>cd TestFlex

C:\TestMavent\TestFlex>mvn compile

Test projet Flex avec Maven

Pour les tests unitaires, nous utilisons la commande :

 C:\TestMavent\TestFlex>mvn test

Autres commandes Flex dans Maven

Le module complémentaire Flex offre des commandes utiles pour notre projet, nous les listons ci-dessous :

• Pour générer une documentation pour les fichiers ActionScript

C:\TestMaven\TestFlex>mvn flexomojos:asdoc

• Pour générer une documentation pour les fichiers ActionScript pour être intégrer dans le site Maven

 C:\TestMaven\TestFlex>mvn flexomojos:asdoc-report

• Pour compiler les fichier MXML et AS en un SWC

C:\TestMaven\TestFlex>mvn flexomojos:compile-swc

• Pour créer un fichier JAR contenant tous les codes

C:\TestMaven\TestFlex>mvn flexomojos:sources

• Pour générer des classes AS en se basant sur les classes Java

C:\TestMaven\TestFlex>mvn flexomojos:generate

• Pour copier mes ressources Flex vers un projet d’application web

C:\TestMaven\TestFlex>mvn flexomojos:copy-flex-resources

Intégration Maven dans NetBeans

NetBeans est l’un des environnements de développement les plus populaires dans l’univers des développeurs Java.

NetBeans est un environnement de développement intégré libre et gratuit maintenu par la communauté NetBeans et supporté par Sun/Oracle.

Le module Maven peut être pré-intégré dans NetBeans ou peut être installé  après.

Préparation de l’environnement

Pour utiliser Maven avec NetBeans, il est recommandé de télécharger et d’installer NetBeans version 7 sur : http://netbeans.org/downloads/index.html

Configuration de NetBeans

Pour configurer l’emplacement principal de Maven, nous allons dans Tools > Options > Java > Maven

Figure : Configuration de Maven dans NetBeans

Création de projet Maven sous NetBeans

Pour lancer un nouveau projet Maven sous NetBeans, nous lançons la fenêtre de création de projet New Project en allant dans le menu : File > New Project et nous sélectionnons Maven puis Java Project.

Figure: Création d’un projet Maven sous NetBeans

Commandes Maven sous NetBeans

NetBeans intègre dans son environnement le cycle de construction de projet de Maven et nous offre toute une panoplie d’options pour gérer nos projets. Les options proposées se trouvent sous les menus Run et Debug.

Figure : Les sous menus de Run

Figure : Les sous menus de Debug

Pour créer une commande Maven personnalisée sous NetBeans, nous faisons un clic-droit  sur notre projet et sélectionner Custom > Goals et après nous définissons les paramètres nécessaires.

Figure: Création d’une commande personnalisée Maven

Intégration de Maven sous Eclipse

Dans cette partie, nous allons parler de l’incontournable Eclipse. C’est un environnement de développement  gratuit et libre. Il supporte le langage Java et d’autres technologies.

Eclipse est plus qu’un environnement de développement intégré, c’est aussi une plateforme extensible par l’intégration de greffons et de modules complémentaires.

Développé par Sonatype,  le module complémentaire M2Eclipse est intégré à Eclipse pour le permettre d’interagir avec Maven.

Préparation

Pour commencer, nous avons besoin de télécharger et installer Eclipse 4.5 depuis le site  web d’Eclipse : http://www.eclipse.org/downloads/

Vérification de la configuration 

Avant d’utiliser Maven avec Eclipse, il faut bien vérifier que Maven est configuré dans Eclipse. Pour se faire, nous allons dans le menu : Windows > Preferences > Maven > Installations

Figure : Configuration de Maven dans Eclipse.

Création d’un projet Maven

Pour créer un projet Maven avec Eclipse, nous suivons le menu : File > New > Maven Project

Après, nous complétons les informations nécessaires pour notre projet.

Figure: Sélection d’un archetype sous  Eclipse

Figure: Insertion des informations concernant le projet sous Eclipse.

En cliquant sur « Finish », un nouveau projet Maven est créé sous Eclipse dont l’arborescence est présentée  ci-dessous.

Figure : Structure de répertoires et de fichiers du projet Maven créé sous Eclipse.

Commandes Maven sous Eclipse

Pour utiliser les commandes Maven dans Eclipse, nous allons dans le menu :

Run > Run Configurations…

Nous sectionnons Maven Build et nous créons une nouvelle configuration en double cliquant sur Maven Build.

Figure : Création d’une commande compile sous Eclipse.

Nous pouvons créer ainsi toutes les commandes Maven sous Eclipse.

J’espère que ce tutoriel d’initiation à Maven vous a été utile, si vous avez des questions ou des remarques, n’hésitez pas à poster vos commentaires.