Déploiement avec plugins

**Matthieu Vergne** · 16/11/2011, 15h51

Bonjour {^_^}, (desole pour les accents et autres, je suis sur un clavier QWERTY)

Tout d'abord le contexte. Je cree un framework qui execute des algorithmes ayant un objectif commun (trier des besoins selon differents criteres). Les algorithmes sont charges dynamiquement a l'execution, l'utilisateur pouvant alors choisir lequel il veut utiliser. Pour cela, chaque algorithme est developpe dans un projet a part, qui depend donc d'un projet decrivant les interfaces a utiliser (et differents outils communs). De maniere plus shematisee :

- Projet "algorithm" : regroupe les interfaces generiques et les outils communs aux differents algorithmes.

- Projet algo1 : implemente un algorithme particulier, qui etend les interfaces du projet "algorithm" (et donc en depend). Un JAR est cree une fois l'algo implemente.

- Projets algo2, algo3, ... : idem, chacun implemente un algorithme particulier.

- Projet "framework" : implemente le framework qui execute les algorithmes. Les JAR des algos disponibles sont places dans un dossier specifique, scanne par le framework. Il charge alors les algorithmes qui implementent les interfaces definies dans le projet "algorithm" (et donc il en depend aussi). Il convient de noter que ce projet ne depend pas des projets algo1, algo2, ... Il n'a aucune connaissance de ces projets, seuls les JARs dispo dans son dossier sont charges dynamiquement (et s'ils implementent les interfaces de "algorithms", alors ils sont reconnus et listes).

