• 20 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 12/12/2019

Créez votre premier projet Maven

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Votre environnement de développement est prêt ? Alors, je vais vous montrer comment créer votre premier projet avec Apache Maven.

Maven utilise une approche dite « convention over configuration » (ou convention plutôt que configuration en français). Cela signifie que Maven a établi un certain nombre de conventions et que si vous les respectez, beaucoup de choses seront automatiques. Vous n'aurez donc que très peu de configuration à faire !

Une des premières conventions concerne l'arborescence d'un projet Maven. Celle-ci étant fixée (cf. documentation), Maven vous permet de générer un squelette de votre projet. C'est ce que je vais vous montrer tout de suite.

Générer un squelette de projet Maven

Afin de générer le squelette d'un projet, Maven s'appuie sur des archétypes (ce sont des sortes de modèles). Ici, je vais tout simplement demander à Maven de me générer un squelette à partir de l'archétype quickstart.

Voici comment générer le squelette en mode console :

  1. Ouvrez un terminal (ou une console) et placez-vous dans le répertoire où vous voulez créer le projet (Maven y créera un sous-répertoire pour votre nouveau projet).

    cd /chemin/vers/repertoire/projet
  2. Lancez la génération à partir de l'archétype :

    mvn archetype:generate -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.1
  3. Maven va vous poser des questions afin de personnaliser la génération de votre projet :

    • groupId : org.exemple.demo

    • artifactId : mon-appli

    • version (1.0-SNAPSHOT) : laissez vide

    • package (org.exemple.demo) : laissez vide

  4. Ensuite Maven vous demande de confirmer les paramètres, il vous suffit donc de presser la touche Entrée.

  5. Maven crée le squelette du projet : vous devriez voir un résultat comme celui-ci :

    [INFO] ------------------------------------------------------------------------
    [INFO] BUILD SUCCESS
    [INFO] ------------------------------------------------------------------------
    [INFO] Total time: 28.944 s
    [INFO] Finished at: 2017-06-12T17:26:46+02:00
    [INFO] Final Memory: 19M/308M
    [INFO] ------------------------------------------------------------------------

Qu'est-ce qui a été généré ?

Maven a créé le répertoire mon-appli (valeur de l'artifactId saisie plus tôt) et y a généré l'arborescence suivante :

🗁 mon-appli
├── 🗎 pom.xml
└── 🗁 src
├── 🗁 main
│ └── 🗁 java
│ └── 🗁 org
│ └── 🗁 exemple
│ └── 🗁 demo
│ └── 🗎 App.java
└── 🗁 test
└── 🗁 java
└── 🗁 org
└── 🗁 exemple
└── 🗁 demo
└── 🗎 AppTest.java

J'ai ainsi obtenu :

  • un fichier pom.xml à la racine de mon projet. C'est le fichier de description/configuration du projet Maven.

  • un répertoire src/main/java. C'est le répertoire contenant les sources de mon application, contenant pour l'instant un unique fichier App.java situé dans le package org.exemple.demo.

  • un répertoire src/test/java. C'est le répertoire contenant les sources des tests JUnit de mon application, contenant pour le moment un unique fichier AppTest.java situé dans le package org.exemple.demo.

Dans le fichier pom.xml, vous retrouverez les paramètres saisis lors de la génération (groupId, artifactId, version) :

<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>org.exemple.demo</groupId>
<artifactId>mon-appli</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>mon-appli</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>

Vous remarquez également que l'application a une dépendance en « test » vers JUnit version 3.8.1. Nous y reviendrons plus loin dans ce cours.

Le fichier App.java, quant à lui, n'est qu'un simple Hello world :

package org.exemple.demo;
/**
* Hello world!
*
*/
public class App
{
public static void main( String[] args )
{
System.out.println( "Hello World!" );
}
}

Construisez votre nouveau projet

Même si ce n'est qu'un « hello world », votre projet semble être une application valide. Vous allez donc pouvoir le compiler… enfin, vous allez pouvoir laisser Maven le compiler pour vous !

Ouvrez une console à la racine du projet (répertoire mon-appli), là où se trouve le fichier pom.xml :

mvn package

Attendez un peu et... tada ! Vous avez un JAR de votre application : target/mon-appli-1.0-SNAPSHOT.jar !

Mais Maven n'a pas fait que générer un JAR. Regardez la sortie affichée sur la console, vous devriez avoir quelque chose comme ceci :

[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building mon-appli 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ mon-appli ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] skip non existing resourceDirectory /projets/mon-appli/src/main/resources
[INFO]
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ mon-appli ---
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 1 source file to /projets/mon-appli/target/classes
[INFO]
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ mon-appli ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] skip non existing resourceDirectory /projets/mon-appli/src/test/resources
[INFO]
[INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ mon-appli ---
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 1 source file to /projets/mon-appli/target/test-classes
[INFO]
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ mon-appli ---
[INFO] Surefire report directory: /projets/mon-appli/target/surefire-reports
-------------------------------------------------------
T E S T S
-------------------------------------------------------
Running org.exemple.demo.AppTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.005 sec
Results :
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO]
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ mon-appli ---
[INFO] Building jar: /projets/mon-appli/target/mon-appli-1.0-SNAPSHOT.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 1.307 s
[INFO] Finished at: 2017-06-12T18:50:44+02:00
[INFO] Final Memory: 16M/209M
[INFO] ------------------------------------------------------------------------

En effet, Maven a :

  • copié les ressources de l'application (j'y reviendrai plus tard)

  • compilé les sources de l'application

  • compilé les sources des tests

  • exécuté les tests sur l'application (1 test exécuté, aucune erreur)

  • généré un JAR de l'application

Pas mal, hein !? ;)

Vous pouvez lancer votre application Java flambant neuve :

java -cp target/mon-appli-1.0-SNAPSHOT.jar org.exemple.demo.App

Ce qui devrait vous afficher un magnifique :

Hello World!

Résumons

Dans ce chapitre, j'ai survolé rapidement la gestion de projet Java avec Apache Maven.

Voici les choses importantes à retenir :

  • Maven utilise une approche « convention over configuration » (ou convention plutôt que configuration en français).

  • L'arborescence d'un projet Maven est fixée par convention. Elle comporte :

    • un fichier pom.xml à la racine qui sert à décrire et configurer le projet Maven ;

    • un répertoire src/main/java contenant les sources de l'application ;

    • un répertoire src/test/java contenant les sources des tests JUnit de l'application.

  • Pour créer un nouveau projet Maven, vous pouvez générer l'arborescence en utilisant un archétype grâce à la commande mvn archetype:generate.

  • Compilez votre projet, exécutez les tests et construisez un JAR de votre application en une seule commande : mvn package. Si la compilation et tous les tests passent sans encombre, un fichier target/<artifactId>-<version>.<packaging> est généré (soit target/mon-appli-1.0-SNAPSHOT.jar dans mon exemple).

Dans les chapitres suivants, je vais entrer plus dans le détail du fonctionnement et de la configuration de Maven.

Exemple de certificat de réussite
Exemple de certificat de réussite