IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Utiliser Maven 2

Date de publication : 04/08/2008 , Date de mise à jour : 04/08/2008


14. Projets modulaires
14.1. Définition
14.2. Utilisation
14.3. Intérêts et développements


14. Projets modulaires

Dans les projets Web, il est très souvent intéressant de séparer le code middle du projet de la couche de présentation. Cela permet notamment de localiser le middle dans un jar que l'on pourra réutiliser dans le site Web mais aussi dans les batchs, les Web Services etc...

Les projets modulaires dans Maven permettent de déclarer un méta-projet qui correspond au regroupement de plusieurs sous-projets Maven.


14.1. Définition

Pour créer un projet multi-modules, le principe est de créer plusieurs projets Maven dans un même sous répertoire. A la racine de ce répertoire, il faut ajouter un fichier pom.xml qui va référencer les sous projets.
Structure des fichiers pour un projet modulaire

	+- project/
	   +- pom.xml
	   +- sub-project1/
	   |  +-pom.xml
	   +- sub-project2/
	   |  +-pom.xml
	   +- sub-project3/
	      +-pom.xml
				
Le méta projet n'est pas obligatoirement placé à la racine des sous projets. C'est tout de même préférable notamment pour la gestion des releases.

Pour référencer les sous-projets, le méta-projet devra ressembler à ça :
pom.xml pour le méta projet

	<project ...>
		<modelVersion>4.0.0</modelVersion>
		<groupId>...</groupId>
		<artifactId>...</artifactId>
		<packaging>pom</packaging>
	
		<modules>
			<module>sub-project1</module>
			<module>sub-project2</module>
		</modules>
	</project>
				
Attention pour travailler ensemble, les sous modules doivent gérer leurs dépendances eux même. Par exemple, si les deux sous projets sont monProjetMiddle et monProjetFront, il sera toujours necessaire de définir monProjetMiddle comme dépendance de monProjetFront.

Ce n'est pas parce que plusieurs projets sont référencés dans le même méta-projet qu'ils se connaissent les uns les autres.


14.2. Utilisation

Maven propose étonnament peu de fonctionnalités qui se basent directement sur le mécanisme des modules. La seule fonctionnalité directe est le "reactor".

Le "reactor" est le mecanisme qui fait que lorsqu'on lance un goal sur un méta-projet, ce goal va d'abord être lancé successivement sur tous les sous-projets. Le "reactor" prendra garde à analyser les dépendances entre les différents modules pour les compiler dans le bon ordre.
Exemple d'exécution sur un projet modulaire

	...
	[INFO] ------------------------------------------------------------------------
	[INFO] Reactor Summary:
	[INFO] ------------------------------------------------------------------------
	[INFO] sub project 1 .......................................... SUCCESS [12.892s]
	[INFO] sub project 2 .......................................... SUCCESS [15.000s]
	[INFO] sub project 3 .......................................... SUCCESS [0.313s]
	...
	[INFO] ------------------------------------------------------------------------
	[INFO] BUILD SUCCESSFUL
	[INFO] ------------------------------------------------------------------------
	[INFO] Total time: 1 minute 32 seconds
	[INFO] Finished at: Tue Jul 08 17:19:38 CEST 2008
	[INFO] Final Memory: 15M/33M
	[INFO] ------------------------------------------------------------------------
				
Dans la définition des goals Maven, il est possible de traiter le fait de s'exécuter ou non dans le cadre d'un projet multi-module. Il est donc possible de trouver des plugins Maven qui ont un comportement particulier pour les projets multi-modules, c'est le cas notamment pour le plugin Maven pour Lutèce.


14.3. Intérêts et développements

On l'a vu, Maven propose peu de fonctionnalités directement liées aux modules, pourtant l'utilisation en est de plus en plus importante.

En effet l'un des intérêts majeur de Maven est sa gestion fine des dépendances. Il est de plus en plus souvent intéressant de profiter de cette gestion au sein même d'un projet.

Comme on l'a vu, dans un projet Web, on va rapidement extraire le middle dans un projet à part afin de pouvoir en dépendre depuis plusieurs projets différents.

Dans les grands frameworks, ce besoin est encore plus évident : pour les projets volumineux comme Spring, cela permet de ne pas avoir tout en dépendance. Par exemple, si l'on n'utilise pas la fonctionnalité de connexion au LDAP de Spring, il n'est pas nécessaire de dépendre de l'artefact spring-ldap ni des dépendances nécessaires à la connexion LDAP etc...

Spring est aujourd'hui découpé en plus de 40 modules, Hibernate, Tapestry, Struts sont déjà tous des projets Maven modulaires...

 

Valid XHTML 1.1!Valid CSS!

Les sources présentés sur cette pages sont libre de droits, et vous pouvez les utiliser à votre convenance. Par contre cette page de présentation de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright Matthieu Lux . Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérets.