MAVEN

Bureau E204

PLAN DU COURS

– Fonctionnalités Maven – Installation Maven – Premier Projet Maven – Arborescence du projet – Etapes de construction du projet – Gestion et portée des dépendances – Dépôts Maven – TP : Projet avec Maven (JAR) – TP : Projet Web Avec Maven (WAR)

Fonctionnalités MAVEN

Maven est un outil pour le management et l’automatisation de production des projets (construction des projets) développé par la fondation Apache permettant :

 L’intégration continue  La gestion des dépendances locales et distantes dans le Modèle

de projet basé sur des conventions (POM)

 Automatiser la gestion des builds et la génération des livrables  Automatisation de tâches récurrentes  Le lancement des tests

INSTALLATION DE MAVEN

• Maven peut être installé :

 En mode standalone Exemple: Utiliser Maven dans l’intégration continue (domaine DevOps)

 En tant que plugin Par défaut, STS intègre un plugin Maven

INSTALLATION DE MAVEN

• En mode plugin :

PREMIER PROJET MAVEN

Un projet est caractérisé par : • project : Balise racine de tous les fichiers pom.xml. • modelVersion : Version de POM utilisée. • groupId : Identifier un groupe qui a créé le projet. Ex:

org.apache.

• artifactId : Nom unique utilisé pour nommer l’artifact à

construire.

• packaging : Type de packaging du projet ( ex. : JAR,

WAR, EAR...).

• archetype : Template de Projet. • name : Nom du projet. • description : Description du projet.

Gestion des versions du projet

Exercice

Soit les versions du projet suivantes : 1.0 1.1.1 2.0 2.1 3.0

A quoi correspond chaque numérotation ?

Release Modification majeure Modification mineure

ARBORESCENCE DU PROJET

• Maven est basé sur la notion de convention over configuration (arborescence prédéfinie) ce qui le différencie par rapport à ses concurrents (Gradle, Ant) où une configuration supplémentaire est requise.

ARBORESCENCE DU PROJET

• pom.xml : le fichier de configuration du projet • /src : code source et fichiers source principaux • /src/main/java : code source java • /src/main/resources : fichiers de ressources (images, fichiers

config...)

• /src/main/webapp : webapp du projet • /src/test : fichiers de test • /src/test/java : code source Java de test • /src/test/resources : fichiers de ressources de test • /target : fichiers résultat, les binaires (du code et des tests), les

packages générés et les résultats des tests

Fichier POM.XML

 Permet de spécifier les dépendances dont le projet a besoin.  Spécifie l’emplacement de l’artifact du projet (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>com.esprit.spring</groupId> <artifactId>tpMaven</artifactId> <version>1.0</version> <name>tpMaven</name> <description>tpMaven</description> <dependencies><dependency> <groupId>org.apache.logging.log4j</groupId> <artifactId>log4j-core</artifactId> <version>2.14.0</version> </dependency></dependencies> </project>

COMMANDES MAVEN

• En faisant un click droit sur votre projet Maven, tu auras les commandes

suivantes:

• Par exemple, en cliquant sur Maven Install, un ensemble d’étapes de

construction du projet vont s’exécuter les unes après les autres et ceci va mettre à jour votre Repository local avec l’ensemble des livrables et dépendances nécessaires pour le bon fonctionnement du projet.

Etapes de construction du projet

Un cycle de vie est constitué de phases consécutives aboutissant à la création de l’artifact de notre projet (jar, war, etc..)

Etapes de construction du projet

• mvn compile : Créer les .class

• mvn test : Jouer les tests unitaires

• mvn package : Création du livrable dans target.

• mvn install : Copie du livrable dans le Repository local :

~\.m2\repository\...

• mvn deploy : Copie du livrable sur le repository distant

• mvn clean : Supprime le contenu du dossier target.

Etapes de construction du projet

• Emplacement du livrable :

{emplacement Repository}/groupId/artifactId/version

• Nom du package (jar en général) : {artifactId}-{version}.{package}

Gestion et portée des dépendances

Pour ajouter une dépendance, il suffit de chercher la dépendance en question dans le mvnRepository (https://mvnrepository.com/) et l’inclure dans le pom.xml sous la balise <dependencies> comme suit :

<dependencies> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.23</version> </dependency> </dependencies>

Gestion et portée des dépendances

<dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.13</version> <scope>test</scope> </dependency>

Le scope precise la portée de la dépendance : compile : par default, disponible dans tous les classpath provided : disponible seulement pour le classpath de compilation runtime : disponible pour l’exécution (runtime et test classpaths) test :disponible seulement lors du lancement des tests ( test classpath)

Gestion et portée des dépendances

Dépôts Maven

• Maven s’appuie sur les dépôts ( repositories) pour stocker les jars des

dépendances et des livrables.

• Ce dépôt peut être :  Distant : que ce soit le dépôt public Maven accessible via

https://mvnrepository.com/ ou privée (dépôt spécifique à la société)

 Local : Le dépôt local se trouve par défaut sous l’arborescence

%path_dossier_M2%\repository

 Privé : dans les serveurs dédiés à l’entreprise ( pour des raisons de

sécurité)

• Les dépôts sont organisés en groupes, artefacts et versions

Multi projets Maven (Optionnel)

Avec Maven, il est possible d’avoir un projet composé de sous projets en respectant une architecture arboresente

Module Enfant

pom Module Enfant : hérite les propriétés du pom parent et spécifie les besoins propres à ce module

Module Parent

TP1 – Projet avec Maven (JAR)

• Créer un Projet Maven :

• Simple : sans archetype, type Jar, groupId : tn.esprit • artefactId / nom / description : tpMavenWithJar • package : tn.esprit

• Mettre à jour le pom.xml pour utiliser Java 1.8 • Créer le package : tn.esprit • Créer la Classe : RepositoryLocation (Voir Code Source pages suivantes). • Créer le livrable avec Maven • Exécuter la méthode main.

TP1 – Projet avec Maven (JAR)

package tn.esprit; import java.io.File;

public class RepositoryLocation {

public static void main(String[] args) { File file = new File("C:\\Users\\nameUser\\.m2\\repository\\tn\\esprit\\1.0"); String absolutePath = file.getAbsolutePath(); String filePath =absolutePath.substring(0,absolutePath.indexOf(File.separator,

30));

System.out.println("Le dossier contenant les dépendances " + "et les livrables des projets est : "); System.out.println( filePath); } }

TP1 – Projet avec Maven (JAR)

<project …… <modelVersion>4.0.0</modelVersion> <groupId>tn.esprit</groupId> <artifactId>tpMavenWithJar</artifactId> <version>1.0</version> <name>tpMavenWithJar</name> <description>tpMavenWithJar</description> <properties> <maven.compiler.source>1.8</maven.compiler.source> <maven.compiler.target>1.8</maven.compiler.target> <maven-jar-plugin.version>3.1.1</maven-jar-plugin.version> </properties> </project>