Est-il possible de renommer un maven jar-with-dependencies?

J'utilise actuellement l'assemblage jar-with-dependencies pour créer un tel fichier jar. Cependant, le nom de mon pot est un peu long.

Étant donné que ce fichier est utilisé par les programmes RPG sur un AS400, j'aimerais le raccourcir pour rendre la vie un peu plus facile à ces développeurs. Mais, à part à la main, je n'ai pas trouvé de moyen de renommer le pot de l'habituel project-name-version-classifier-jar-with-dependencies.jar. J'aimerais quelque chose commeproject-name-version-classifier-full.jar

Est-il possible de faire cela sans copier fondamentalement le descripteur d'assembly jar-with-dependencies et l'appeler full?

De plus, je veux continuer à avoir le fichier jar sans le classpath assemblé stocké dans le référentiel.

J'ai besoin de deux artefacts. Le pot avec mon classificateur contenant la région pour laquelle la construction est destinée. Le pot avec toutes les dépendances qui inclut également la région.

project-name-version-region-full.jaret project-name-version-region.jardoit être stocké dans le référentiel. Dans le premier exemple, le classificateur est plein de régions, dans le deuxième c'est une région. Ce dernier fonctionne.

Vous pouvez spécifier la propriété finalName pour donner au fichier jar le nom souhaité et spécifier que appendAssemblyId doit être false pour éviter le suffixe "jar-with-dependencies".

La configuration ci-dessous affichera un fichier jar appelé "test.jar"

<plugin>
  <artifactId>maven-assembly-plugin</artifactId>
  <version>2.2-beta-4</version>
  <executions>
    <execution>
      <id>jar-with-dependencies</id>
      <phase>package</phase>
      <goals>
        <goal>single</goal>
      </goals>
      <configuration>
        <descriptorRefs>
          <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
        <finalName>test</finalName>
        <appendAssemblyId>false</appendAssemblyId>
      </configuration>
    </execution>
  </executions>
</plugin>

Mise à jour: en fonction de vos commentaires, l'utilisation du descripteur intégré ne fonctionnera pas. Je pense que cela est dû à un bogue dans les versions récentes de l'assembly-plugin - ils ont supprimé la prise en charge des classificateurs, mais l'identifiant est corrigé si vous utilisez un descripteur intégré, vous vous retrouvez donc avec un gros nom idiot.

Pour contourner ce problème, vous pouvez copier le descripteur d'assembly utilisé par le descripteur jar-with-dependencies et modifier l'ID.

Cet exemple entraînerait l'ajout de l'ID d'assembly au finalName, donc si vous avez besoin d'un nom de region-full.jar , vous pouvez spécifier le finalName comme région et l'ID d'assembly comme complet . Cela se traduira par un fichier dans la cible appelé region-full.jar, mais notez qu'il sera toujours installé dans le référentiel Maven comme un artefact attaché avec full utilisé comme classificateur. Tant que cet identifiant est différent de celui de votre autre assembly, il ne devrait pas y avoir de collision.

La configuration du pom ressemblerait à ceci.

<plugin>
  <artifactId>maven-assembly-plugin</artifactId>
  <version>2.2-beta-4</version>
  <executions>
    <execution>
      <id>jar-with-dependencies</id>
      <phase>prepare-package</phase>
      <goals>
        <goal>single</goal>
      </goals>
      <configuration>
        <descriptors>
          <descriptor>src/main/assembly/jar-assembly.xml</descriptor>
        </descriptors>
        <finalName>region</finalName>
      </configuration>
    </execution>
  </executions>
</plugin>

et le jar-assembly.xml dans src / main / assembly comme ceci:

<assembly>
  <id>full</id>
  <formats>
    <format>jar</format>
  </formats>
  <includeBaseDirectory>false</includeBaseDirectory>
  <dependencySets>
    <dependencySet>
      <unpack>true</unpack>
      <scope>runtime</scope>
    </dependencySet>
  </dependencySets>
  <fileSets>
    <fileSet>
      <directory>${project.build.outputDirectory}</directory>
    </fileSet>
  </fileSets>
</assembly>

Je pense avoir trouvé un moyen de configurer cela directement dans le pom sans avoir besoin d'un fichier jar-assembly.xml séparé.

