Ist es möglich, ein Maven-Jar-with-Dependencies umzubenennen?

Ich verwende derzeit die Assembly jar-with-dependencies, um ein solches jar zu erstellen. Der Name meines Glases ist jedoch etwas lang.

Da dieses Glas von RPG-Programmen auf einem AS400 verwendet wird, möchte ich es verkürzen, um diesen Entwicklern das Leben ein wenig zu erleichtern. Aber anders als von Hand habe ich keinen Weg gefunden, das Glas vom Üblichen umzubenennen project-name-version-classifier-jar-with-dependencies.jar. Ich hätte gerne so etwasproject-name-version-classifier-full.jar

Gibt es überhaupt eine Möglichkeit, dies zu tun, ohne den Assembly-Deskriptor jar-with-dependencies zu kopieren und als voll aufzurufen?

Außerdem möchte ich weiterhin das JAR ohne den zusammengestellten Klassenpfad im Repository speichern.

Ich brauche zwei Artefakte. Das Glas mit meinem Klassifikator, das die Region enthält, für die der Build bestimmt ist. Das Glas mit allen Abhängigkeiten, das auch die Region enthält.

project-name-version-region-full.jarund project-name-version-region.jarsollte im Repository gespeichert werden. Im ersten Beispiel ist der Klassifikator region-full, im zweiten ist es region. Letzteres funktioniert.

Sie können die Eigenschaft finalName angeben , um dem JAR den gewünschten Namen zu geben, und angeben, dass appendAssemblyId false sein soll, um das Suffix "jar-with-dependencies" zu vermeiden.

Die folgende Konfiguration gibt ein JAR mit dem Namen "test.jar" aus.

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

Update: Basierend auf Ihren Kommentaren funktioniert die Verwendung des integrierten Deskriptors nicht. Ich glaube, das liegt an einem Fehler in den jüngsten Versionen des Assembly-Plugins - sie haben die Unterstützung für Klassifizierer entfernt, aber die ID ist behoben, wenn Sie einen integrierten Deskriptor verwenden, sodass Sie einen großen blöden Namen erhalten.

Um dieses Problem zu umgehen, können Sie den vom JAR-with-Dependencies- Deskriptor verwendeten Assembly-Deskriptor kopieren und die ID ändern.

Dieses Beispiel würde dazu führen, dass die Assembly-ID an den endgültigen Namen angehängt wird. Wenn Sie also den Namen region-full.jar benötigen , können Sie den endgültigen Namen als Region und die Assembly-ID als vollständig angeben . Dies führt zu einer Datei im Ziel mit dem Namen region-full.jar. Beachten Sie jedoch, dass sie weiterhin als angefügtes Artefakt im Maven-Repository installiert wird, wobei full als Klassifizierer verwendet wird. Solange sich diese ID von der für Ihre andere Baugruppe unterscheidet, sollte es jedoch keine Kollision geben.

Die POM-Konfiguration würde so aussehen.

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

und die jar-Assembly.xml in src / main / Assembly wie folgt:

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

Ich glaube, ich habe einen Weg gefunden, dies direkt im POM zu konfigurieren, ohne eine separate jar-Assembly.xml zu benötigen.

Es ist im Grunde dasselbe wie Richs Antwort, außer dass der endgültige Name mit der Artefakt-ID und der Version angegeben wird.

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

Dank der Beiträge hier und einiger Eingriffe in die Maven-Dokumente habe ich die folgende Konfiguration für eine allgemeine, neu gepackte ausführbare JAR-Assembly mit einem benutzerdefinierten Namen gefunden.

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

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

Dies führt dazu, dass MyJarName.jaralle Abhängigkeiten in dasselbe und das angegebene Glas neu gepackt werden Main-Class: karlthepagain.MyMain.

Ich werde Rich die Ehre geben, mich in die richtige Richtung zu weisen, aber ich wollte die Lösung veröffentlichen, die für mich funktioniert hat, da Richs etwas anders war:

Meine jar-Assembly.xml sah folgendermaßen aus, sodass sich die Assembly-ID für die Region ändern konnte, die als Eigenschaft in meinem Profil gespeichert war:

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

Ich habe den Parameter finalName in den Einstellungen des Maven-Assembly-Plugins nicht verwendet, da dies mein Projekt mit meinem Projektnamen-Version-env-full.jar-Namen erstellt hat, wobei env-full der Klassifizierer war.

Stellen Sie sich meine Überraschung vor, als ich erfuhr, dass die Assembly-XML durch Elemente im Build parametrisiert werden kann. Genau das habe ich gesucht.

Das hat bei mir funktioniert

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

Es ist auch möglich, die ursprüngliche JAR-Datei zu überschreiben, indem Sie ${project.build.finalName}als endgültigen Namen Folgendes verwenden :

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