Création de deux Jars exécutables à l'aide de maven-assembly-plugin

Question

J'ai un projet Maven et je veux créer deux fichiers jar exécutables à partir de celui-ci. Le premier sera utilisé de manière interactive par les utilisateurs et le second sera exécuté en tant que tâche planifiée qui lit les fichiers journaux produits par le premier. Au final, je m'attends à ce que les deux fichiers jar soient identiques, à l'exception de l'attribut Main-Class dans le fichier MANIFEST.MF.

J'utilise maven-antrun-plugin pour créer un jar exécutable et cela semblait fonctionner correctement jusqu'à ce que j'essaie de créer un deuxième fichier jar en introduisant des profils Maven. La section pertinente de mon fichier POM ressemble à ceci :

<profiles>
    <profile>
        <id>publisher</id>
        <build>
            <finalName>${project.artifactId}</finalName>
            <plugins>
                ...
                <plugin>
                    <artifactId>maven-assembly-plugin</artifactId>
                    <version>2.4</version>
                    <configuration>
                        <appendAssemblyId>false</appendAssemblyId>
                        <finalName>${project.artifactId}</finalName>
                        <archive>
                            <manifest>
                                <mainClass>fully.qualified.path.Publisher</mainClass>
                            </manifest>
                        </archive>
                        <descriptorRefs>
                            <descriptorRef>jar-with-dependencies</descriptorRef>
                        </descriptorRefs>
                    </configuration>
                    <executions>
                        <execution>
                            <phase>package</phase>
                            <goals>
                                <goal>single</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    </profile>
    <profile>
        <id>logReader</id>
        <build>
            <finalName>${project.artifactId}</finalName>
            <plugins>
                ...
                <plugin>
                    <artifactId>maven-assembly-plugin</artifactId>
                    <version>2.4</version>
                    <configuration>
                        <appendAssemblyId>false</appendAssemblyId>
                        <finalName>${project.artifactId}-logReader</finalName>
                        <archive>
                            <manifest>
                                <mainClass>fully.qualified.path.LogReader</mainClass>
                            </manifest>
                        </archive>
                        <descriptorRefs>
                            <descriptorRef>jar-with-dependencies</descriptorRef>
                        </descriptorRefs>
                    </configuration>
                    <executions>
                        <execution>
                            <phase>package</phase>
                            <goals>
                                <goal>single</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    </profile>
</profiles>

En réalité, la seule différence entre les deux est constituée par les éléments "finalName" et "mainClass" tels que définis dans le plugin.

Lorsque j'essaie d'exécuter mvn:package sur les deux profils (j'utilise IntelliJ IDEA, soit dit en passant), j'obtiens deux fichiers .jar, mais l'un est correct et l'autre est incorrect. Le fichier "correct" contient toutes les dépendances et un fichier MANIFEST.MF valide. Le fichier "incorrect" ne contient aucune dépendance et le fichier MANIFEST.MF ne contient pas la propriété "Main-Class" dont j'ai besoin pour qu'il soit exécutable.

J'ai constaté que si je n'exécute qu'un profil ou l'autre, cela fonctionne bien, mais que si j'essaie d'exécuter les deux profils à la fois, cela échoue. J'obtiens également les notes suivantes dans mon journal, mais je dois admettre que je ne comprends pas complètement ce qu'elles disent :

[INFO] Building jar: .../target/publisher.jar
...
[INFO] Building jar: .../target/publisher-logReader.jar
[WARNING] Configuration options: 'appendAssemblyId' is set to false, and 'classifier' is missing.
Instead of attaching the assembly file: .../target/publisher-logReader.jar, it will become the file for main project artifact.
NOTE: If multiple descriptors or descriptor-formats are provided for this project, the value of this file will be non-deterministic!
[WARNING] Replacing pre-existing project main-artifact file: .../target/publisher.jar with assembly file: .../target/publisher-logReader.jar

Des idées à ce sujet ? Est-il possible de produire deux fichiers jar avec un seul mvn:package de cette manière, ou est-ce que je m'égare ?

Merci !

Answer 1

Dès que j'ai posté ce message, j'ai trouvé ce fil de discussion :

Créez plusieurs Jars exécutables (avec les dépendances incluses) à partir d'un seul projet Maven.

Cette approche est différente dans la mesure où elle n'utilise pas deux profils, mais deux exécutions, en tant que telles :

<plugin>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>2.4</version>
    <executions>
        <execution>
            <id>build-publisher</id>
            <configuration>
                <appendAssemblyId>false</appendAssemblyId>
                <archive>
                    <manifest>
                        <mainClass>fully.qualified.path.Publisher</mainClass>
                    </manifest>
                </archive>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
                <finalName>${project.artifactId}</finalName>
            </configuration>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
        </execution>
        <execution>
            <id>build-logReader</id>
            <configuration>
                <appendAssemblyId>false</appendAssemblyId>
                <archive>
                    <manifest>
                        <mainClass>fully.qualified.path.LogReader</mainClass>
                    </manifest>
                </archive>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
                <finalName>${project.artifactId}-logReader</finalName>
            </configuration>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
        </execution>
    </executions>
</plugin>

Cela semble fonctionner. La morale de l'histoire semble être que je ne comprends pas complètement les profils ou le moment où ils doivent être utilisés.