Sommaire
- 1 Généralités sur Apache Maven
- 2 Prise en main et installation de Maven
- 3 Comment créer un nouveau projet avec Maven ?
- 4 Compiler et tester un projet Maven
- 5 Maven et le Project Object Model (POM)
- 6 Maven et le cycle de vie des builds
- 7 Maven et le Build Profile
- 8 Intégrations avec 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.