Discussion :

[Palmer]

Bonjour tout le monde,

J'ai un projet contenant plusieurs répertoires sources :
source/A
source/B

J'aimerais compiler source/A séparément de source/B de facon à obtenir :
target/A
target/B

Je sais qu'il y a le plugin Build-Helper pour ajouter des SourceDirectory, mais alors je n'obtiens plus mes .classes dans les bons répertoires (plus q'un seul dossier target commun). C'est une chose que je veux éviter.

J'ai essayé de chipoter avec la configuration du plugin compiler, lui passer des arguments, etc.. Mais ca ne marche pas vraimment.

Quelqu'un aurait il une idée pour parvenir à un résultat pareil ? Sachant que je ne souhaite PAS splitter mon projet en 2 sous modules.

[dvicente72]

je ne pense pas que tu vas pouvoir avoir le choix.

Il semble bien qu'il vaut meiux que tu géres tes 2 projets comme module d'un projet plus global

[evenisse]

Juste une petite question, pourquoi veux-tu 2 répertoires de compilation?

[Palmer]

Il semble bien qu'il vaut meiux que tu géres tes 2 projets comme module d'un projet plus global

En fait les 2 répertoires sources font parties d'un Projet, Module Maven. Et ce projet, + d'autres de la même structure forment mon projet en global.



Le pourquoi est difficile à dire, la raison principale est que je dois migrer un projet de Ant vers Maven. Une raison est que chaque dossier source produit un jar.
Je pense donc que je vais devoir me résigner à splitter mon module en sous modules.

Ce qui fait que j'aurai une architecture du type (Exemple):

Myproject (pkg.pom)
+-Web(pkg. pom)
| +source/A (pkg. jar)
| +source/B (pkg. jar)
+Client(pkg. pom)
| +source/A (pkg. jar)
| +source/B (pkg. jar)
+Lib(pkg. pom)
| +source/A (pkg. jar)
| +source/B (pkg. jar)
_

MyProject aurait donc comme modules: Web, Client, et Lib. Et ceux-ci auront comme module chaque fois les 2 répertoires sources.
De plus tous les modules de MyProject héritent de ce dernier, et pareil pour les modules "sources".
Il y aurait donc un héritage "grand parent". Cela ne pose pas trop de problème sauf 2:

*quand j'ai une telle architecture en cascade (Modules ET parents), il est impossible d'exécuter une commande depuis un module parent(ex:Web). En effet il ne trouve pas le module MyProject.
Cela devient possible lorsque je n'ai plus d'héritage "Grand Parent". C'est un Bug ?

*Dans le cas où Client est dépendant de Lib, Y a t'il un moyen de simplifier la déclaration des dépendances? Pour le moment j'indique dans source/A et source/B les dependency vers Lib:source/A et Lib:source/B. La seule possibilité pour simplifer que j'ai trouvé est de noter les dépendances dans le module Client une et une seule fois.
Y a t'il moyen d'indiquer une dépendance uniquement vers le module Lib, de manière à ce qu'il comprend directement les sous modules de Lib?

Autre remarque, avec une telle architeture, je suis obligé de rajouter encore un module enfant (responsable des testJunits) accompagnant les modules dit "sources".

Merci!

[Palmer]

Encore une petite question qui va de paire avec l'architecture citées ci-dessus. Imaginons que je souhaite deployer mon projet Web sur un serveur d'application. J'avais pensé à écrire toutes les actions dans le pom du Projet Web. Cependant ce pom s'execute avant ses différents sous-modules. Or l'action du deploy doit être faite APRES l'exécution de ses sous-modules.

Une solution consisterait donc à ajouter un module spplémentaire qui va exécuter toutes ses actions.
Par la suite on pourrait encore imaginer declarer ce module dans les le pom du MyProject combiné avec des Profiles. Afin de ne pas effectuer un deploy à chaque fois.

Est ce que la solution que je propose suite l'optique de Maven2, où faut il s'y prendre autrement ?

ps : personellement, je trouve absurde de creer un module juste pour effectuer le depoy. Car si pour chaque action on doit créer des modules différents, le projet devient très difficile à gêrer.

Merci encore..

[evenisse]

Tu as 2 wars (un pour A et un pour B), exact? dans ce cas le déploiement dans ce faire dans chaque module.

[Palmer]

Mon exemple est peut être mal choisi. Ce que je cherche à savoir, c'est où il faudrait placer une action qui va s'exécuter sur les 2 sous modules. En sachant que ces modules doivent être construit à l'avance.

Par exemple : source/a et source/b produisent des Jar. J'aimerais produire un War qui contient ces 2 jars. La seule solution que je vois est de creer un module spécifique pour la création de ce War. (J'espere que l'exemple est mieux choisi).

Je pense qu'il faut faire de même avec la création d'un Ear. (Ajouter un module juste pour la création d'un Ear. )Je me trompe ?

Sinon, quelqu'un aurait il une idée pour mes 2 problèmes dans mon 2eme message ?

Merci.

[evenisse]

Pour la création d'un war (EAR), tu dois créer un nouveau module ayant pour packaging 'war' (ear).
C'est un règle de base de maven, le packaging par défaut est jar, mais tu dois le changer pour les autres types de modules (war, ear, ejb, rar, sar), ainsi maven sait quel est le cycle de vie à utiliser (liste des plugins à exécuter et dans quel ordre).
Quand un projet ne produit rien, par exemple un pom parent, il doit avoir un packaging 'pom'.

Tu devrais lire le livre "Better Build With Maven"

*quand j'ai une telle architecture en cascade (Modules ET parents), il est impossible d'exécuter une commande depuis un module parent(ex:Web). En effet il ne trouve pas le module MyProject.
Cela devient possible lorsque je n'ai plus d'héritage "Grand Parent". C'est un Bug ?

Quel est ta version de maven? à tu défini le packaging pom pour les parent?
L'héritage fonctionne très bien. J'ai des projets avec plus de 6 niveaux.

*Dans le cas où Client est dépendant de Lib, Y a t'il un moyen de simplifier la déclaration des dépendances? Pour le moment j'indique dans source/A et source/B les dependency vers Lib:source/A et Lib:source/B. La seule possibilité pour simplifer que j'ai trouvé est de noter les dépendances dans le module Client une et une seule fois.
Y a t'il moyen d'indiquer une dépendance uniquement vers le module Lib, de manière à ce qu'il comprend directement les sous modules de Lib?

Quand une dépendance doit être utilisé dans tous les sous-modules, tu peux la déclarer dans le pom parent, elle est héritée. Tu peux utiliser aussi le mécanisme de dependencyManagement qui te permet de déclarer la version dans un pom parent et dans les sous module, tu ne déclares que le groupId/artifactId de la dépendance. Ainsi, tu utiliseras la dépendance que tu as besoin seulement là où tu la veux.

[Palmer]

Bonsoir,

J'ai la version 2.0.5 de Maven.
Lorsque j'ai une architecture suivante :
A(Pom)->B(Pom)->C(Jar)
Je peux executer les commandes depuis le module A, C.
Lorsque j'essaye depuis B, cela ne fonctionne pas. Il ne trouve pas le pom Parent. (A)

sachant que : C hérite de B, et B hérite de A. et que :
C est module de B, et B module de A.


Dans le cas où j'empeche C d'hériter de B, je peux exécuter les commandes depuis B, et le parent (A) est bien trouvé!

On dirait donc qu'il y a un problème lorsque l'héritage dépasse 2 niveaux...

[evenisse]

Quelle commande lances-tu sur chaque projet?
Puis-je voir tes POMs?

[Palmer]

Voici le projet de test que j'avait construit pour essayer de comprendre le probleme:


Pom Grand Parent:

Code xml :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
<project>
	<modelVersion>4.0.0</modelVersion>
 
	<groupId>org.inpres</groupId>
	<artifactId>root</artifactId>
	<version>1.0-SNAPSHOT</version>
	<packaging>pom</packaging>
 
	<name>ROOT</name>
 
	<modules>
		<module>test-client</module>
	</modules>
<project>

Pom parent :

Code xml :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
<project>
	<modelVersion>4.0.0</modelVersion>
 
	<parent>
		<groupId>org.inpres</groupId>
		<artifactId>root</artifactId>
		<version>1.0-SNAPSHOT</version>
	</parent>
 
	<name>test-client</name>
	<artifactId>test-client</artifactId>
 
	<packaging>pom</packaging>
 
	<modules>
		<module>source/runtime</module>
	</modules>
</project>

Pom Enfant :

Code xml :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
<project>
	<modelVersion>4.0.0</modelVersion>
 
	<parent>
		<groupId>org.inpres</groupId>
  		<artifactId>test-client</artifactId>
  		<version>1.0-SNAPSHOT</version>
		<relativePath>../../</relativePath>
  	</parent>
 
  	<artifactId>test-client_source/A</artifactId>
  	<name>test-client_source/A</name>
 
  	<packaging>jar</packaging>
</project>

Lorsque j'essaye d'executer la commande :
mvn compile
depuis le pom parent, il ne trouve pas le pom org.inpres:root:pom:1.0

Pour que cela fonctionne, je suis obligé d'installer ce pom dans le repository local.

A noter que je peux executer n'importe quelle commande un niveaux plus haut ou plus bas, il n'y pas de problèmes. Cependant, impossible de faire quoi que ce soit à partir du niveau intermédiaire.

Merci pour ton aide.

[evenisse]

quel est ton arborescencence pour ces projets?

1. si tes projets sont en cours de développement, les versions doivent se terminer par -SNAPSHOT, donc 1.0-SNAPSHOT
2. je penses que le relativePath défini dans le POM enfant n'est pas bon.

[Palmer]

1. J'ai corrigé, et rajouter mon le -SNAPSHOT. Cela ne change rien au problème.
2. L'architecure :

Root(pom.xml)
|+test-Client(pom.xml)
|----+source
|--------+runtime (pom.xml)

Je pense que le relativePath du Pom enfant est correct, étant donné qu'il trouve son parent quand j'execute une commande depuis ce module. Un mvn help:effective-pom le prouve d'ailleurs.
Ce qui ne fonctionne pas depuis le module parent.

[evenisse]

ok, il semble y avoir un pb quand des modules sont déclarés.
Je n'ai jamias rencontré ce pb car j'exécute toujours 'mvn clean install'

Tu devrais ajouter une nouvelle entrée dans jira afin que ce pb soit corrigé dans les prochaines versions.

Tu devrais supprimé le '/' dans l'artifactId de ton POM enfant, je suis sur que tu veux pas un '/' dans le nom de ton jar final.