Voila en gros comment ca se passe. Pour gerer tout ca, j'utilise Maven via Eclipse. J'ai donc un pom parent qui regroupe tous mes projets (interfaces + algos + framework) et un pom pour chaque projet. Le pom parent definit chaque projet comme un de ses modules (j'ai retire les infos sensibles et change les noms, mais la structure est strictement la meme) :

Code :

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

1
2
3
4
5
6
<modules>
	<module>framework</module>
	<module>algorithm</module>
	<module>algo1</module>
	<module>algo2</module>
</modules>

Bien entendu, chaque projet voit son pom lie au parent :

Code :

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

1
2
3
4
5
<parent>
	<artifactId>parent</artifactId>
	<groupId>...</groupId>
	<version>...</version>
</parent>

Les projets framework et algoX definissent bien entendu leurs dependances aux interfaces :

Code :

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

1
2
3
4
5
6
<dependency>
	<groupId>...</groupId>
	<artifactId>algorithm</artifactId>
	<version>...</version>
	<scope>compile</scope>
</dependency>

Notez qu'ils definissent aussi tous une dependance pour JUnit :

Code :

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

1
2
3
4
5
6
<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>4.8.2</version>
	<scope>test</scope>
</dependency>

A part ca je n'ai rien de special qui me vient en tete. Voila pour illustrer le pom d'un algo :

Code :

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
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
<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>
	<parent>
		<artifactId>parent</artifactId>
		<groupId>...</groupId>
		<version>...</version>
	</parent>
 
	<artifactId>algo1</artifactId>
	<name>...</name>
	<description>...</description>
	<inceptionYear>...</inceptionYear>
 
	<developers>
		<developer>
			<name>...</name>
			<email>...</email>
		</developer>
	</developers>
 
	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.8.2</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>...</groupId>
			<artifactId>algorithm</artifactId>
			<version>...</version>
			<scope>compile</scope>
		</dependency>
	</dependencies>
</project>

Et le pom du parent :

Code :

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
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
<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>...</groupId>
  <artifactId>parent</artifactId>
  <version>...</version>
  <packaging>pom</packaging>
	<name>...</name>
	<description>...</description>
	<inceptionYear>...</inceptionYear>
 
	<developers>
		<developer>
			<name>...</name>
			<email>...</email>
		</developer>
	</developers>
	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>2.3.2</version>
				<configuration>
					<source>1.6</source>
					<target>1.6</target>
				</configuration>
			</plugin>
		</plugins>
	</build>
  <modules>
  	<module>framework</module>
  	<module>algorithm</module>
  	<module>algo1</module>
  	<module>algo2</module>
  </modules>
</project>

Maintenant mon niveau. Je suis un debutant sous Maven : je m'y suis mis parce qu'un camarade a mavenise un de mes projets, et depuis je me contente de copier-coller les poms en changeant juste ce que j'ai besoin. Aussi je pense avoir bien compris le role de chaque element present dans ces poms, mais je n'ai aucune idee de ce que je peux mettre d'autre. J'apprends sur le tas.

Mon soucis est le suivant : j'aimerais que lorsque j'ai fini une release de mon projet, je puisse le deployer en compilant tout et en m'assurant qu'au final j'ai un framework complet, c'est a dire :
- un JAR executable du framework (qui contient les interfaces et outils du projet algorithm)
- un dossier contenant tous les JARs des algorithmes implementes (algo1.jar, algo2.jar, ...)

Je suis capable de le faire a la main sous Eclipse (exporter le projet du framework dans un JAR executable, exporter chaque projet algo dans un JAR que je place dans le dossier du framework) et ca marche. Ce que j'essaye de faire est d'automatiser ce processus via Maven.

Ma question est donc la suivante : comment automatiser ce processus de la maniere la plus propre que possible ? J'ai deja vu un sujet similaire mais je ne suis pas sur que ce soit le meme probleme : http://www.developpez.net/forums/d11...dances-projet/

Une question subsidiaire serait : auriez-vous un tutoriel pas-a-pas ET complet sur Maven ? J'ai vu plein de tutos sur le net, mais a chaque fois c'etait soit super simple mais on fait juste un projet sous Maven, on va pas beaucoup plus loin, soit bien detaille mais il faut deja maitriser maven pour savoir de quoi on parle, ce qui n'est pas mon cas (et c'est le feeling que m'a donne le sujet cite ci-dessus).

**Philippe Bastiani** · 17/11/2011, 00h08

Tu peux jouer avec la configuration du plugin maven-jar-plugin

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId> 
      <artifactId>maven-jar-plugin</artifactId>
      <version>2.3.2</version>
      <configuration>
        <outputDirectory>myPath</outputDirectory>
     </configuration>
    </plugin>
  </plugins>
</build>

Tu peux biensur parametrer ta sortie via une variable <outputDirectory>${dir}</outputDirectory> ; et, lui affecter une valeur depuis la ligne de commande mvn -Ddir=myPath ou dans ton settings.xml

**Matthieu Vergne** · 17/11/2011, 14h53

J'ai regarde vite fait ton lien et, si j'ai bien compris, cette description permet de dire ou tu veux generer le JAR du projet concerne, c'est ca ?

Si non alors j'ai pas compris son utilisation.

Si oui alors ce n'est peut-etre pas exactement ce qu'il me faut, dans le sens ou cela m'oblige a definir une partie de la logique globale dans chaque projet (pour chaque algo je dois lui dire de faire un JAR a mettre dans un dossier qu'il n'est pas sense manager). Je serai plus partant pour une solution qui me fait generer mes JAR normalement, mais qui me permette de dire dans la config du parent "tu recuperes le JAR du framework que tu met la, et le JAR de algo1 et algo2 que tu met la". De cette maniere la logique est centralisee et ca m'evite de devoir retoucher tous les poms des que je veux changer un truc.

**Philippe Bastiani** · 18/11/2011, 10h23

Ok donc tu souhaites faire un délivrabre: dans ce cas, tu auras, sans doute, à déposer tes dépendances externes, ta javadoc, ...

Donc ce plugin maven-assembly-plugin. Tu pourras noter que ton assembly pourra prendre plusieurs formes (zip, dir, etc).

Tu trouveras sur le site d'Apache des exemples; où dans ce livre de référence sur Maven

a+

**Matthieu Vergne** · 18/11/2011, 12h37

Effectivement ca a l'air pas mal du tout. Je vois ca et je viens faire un retour {^_^}.

**Matthieu Vergne** · 21/11/2011, 21h45

Ça marche pas mal du tout. J'ai fait un nouveau projet "all" qui récupère le framework et les algos. J'ai préféré faire ça car je n'ai pas envie de mettre des dépendances entre le framework et les algos, sinon ça perd son sens. Du coup j'ai mon projet "all" qui ne fait que fusionner l'ensemble des éléments en un tout cohérent. Il dépend donc de tous les projets et définit un assembly.xml qui récupère ce dont il a besoin.

Le pom du projet all :

Code :

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
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
<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>
	<parent>
		<groupId>groupId</groupId>
		<artifactId>irp-parent</artifactId>
		<version>1.0.0</version>
	</parent>
 
	<artifactId>all</artifactId>
	<name>...</name>
	<description>...</description>
	<inceptionYear>...</inceptionYear>
 
	<developers>
		<developer>
			<name>...</name>
			<email>...</email>
		</developer>
	</developers>
 
	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-assembly-plugin</artifactId>
				<version>2.2.1</version>
				<configuration>
					<descriptors>
						<descriptor>assembly.xml</descriptor> <!-- assembly fait main -->
					</descriptors>
				</configuration>
				<executions>
					<execution>
						<id>make-assembly</id> <!-- this is used for inheritance merges -->
						<phase>package</phase> <!-- bind to the packaging phase -->
						<goals>
							<goal>single</goal>
						</goals>
					</execution>
				</executions>
			</plugin>
		</plugins>
	</build>
 
	<properties>
		<deps.scope>runtime</deps.scope>
	</properties>
 
	<dependencies>
		<dependency>
			<groupId>${project.parent.groupId}</groupId>
			<artifactId>framework</artifactId>
			<version>LATEST</version>
			<scope>${deps.scope}</scope>
		</dependency>
		<dependency>
			<groupId>${project.parent.groupId}</groupId>
			<artifactId>algo1</artifactId>
			<version>LATEST</version>
			<scope>${deps.scope}</scope>
		</dependency>
		<dependency>
			<groupId>${project.parent.groupId}</groupId>
			<artifactId>algo2</artifactId>
			<version>LATEST</version>
			<scope>${deps.scope}</scope>
		</dependency>
	</dependencies>
</project>

Et l'assembly qui définit ce que je veux mettre ensemble :

Code :

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
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
<assembly xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0" 
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0 http://maven.apache.org/xsd/assembly-1.1.0.xsd">
  <id>bin</id>
 
  <formats>
    <format>tar.gz</format>
    <format>tar.bz2</format>
    <format>zip</format>
  </formats>
 
  <fileSets>
    <!-- recopié depuis un modèle de base -->
    <!-- on recopie la doc, les licences, ... -->
    <fileSet>
      <directory>${project.basedir}</directory>
      <outputDirectory>/</outputDirectory>
      <includes>
        <include>README*</include>
        <include>LICENSE*</include>
        <include>NOTICE*</include>
      </includes>
    </fileSet>
    <fileSet>
      <directory>${project.build.directory}/site</directory>
      <outputDirectory>docs</outputDirectory>
    </fileSet>
  </fileSets>
 
  <dependencySets>
    <!-- on récupère le framework -->
    <dependencySet>
      <outputDirectory>/</outputDirectory>
      <includes>
        <include>${project.parent.groupId}:framework</include>
      </includes>
    </dependencySet>
    <!-- on récupère les algos (algo* = algo1, algo2, ...)-->
    <dependencySet>
      <outputDirectory>/algorithms/</outputDirectory>
      <includes>
        <include>${project.parent.groupId}:algo*</include>
      </includes>
    </dependencySet>
  </dependencySets>
</assembly>

Maintenant, ce que j'aimerais, c'est que les resources que je définis dans chacun des algos soit aussi récupérés, pas juste les JAR. J'ai pas trouvé de moyen propre de le faire (obligé de donner le chemin complet vers le dossier via un fileSet). J'espère pouvoir dire "récupère les ressources des projets algo1, algo2, ... pour les mettre dans un dossier resources dans l'archive".

Une idée pour ce dernier point ?

Déploiement avec plugins

Maven Java

Vue hybride

Discussions similaires

Partager

Partager