wake-up-neo.net

Ist es möglich, einen Maven jar-with-dependencies umzubenennen?

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

Da diese JAR von RPG-Programmen auf einem AS400 verwendet wird, möchte ich sie verkürzen, um den Entwicklern das Leben ein wenig zu erleichtern. Aber anders als von Hand habe ich keine Möglichkeit gefunden, das Glas vom üblichen project-name-version-classifier-jar-with-dependencies.jar Umzubenennen. Ich hätte gerne etwas wie project-name-version-classifier-full.jar

Ist dies überhaupt möglich, ohne den Assembly-Deskriptor jar-with-dependencies zu kopieren und als voll zu bezeichnen?

Außerdem möchte ich weiterhin die JAR-Datei 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.jar Und project-name-version-region.jar Sollten im Repository gespeichert werden. Im ersten Beispiel ist der Klassifikator region-full, im zweiten region. Letzteres funktioniert.

121
Mike Cornell

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

Die folgende Konfiguration gibt eine JAR-Datei 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 eingebauten Deskriptor verwenden, so dass Sie am Ende einen dummen Namen haben.

Um dieses Problem zu umgehen, können Sie den Assembly-Deskriptor kopieren, der vom Deskriptor jar-with-dependencies verwendet wird, und die ID ändern.

In diesem Beispiel wird die Assembly-ID an den finalName angehängt. Wenn Sie also den Namen region-full.jar benötigen, können Sie diesen angeben Der endgültige Name als Region und die Assembly-ID als voll . Dies führt zu einer Datei im Ziel mit dem Namen region-full.jar. Beachten Sie jedoch, dass sie weiterhin als angefügtes Artefakt mit full im Maven-Repository installiert wird. als Klassifikator verwendet. Solange diese ID von der für Ihre andere Assembly abweicht, sollte es jedoch zu keiner Kollision kommen.

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>
211
Rich Seller

Ich denke, ich habe eine Möglichkeit gefunden, dies direkt in der pom zu konfigurieren, ohne eine separate jar-Assembly.xml zu benötigen.

Es ist im Grunde die gleiche wie Richs Antwort, mit der Ausnahme, dass der endgültige Name mit der ArtifactId 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>
27
vikingsteve

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

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

Dadurch wird MyJarName.jar Mit all seinen Abhängigkeiten erzeugt, die in dasselbe Jar und das angegebene Main-Class: karlthepagain.MyMain Umgepackt wurden.

8
Karl the Pagan

Ich werde Rich die Ehre erweisen, mich in die richtige Richtung gelenkt zu haben, aber ich wollte die Lösung veröffentlichen, die für mich funktioniert hat, da Richs Fehler leicht zu spüren war:

Meine jar-Assembly.xml sah so aus, dass 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 erstellte, 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.

3
Mike Cornell

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

Es ist auch möglich, die ursprüngliche JAR-Datei mit ${project.build.finalName} Als endgültigem Namen zu überschreiben:

<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>
0
Mark Schäfer