C'est fondamentalement la même chose que la réponse de Rich, sauf que le nom final est spécifié avec l'artefactId et la version.

<plugin>
    <artifactId>maven-assembly-plugin</artifactId>
    <configuration>
        <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
        <finalName>${project.artifactId}-${project.version}-full</finalName>
        <appendAssemblyId>false</appendAssemblyId>
        <archive>
            <manifest>
                <mainClass>com.mycompany.MyMainClass</mainClass>
            </manifest>
        </archive>
    </configuration>
    <executions>
        <execution>
            <id>make-my-jar-with-dependenciess</id>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
        </execution>
    </executions>
</plugin>

Grâce aux articles ici et à quelques recherches dans les documents maven, j'ai trouvé la configuration suivante pour un assemblage de jar exécutable général reconditionné avec un nom personnalisé.

Dans pom.xml:

<plugin>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>2.2</version>
    <executions>
        <execution>
            <id>exe</id>
            <phase>package</phase>
            <goals><goal>single</goal></goals>
            <configuration>
                <finalName>MyJarName</finalName>
                <attach>false</attach>
                <appendAssemblyId>false</appendAssemblyId>
                <descriptors>
                    <descriptor>assembly.xml</descriptor>
                </descriptors>
                <archive>
                    <manifest>
                        <mainClass>karlthepagain.MyMain</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </execution>
    </executions>
</plugin>

Dans assembly.xml:

<assembly>
    <id>exe</id>
    <formats>
        <format>jar</format>
    </formats>
    <includeBaseDirectory>false</includeBaseDirectory>
    <dependencySets>
        <dependencySet>
            <outputDirectory>/</outputDirectory>
            <unpack>true</unpack>
            <scope>runtime</scope>
        </dependencySet>
    </dependencySets>
</assembly>

Cela produira MyJarName.jaravec toutes ses dépendances reconditionnées dans ce même fichier jar et le fichier Main-Class: karlthepagain.MyMain.

Je vais donner à Rich le mérite de m'avoir pointé dans la bonne direction, mais je voulais publier la solution qui a fonctionné pour moi car Rich était légèrement en retrait:

Mon jar-assembly.xml ressemblait à ceci, ce qui permettait à l'ID d'assembly de changer pour la région qui était stockée en tant que propriété dans mon profil:

<assembly>
  <id>${env}-full</id>
    <formats>
      <format>jar</format>
    </formats>
    <includeBaseDirectory>false</includeBaseDirectory>
    <dependencySets>
      <dependencySet>
        <unpack>true</unpack>
        <scope>runtime</scope>
      </dependencySet>
    </dependencySets>
    <fileSets>
      <fileSet>
        <directory>${project.build.outputDirectory}</directory>
      </fileSet>
    </fileSets>
</assembly>

Je n'ai pas utilisé le paramètre finalName dans les paramètres de maven-assembly-plugin car cela a construit mon projet avec mon nom de projet-version-env-full.jar où env-full était le classificateur.

Imaginez ma surprise lorsque j'ai appris que l'assembly xml pouvait être paramétré par des éléments de la construction. C'était exactement ce que je cherchais.

Cela a fonctionné pour moi

<build>
    <finalName>anynameyoulike</finalName>
    <plugins>           
        <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>2.6</version>
            <configuration>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>                   
                <appendAssemblyId>false</appendAssemblyId>
                <archive>
                    <manifest>
                        <mainClass>com.mycompany.MyMainClass</mainClass>
                    </manifest>
                </archive>
            </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>

Il est également possible d'écraser le fichier jar d'origine en utilisant ${project.build.finalName}comme nom final:

<plugin>
  <artifactId>maven-assembly-plugin</artifactId>
   <executions>
      <execution>
          <phase>package</phase>
          <goals>
             <goal>single</goal>
          </goals>
      </execution>
   </executions>
   <configuration>
     <descriptorRefs>
       <descriptorRef>jar-with-dependencies</descriptorRef>
     </descriptorRefs>
     <finalName>${project.build.finalName}</finalName>
     <appendAssemblyId>false</appendAssemblyId>
   </configuration>
 </plugin>