Czy można zmienić nazwę pliku jar-maven z zależnościami?

Obecnie używam zestawu jar-with-dependencies do tworzenia takiego jar. Jednak nazwa mojego słoika jest trochę długa.

Ponieważ ten jar jest używany przez programy RPG na AS400, chciałbym go skrócić, aby trochę ułatwić życie tym programistom. Ale poza ręką nie znalazłem sposobu na zmianę nazwy słoika ze zwykłej project-name-version-classifier-jar-with-dependencies.jar. Chciałbym coś podobnegoproject-name-version-classifier-full.jar

Czy w ogóle można to zrobić bez kopiowania deskryptora zestawu jar-with-dependencies i nazywania go pełnym?

Ponadto chcę nadal przechowywać słoik bez zmontowanej ścieżki klas w repozytorium.

Potrzebuję dwóch artefaktów. Słoik z moim klasyfikatorem zawierającym region, dla którego jest kompilacja. Jar ze wszystkimi zależnościami, który obejmuje również region.

project-name-version-region-full.jari project-name-version-region.jarpowinny być przechowywane w repozytorium. W pierwszym przykładzie klasyfikator jest pełen regionu, w drugim jest to region. Ten ostatni działa.

Możesz określić właściwość finalName, aby nadać jarowi żądaną nazwę, i określić, że parametr appendAssemblyId powinien mieć wartość false, aby uniknąć przyrostka „jar-with-dependencies”.

Poniższa konfiguracja wyświetli plik jar o nazwie „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>

Aktualizacja: na podstawie twoich komentarzy użycie wbudowanego deskryptora nie zadziała. Uważam, że jest to spowodowane błędem w ostatnich wersjach wtyczki assemblera - usunęli wsparcie dla klasyfikatorów, ale identyfikator jest naprawiony, jeśli używasz wbudowanego deskryptora, więc otrzymujesz dużą, głupią nazwę.

Aby obejść ten problem, możesz skopiować deskryptor zestawu używany przez deskryptor jar-with-dependencies i zmodyfikować id.

Ten przykład spowoduje dołączenie identyfikatora zestawu do finalName, więc jeśli potrzebujesz nazwy region-full.jar , możesz określić finalName jako region, a identyfikator zestawu jako pełny . Spowoduje to powstanie w miejscu docelowym pliku o nazwie region-full.jar, ale pamiętaj, że nadal będzie on instalowany w repozytorium Maven jako dołączony artefakt, w pełni używany jako klasyfikator. Dopóki ten identyfikator różni się od identyfikatora innego zestawu, nie powinno być jednak kolizji.

Konfiguracja pom wyglądałaby tak.

<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>

i jar-assembly.xml w src / main / assembly w następujący sposób:

<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>

Myślę, że znalazłem sposób, aby skonfigurować to bezpośrednio w pom, bez potrzeby oddzielnego jar-assembly.xml.

Zasadniczo jest to to samo, co odpowiedź Richa, z wyjątkiem tego, że finalName jest określana za pomocą artifactId i 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>

Dzięki postom tutaj i kilku przeglądom dokumentacji Maven wymyśliłem następującą konfigurację ogólnego jednorazowego przepakowanego zestawu jar wykonywalnego pliku jar o niestandardowej nazwie.

W 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>

W 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>

Spowoduje to, że MyJarName.jarwszystkie jego zależności zostaną ponownie spakowane do tego samego pliku jar i określonego Main-Class: karlthepagain.MyMain.

Mam zamiar przyznać Richowi zasługę, że wskazał mi właściwy kierunek, ale chciałem opublikować rozwiązanie, które zadziałało dla mnie, ponieważ Rich's był nieco wyłączony:

Mój plik jar-assembly.xml wyglądał tak, co umożliwiło zmianę identyfikatora zestawu dla regionu, który był przechowywany jako właściwość w moim profilu:

<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>

Nie użyłem parametru finalName w ustawieniach wtyczki maven-assembly, ponieważ skompilowałem mój projekt z nazwą mojego projektu-nazwa-wersja-env-full.jar, gdzie env-full był klasyfikatorem.

Wyobraź sobie moje zdziwienie, gdy dowiedziałem się, że plik XML zestawu może być sparametryzowany przez elementy w kompilacji. To było dokładnie to, czego szukałem.

To zadziałało dla mnie

<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>

Możliwe jest również nadpisanie oryginalnego pliku jar, używając ${project.build.finalName}jako ostatecznej nazwy:

<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>