Wie kann ich mit Maven eine ausführbare JAR mit Abhängigkeiten erstellen?

2396

Ich möchte mein Projekt zur Verteilung in eine einzige ausführbare JAR packen.

Wie kann ich aus einem Maven-Projektpaket alle Abhängigkeits-JARs in meine Ausgabe-JAR erstellen?

Soemirno
quelle
14
Bitte erläutern Sie, auf welches Ziel des Abhängigkeits-Plugins Sie sich beziehen. Ich kenne kein Ziel, das das tut, was die ursprüngliche Frage verlangt: alle Abhängigkeiten entweder A) durch Umpacken in das Glas des Autors zu setzen oder B) ein ausführbares Glas zu erstellen, das die anderen in einem Klassenpfad von MANIFEST.MF
Matthew McCullough
2
Sie könnten diese nützliche rationaljava.com/2015/02/…
Dan

Antworten:

2359
<build>
  <plugins>
    <plugin>
      <artifactId>maven-assembly-plugin</artifactId>
      <configuration>
        <archive>
          <manifest>
            <mainClass>fully.qualified.MainClass</mainClass>
          </manifest>
        </archive>
        <descriptorRefs>
          <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
      </configuration>
    </plugin>
  </plugins>
</build>

und du machst es mit

mvn clean compile assembly:single

Das Kompilierungsziel sollte vor dem Zusammenbau hinzugefügt werden: einzeln oder anderweitig ist der Code in Ihrem eigenen Projekt nicht enthalten.

Weitere Details finden Sie in den Kommentaren.


In der Regel ist dieses Ziel an eine Build-Phase gebunden, die automatisch ausgeführt wird. Dadurch wird sichergestellt, dass die JAR beim Ausführen mvn installoder Ausführen einer Bereitstellung / Version erstellt wird.

<plugin>
  <artifactId>maven-assembly-plugin</artifactId>
  <configuration>
    <archive>
      <manifest>
        <mainClass>fully.qualified.MainClass</mainClass>
      </manifest>
    </archive>
    <descriptorRefs>
      <descriptorRef>jar-with-dependencies</descriptorRef>
    </descriptorRefs>
  </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>
IAdapter
quelle
22
Danke @IAdapter. Beachten Sie, dass Sie immer vorab kompilieren sollten, da nur das, was sich in "Ziel / Klassen" befindet, in die JAR eingefügt wird. Dadurch wird sichergestellt, dass die JAR alle Änderungen enthält, die Sie kürzlich am Quellcode vorgenommen haben. Sie sollten also Folgendes tun : mvn clean compile assembly:single.
Michael
10
Ich habe die Frage so bearbeitet, dass sie die Phasenbindung enthält. Ich habe das veraltete Montageziel entfernt, weil niemand davon wissen muss.
Duncan Jones
2
Ich sehe, dass dies nicht die Gläser zum Überglas hinzufügt, sondern nur alle Klassendateien zum Glas hinzufügt.
Pitchblack408
170
Tipp: Sie können das Element auch <appendAssemblyId>false</appendAssemblyId>in das hinzufügen configuration, um das nervige Suffix "-jar-with-dependencies" im Namen zu vermeiden
maxivis
6
Vergiss compileund du bist geschraubt.
Prayagupd
349

Sie können das Abhängigkeits-Plugin verwenden, um alle Abhängigkeiten vor der Paketphase in einem separaten Verzeichnis zu generieren und diese dann in den Klassenpfad des Manifests aufzunehmen:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <executions>
        <execution>
            <id>copy-dependencies</id>
            <phase>prepare-package</phase>
            <goals>
                <goal>copy-dependencies</goal>
            </goals>
            <configuration>
                <outputDirectory>${project.build.directory}/lib</outputDirectory>
                <overWriteReleases>false</overWriteReleases>
                <overWriteSnapshots>false</overWriteSnapshots>
                <overWriteIfNewer>true</overWriteIfNewer>
            </configuration>
        </execution>
    </executions>
</plugin>
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <configuration>
        <archive>
            <manifest>
                <addClasspath>true</addClasspath>
                <classpathPrefix>lib/</classpathPrefix>
                <mainClass>theMainClass</mainClass>
            </manifest>
        </archive>
    </configuration>
</plugin>

Alternativ können Sie es ${project.build.directory}/classes/libals OutputDirectory verwenden, um alle JAR-Dateien in das Haupt-JAR zu integrieren. Anschließend müssen Sie jedoch benutzerdefinierten Klassenladecode hinzufügen, um die Jars zu laden.

André Aronsen
quelle
3
+1 Ausgezeichnet. Der Grund, warum ich mich für das Maven-Dependency-Plugin anstelle des Maven-Assembly-Plugins entscheide, ist, dass ich auch das Buildnumber-Maven-Plugin verwende und auf diese Weise die Versionsnummer im Manifest jedes JARs einzeln speichern kann.
PapaFreud
17
Ich mag deine Lösung. Ich benutze ${project.build.directory}/classes/libals outputDirectoryein Haupt .jar mit allen Abhängigkeiten innerhalb haben, aber - wie benutzerdefinierten Classloading Code hinzufügen diese Gläser zu laden? Ich muss die Arbeit wie folgt ausführen : java -jar main-jar-with-deps.jar. Ist das möglich ?
Marioosh
3
@ André Aronsen, ich habe diese Lösung verwendet, um die Abhängigkeiten in einem lib-Ordner im JAR hinzuzufügen, aber ich bekomme immer eine Ausnahme, dass die Klasse nicht gefunden wurde. Können Sie mir bitte mitteilen, wie das behoben werden kann?
Mahmoud Saleh
11
+1 für dich !! Es sieht so aus, als ob das Maven-Assembly-Plugin 'jar-with-dependencies' nicht wirklich gut funktioniert. Ich habe einige Einträge von META-INF / spring.schemas im generierten Glas vermisst. Also habe ich das Glas mit den Abhängigkeiten verschrottet und Ihre obige Lösung verwendet. Perfekt danke!!!
Derek
9
Für alle anderen, die auf dieses Problem stoßen, müssen Sie den Ordner lib im selben Verzeichnis wie Ihre JAR-Datei einfügen, wohin auch immer Sie die JAR-Datei transportieren.
Sparticles
224

Ich habe über verschiedene Möglichkeiten gebloggt, dies zu tun.

Siehe Ausführbares Glas mit Apache Maven (WordPress)

oder ausführbares-jar-with-maven-Beispiel (GitHub)

Anmerkungen

Diese Vor- und Nachteile werden von Stephan bereitgestellt .


Für die manuelle Bereitstellung

  • Vorteile
  • Nachteile
    • Abhängigkeiten sind aus dem letzten Glas.

Kopieren Sie Abhängigkeiten in ein bestimmtes Verzeichnis

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-dependency-plugin</artifactId>
  <executions>
    <execution>
      <id>copy-dependencies</id>
      <phase>prepare-package</phase>
      <goals>
        <goal>copy-dependencies</goal>
      </goals>
      <configuration>
        <outputDirectory>${project.build.directory}/${project.build.finalName}.lib</outputDirectory>
      </configuration>
    </execution>
  </executions>
</plugin>

Machen Sie das Jar Executable und Classpath Aware

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-jar-plugin</artifactId>
  <configuration>
    <archive>
      <manifest>
        <addClasspath>true</addClasspath>
        <classpathPrefix>${project.build.finalName}.lib/</classpathPrefix>
        <mainClass>${fully.qualified.main.class}</mainClass>
      </manifest>
    </archive>
  </configuration>
</plugin>

Zu diesem Zeitpunkt jarist das tatsächlich mit externen Klassenpfadelementen ausführbar.

$ java -jar target/${project.build.finalName}.jar

Bereitstellbare Archive erstellen

Die jarDatei kann nur mit dem Geschwisterverzeichnis ausgeführt werden ...lib/. Wir müssen Archive erstellen, um sie mit dem Verzeichnis und seinem Inhalt bereitzustellen.

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-antrun-plugin</artifactId>
  <executions>
    <execution>
      <id>antrun-archive</id>
      <phase>package</phase>
      <goals>
        <goal>run</goal>
      </goals>
      <configuration>
        <target>
          <property name="final.name" value="${project.build.directory}/${project.build.finalName}"/>
          <property name="archive.includes" value="${project.build.finalName}.${project.packaging} ${project.build.finalName}.lib/*"/>
          <property name="tar.destfile" value="${final.name}.tar"/>
          <zip basedir="${project.build.directory}" destfile="${final.name}.zip" includes="${archive.includes}" />
          <tar basedir="${project.build.directory}" destfile="${tar.destfile}" includes="${archive.includes}" />
          <gzip src="${tar.destfile}" destfile="${tar.destfile}.gz" />
          <bzip2 src="${tar.destfile}" destfile="${tar.destfile}.bz2" />
        </target>
      </configuration>
    </execution>
  </executions>
</plugin>

Jetzt haben Sie target/${project.build.finalName}.(zip|tar|tar.bz2|tar.gz)welche jeweils das jarund enthält lib/*.


Apache Maven Assembly Plugin

  • Vorteile
  • Nachteile
    • Keine Unterstützung für Klassenverschiebungen (verwenden Sie das Maven-Shade-Plugin, wenn eine Klassenverschiebung erforderlich ist).
<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-assembly-plugin</artifactId>
  <executions>
    <execution>
      <phase>package</phase>
      <goals>
        <goal>single</goal>
      </goals>
      <configuration>
        <archive>
          <manifest>
            <mainClass>${fully.qualified.main.class}</mainClass>
          </manifest>
        </archive>
        <descriptorRefs>
          <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
      </configuration>
    </execution>
  </executions>
</plugin>

Du hast target/${project.bulid.finalName}-jar-with-dependencies.jar.


Apache Maven Shade Plugin

  • Vorteile
  • Nachteile
<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-shade-plugin</artifactId>
  <executions>
    <execution>
      <goals>
        <goal>shade</goal>
      </goals>
      <configuration>
        <shadedArtifactAttached>true</shadedArtifactAttached>
        <transformers>
          <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
            <mainClass>${fully.qualified.main.class}</mainClass>
          </transformer>
        </transformers>
      </configuration>
    </execution>
  </executions>
</plugin>

Du hast target/${project.build.finalName}-shaded.jar.


onejar-maven-plugin

  • Vorteile
  • Nachteile
    • Seit 2012 nicht mehr aktiv unterstützt.
<plugin>
  <!--groupId>org.dstovall</groupId--> <!-- not available on the central -->
  <groupId>com.jolira</groupId>
  <artifactId>onejar-maven-plugin</artifactId>
  <executions>
    <execution>
      <configuration>
        <mainClass>${fully.qualified.main.class}</mainClass>
        <attachToBuild>true</attachToBuild>
        <!-- https://code.google.com/p/onejar-maven-plugin/issues/detail?id=8 -->
        <!--classifier>onejar</classifier-->
        <filename>${project.build.finalName}-onejar.${project.packaging}</filename>
      </configuration>
      <goals>
        <goal>one-jar</goal>
      </goals>
    </execution>
  </executions>
</plugin>

Spring Boot Maven Plugin

  • Vorteile
  • Nachteile
    • Fügen Sie potenzielle unnötige Spring- und Spring Boot-bezogene Klassen hinzu.
<plugin>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-maven-plugin</artifactId>
  <executions>
    <execution>
      <goals>
        <goal>repackage</goal>
      </goals>
      <configuration>
        <classifier>spring-boot</classifier>
        <mainClass>${fully.qualified.main.class}</mainClass>
      </configuration>
    </execution>
  </executions>
</plugin>

Du hast target/${project.bulid.finalName}-spring-boot.jar.

Jin Kwon
quelle
2
@caiohamamura Sie können das GitHub-Repository klonen und sehen, wie alle Profile funktionieren.
Jin Kwon
Das Problem war mit dem Paket, das ich verwendete: stackoverflow.com/a/12622037/2548351
caiohamamura
1
Ich denke, dies ist wahrscheinlich die vollständigste Antwort auf dieses Thema.
Petr Bodnár
139

Wenn wir die Antwort von Unanswered nehmen und neu formatieren, haben wir:

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <configuration>
                <archive>
                    <manifest>
                        <addClasspath>true</addClasspath>
                        <mainClass>fully.qualified.MainClass</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>
        <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <configuration>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
        </plugin>
    </plugins>
</build>

Als nächstes würde ich empfehlen, dies zu einem natürlichen Teil Ihres Builds zu machen, anstatt es explizit aufzurufen. Um dies zu einem integralen Bestandteil Ihres Builds zu machen, fügen Sie dieses Plugin zu Ihrem hinzu pom.xmlund binden Sie es an das packageLebenszyklusereignis. Ein Problem ist jedoch, dass Sie das assembly:singleZiel aufrufen müssen, wenn Sie es in Ihre pom.xml einfügen, während Sie "Assembly: Assembly" aufrufen würden, wenn Sie es manuell über die Befehlszeile ausführen.

<project>
  [...]
  <build>
      <plugins>
          <plugin>
              <artifactId>maven-assembly-plugin</artifactId>
              <configuration>
                  <archive>
                      <manifest>
                          <addClasspath>true</addClasspath>
                          <mainClass>fully.qualified.MainClass</mainClass>
                      </manifest>
                  </archive>
                  <descriptorRefs>
                      <descriptorRef>jar-with-dependencies</descriptorRef>
                  </descriptorRefs>
              </configuration>
              <executions>
                  <execution>
                      <id>make-my-jar-with-dependencies</id>
                      <phase>package</phase>
                      <goals>
                          <goal>single</goal>
                      </goals>
                  </execution>
              </executions>
          </plugin>
      [...]
      </plugins>
    [...]
  </build>
</project>
Matthew McCullough
quelle
10
Die Verwendung des Ansatzes in dieser Antwort führt zu der folgenden Fehlermeldung: 'Fehler beim Laden des Manifestattributs der Hauptklasse aus <JAR-Datei>', wenn versucht wird, die JAR mit 'java -jar <Jar-Datei>' auszuführen
Elmo
3
Archivteil des maven-jar-Plugins wird benötigt <archive> <manifest> <addClasspath> true </ addClasspath> <mainClass> vollständig qualifiziert.MainClass </ mainClass> </ manifest> </ archive>
Rade_303
4
Entschuldigung, diese Antwort ist einfach falsch. Das mainClass-Tag muss sich im Eintrag des Maven-Assembly-Plugins befinden, da Sie dies während des Paketziels aufrufen
Alex Lehmann,
Ich bin überrascht, warum kann pom.xml dies nicht bereits nach dem Befehl mvn archetype: generate enthalten? Es ist ärgerlich, dies jedes Mal manuell zu kopieren und einzufügen, wenn ich ein neues Maven-Projekt erstelle ...
Wintermute
Ich habe irgendwie keine Hauptmethode oder Klasse, ich habe nur Klasse mit Funktion. Wie kann ich Glas machen und es verwenden
Parlad
97

Verwenden Sie das Maven-Shade-Plugin, um alle Abhängigkeiten in ein Uber-Jar zu packen. Es kann auch zum Erstellen einer ausführbaren JAR-Datei verwendet werden, indem die Hauptklasse angegeben wird. Nachdem ich versucht hatte, Maven-Assembly und Maven-Jar zu verwenden, stellte ich fest, dass dieses Plugin meinen Anforderungen am besten entsprach.

Ich fand dieses Plugin besonders nützlich, da es den Inhalt bestimmter Dateien zusammenführt, anstatt sie zu überschreiben. Dies ist erforderlich, wenn Ressourcendateien in den Jars denselben Namen haben und das Plugin versucht, alle Ressourcendateien zu verpacken

Siehe Beispiel unten

      <plugins>
    <!-- This plugin provides the capability to package the artifact in an uber-jar, including its dependencies and to shade - i.e. rename - the packages of some of the dependencies. -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <version>1.4</version>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                    <configuration>
                        <artifactSet>
                        <!-- signed jars-->
                            <excludes>
                                <exclude>bouncycastle:bcprov-jdk15</exclude>
                            </excludes>
                        </artifactSet>

                         <transformers>
                            <transformer
                                implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                <!-- Main class -->
                                <mainClass>com.main.MyMainClass</mainClass>
                            </transformer>
                            <!-- Use resource transformers to prevent file overwrites -->
                            <transformer 
                                 implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                <resource>properties.properties</resource>
                            </transformer>
                            <transformer
                                implementation="org.apache.maven.plugins.shade.resource.XmlAppendingTransformer">
                                <resource>applicationContext.xml</resource>
                            </transformer>
                            <transformer
                                implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                <resource>META-INF/cxf/cxf.extension</resource>
                            </transformer>
                            <transformer
                                implementation="org.apache.maven.plugins.shade.resource.XmlAppendingTransformer">
                                <resource>META-INF/cxf/bus-extensions.xml</resource>
                            </transformer>
                     </transformers>
                    </configuration>
                </execution>
            </executions>
        </plugin>

    </plugins>
Vijay Katam
quelle
Wie kommt bcprov-jdk15.jar zur Laufzeit in den Klassenpfad, da es vom Shading-Prozess ausgeschlossen ist?
Andrew Swan
Es wurde von cxf-rt-ws-security gezogen, was Teil meiner Abhängigkeiten ist
Vijay Katam
Ich habe noch nie von diesem Plugin gehört, aber es hat mein Problem mit spring.handlers in den Gläsern gelöst. Vielen Dank!
Alexandre L Telles
11
Diejenigen, die eine Sicherheitsausnahme erhalten haben, schließen DSAs aus dem Manifest aus. Überprüfen Sie maven.apache.org/plugins/maven-shade-plugin/examples/…
ruhsuzbaykus
+1 Ich habe in der Vergangenheit minijar: ueberjar verwendet, aber das Minijar-Plugin ist jetzt veraltet und wird durch Schatten ersetzt
8.
19

Ich habe lange das Maven Assembly Plugin verwendet , aber ich konnte keine Lösung für das Problem mit finden "already added, skipping". Jetzt benutze ich ein anderes Plugin - onejar-maven-plugin . Beispiel unten ( mvn packageBuild Jar):

<plugin>
    <groupId>org.dstovall</groupId>
    <artifactId>onejar-maven-plugin</artifactId>
    <version>1.3.0</version>
    <executions>
        <execution>
            <configuration>
                <mainClass>com.company.MainClass</mainClass>
            </configuration>
            <goals>
                <goal>one-jar</goal>
            </goals>
        </execution>
    </executions>
</plugin>

Sie müssen ein Repository für dieses Plugin hinzufügen:

<pluginRepositories>
    <pluginRepository>
        <id>onejar-maven-plugin.googlecode.com</id>
        <url>http://onejar-maven-plugin.googlecode.com/svn/mavenrepo</url>
    </pluginRepository>
</pluginRepositories>
Marioosh
quelle
Wie werden zusätzliche Nachrichten in der Ausgabe entfernt?
Alexandr
17

Sie können das Maven-Dependency-Plugin verwenden, aber die Frage war, wie Sie eine ausführbare JAR erstellen. Um dies zu erreichen, muss die Antwort von Matthew Franglen wie folgt geändert werden (übrigens dauert die Erstellung des Abhängigkeits-Plugins länger, wenn von einem sauberen Ziel ausgegangen wird):

<build>
    <plugins>
        <plugin>
            <artifactId>maven-jar-plugin</artifactId>
            <configuration>
                <archive>
                    <manifest>
                        <mainClass>fully.qualified.MainClass</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>
        <plugin>
            <artifactId>maven-dependency-plugin</artifactId>
            <executions>
                <execution>
                    <id>unpack-dependencies</id>
                    <phase>package</phase>
                    <goals>
                        <goal>unpack-dependencies</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
    <resources>
        <resource>
            <directory>${basedir}/target/dependency</directory>
        </resource>
    </resources>
</build>

quelle
16

Sie können das Maven-Shade-Plugin verwenden, um ein Uber-Glas wie unten zu erstellen

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-shade-plugin</artifactId>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>shade</goal>
            </goals>
        </execution>
    </executions>
</plugin>
Minisha
quelle
Aber wie wird dies dann für das Repo eingesetzt?
Francesco Gualazzi
15

Eine weitere Option, wenn Sie die anderen JAR-Inhalte in Ihrer einzelnen resultierenden JAR wirklich neu verpacken möchten, ist das Maven Assembly-Plugin . Es entpackt und packt dann alles in ein Verzeichnis über <unpack>true</unpack>. Dann hätten Sie einen zweiten Durchgang, der es zu einem massiven JAR machte.

Eine weitere Option ist das OneJar-Plugin . Dies führt die obigen Umpackaktionen in einem Schritt aus.

Matthew McCullough
quelle
14

Sie können Ihrer pom.xml Folgendes hinzufügen :

<build>
<defaultGoal>install</defaultGoal>
<plugins>
  <plugin>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>2.3.2</version>
    <configuration>
      <source>1.6</source>
      <target>1.6</target>
    </configuration>
  </plugin>
  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>2.3.1</version>
    <configuration>
      <archive>
        <manifest>
          <addClasspath>true</addClasspath>
          <mainClass>com.mycompany.package.MainClass</mainClass>
        </manifest>
      </archive>
    </configuration>
  </plugin>
  <plugin>
    <artifactId>maven-assembly-plugin</artifactId>
    <configuration>
      <descriptorRefs>
        <descriptorRef>jar-with-dependencies</descriptorRef>
      </descriptorRefs>
      <archive>
        <manifest>
          <mainClass>com.mycompany.package.MainClass</mainClass>
        </manifest>
      </archive>
    </configuration>
    <executions>
      <execution>
        <id>make-my-jar-with-dependencies</id>
        <phase>package</phase>
        <goals>
          <goal>single</goal>
        </goals>
      </execution>
    </executions>
  </plugin>
</plugins>
</build>

Anschließend müssen Sie über die Konsole in das Verzeichnis wechseln, in dem sich die Datei pom.xml befindet. Dann müssen Sie mvn assembly: single ausführen und dann wird hoffentlich Ihre ausführbare JAR-Datei mit Abhängigkeiten erstellt. Sie können dies überprüfen, wenn Sie mit cd ./target in das Ausgabeverzeichnis (Zielverzeichnis) wechseln und Ihr jar mit einem Befehl starten , der java -jar mavenproject1-1.0-SNAPSHOT-jar-with-dependencies.jar ähnelt .

Ich habe dies mit Apache Maven 3.0.3 getestet .

Benny Neugebauer
quelle
13

Ich habe jede dieser Antworten durchgesehen, um ein fettes ausführbares Glas zu erstellen, das alle Abhängigkeiten enthält, und keine davon hat richtig funktioniert. Die Antwort ist das Schatten-Plugin, es ist sehr einfach und unkompliziert.

    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-shade-plugin</artifactId>
      <version>2.3</version>
      <executions>
         <!-- Run shade goal on package phase -->
        <execution>
        <phase>package</phase>
        <goals>
            <goal>shade</goal>
        </goals>
        <configuration>
          <transformers>
             <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                <mainClass>path.to.MainClass</mainClass>
             </transformer>
          </transformers>
        </configuration>
          </execution>
      </executions>
    </plugin>

Beachten Sie, dass Ihre Abhängigkeiten über einen Kompilierungs- oder Laufzeitbereich verfügen müssen, damit dies ordnungsgemäß funktioniert.

Dieses Beispiel stammt von mkyong.com

dsutherland
quelle
Wenn ich das behoben habe, würde es Ihnen etwas ausmachen, Ihre Bewertung zu aktualisieren. Ich hatte Ihre Gedanken vor dem Posten nicht berücksichtigt und schnell eine Korrektur vorgenommen, als ich Ihren Kommentar sah
dsutherland
2
Das pluginElement geht pom.xmlunter build/plugins.
Isapir
12

Sie könnten das maven-shade-pluginund kombinieren maven-jar-plugin.

  • Das maven-shade-pluginpackt Ihre Klassen und alle Abhängigkeiten in eine einzige JAR-Datei.
  • Konfigurieren Sie die maven-jar-plugindie Hauptklasse Ihres ausführbaren jar angeben (siehe Set Up The Classpath , Kapitel "Make The Jar Executable").

Beispiel für eine POM-Konfiguration für maven-jar-plugin:

        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>2.3.2</version>
            <configuration>
                <archive>
                    <manifest>
                        <addClasspath>true</addClasspath>
                        <mainClass>com.example.MyMainClass</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>

Erstellen Sie abschließend die ausführbare JAR-Datei, indem Sie Folgendes aufrufen:

mvn clean package shade:shade
Oliver
quelle
3
Das Shade-Plugin hat jetzt die Möglichkeit, den Hauptklasseneintrag
Chadwick
9

Ken Liu hat es meiner Meinung nach richtig. Mit dem Maven-Abhängigkeits-Plugin können Sie alle Abhängigkeiten erweitern, die Sie dann als Ressourcen behandeln können. Auf diese Weise können Sie sie in das Hauptartefakt aufnehmen . Durch die Verwendung des Assembly-Plugins wird ein sekundäres Artefakt erstellt, das möglicherweise nur schwer geändert werden kann. In meinem Fall wollte ich benutzerdefinierte Manifesteinträge hinzufügen. Mein Pom endete als:

<project>
 ...
 <build>
  <plugins>
   <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <executions>
     <execution>
      <id>unpack-dependencies</id>
      <phase>package</phase>
      <goals>
       <goal>unpack-dependencies</goal>
      </goals>
     </execution>
    </executions>
   </plugin>
  </plugins>
  ...
  <resources>
   <resource>
    <directory>${basedir}/target/dependency</directory>
    <targetPath>/</targetPath>
   </resource>
  </resources>
 </build>
 ...
</project>
Matthew Franglen
quelle
1
Wirklich nett! Wäre es nicht besser, die Phase zum Generieren von Ressourcen zum Auspacken zu verwenden?
Nawroth
9

Es sollte so sein:

<plugin>
    <artifactId>maven-dependency-plugin</artifactId>
    <executions>
        <execution>
            <id>unpack-dependencies</id>
            <phase>generate-resources</phase>
            <goals>
                <goal>unpack-dependencies</goal>
            </goals>
        </execution>
    </executions>
</plugin>

Das Entpacken muss sich in der Phase "Ressourcen generieren" befinden, da es in der Paketphase nicht als Ressourcen enthalten ist. Versuchen Sie es mit einem sauberen Paket und Sie werden sehen.

kac-ani
quelle
7

Problem beim Auffinden der freigegebenen Assembly-Datei mit dem Maven-Assembly-Plugin-2.2.1?

Versuchen Sie, den Konfigurationsparameter deskriptors ID anstelle der Parameter deskriptoren / deskriptor oder deskriptorsRefs / deskriptors zu verwenden.

Keiner von beiden tut das, was Sie brauchen: Suchen Sie im Klassenpfad nach der Datei. Natürlich müssen Sie das Paket hinzufügen, in dem sich die gemeinsam genutzte Assembly im Klassenpfad des Maven-Assembly-Plugins befindet (siehe unten). Wenn Sie Maven 2.x (nicht Maven 3.x) verwenden, müssen Sie diese Abhängigkeit möglicherweise in der obersten übergeordneten Datei pom.xml im Abschnitt pluginManagement hinzufügen.

Sehen Sie dies für weitere Details.

Klasse: org.apache.maven.plugin.assembly.io.DefaultAssemblyReader

Beispiel:

        <!-- Use the assembly plugin to create a zip file of all our dependencies. -->
        <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>2.2.1</version>
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                    <configuration>
                        <descriptorId>assembly-zip-for-wid</descriptorId>
                    </configuration>
                </execution>
            </executions>
            <dependencies>
                <dependency>
                    <groupId>cz.ness.ct.ip.assemblies</groupId>
                    <artifactId>TEST_SharedAssemblyDescriptor</artifactId>
                    <version>1.0.0-SNAPSHOT</version>
                </dependency>
            </dependencies>
        </plugin>
Rostislav Stříbrný
quelle
7

Um dieses Problem zu beheben, verwenden wir das Maven Assembly Plugin, das die JAR zusammen mit ihren Abhängigkeits-JARs in einer einzigen ausführbaren JAR-Datei erstellt. Fügen Sie einfach die folgende Plugin-Konfiguration in Ihre pom.xml-Datei ein.

<build>
   <pluginManagement>
      <plugins>
         <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <configuration>
               <archive>
                  <manifest>
                     <addClasspath>true</addClasspath>
                     <mainClass>com.your.package.MainClass</mainClass>
                  </manifest>
               </archive>
               <descriptorRefs>
                  <descriptorRef>jar-with-dependencies</descriptorRef>
               </descriptorRefs>
            </configuration>
            <executions>
               <execution>
                  <id>make-my-jar-with-dependencies</id>
                  <phase>package</phase>
                  <goals>
                     <goal>single</goal>
                  </goals>
               </execution>
            </executions>
         </plugin>
      </plugins>
   </pluginManagement>
</build>

Vergessen Sie danach nicht, das MAVEN-Tool mit dem Befehl mvn clean compile Assembly: single auszuführen

http://jkoder.com/maven-creating-a-jar-together-with-its-dependency-jars-into-a-single-executable-jar-file/

Anoop Rai
quelle
5

Ich werde die Frage nicht direkt beantworten, da andere dies bereits getan haben, aber ich frage mich wirklich, ob es eine gute Idee ist, alle Abhängigkeiten in das Projektglas selbst einzubetten.

Ich sehe den Punkt (einfache Bereitstellung / Verwendung), aber es hängt vom Anwendungsfall Ihres Projekts ab (und es kann Alternativen geben (siehe unten)).

Wenn Sie es vollständig eigenständig verwenden, warum nicht?

Wenn Sie Ihr Projekt jedoch in anderen Kontexten verwenden (z. B. in einer Webanwendung oder in einem Ordner, in dem sich andere Jars befinden), befinden sich möglicherweise JAR-Duplikate in Ihrem Klassenpfad (die im Ordner, die in den Jars). Vielleicht kein Angebot, aber ich vermeide dies normalerweise.

Eine gute Alternative:

  • Stellen Sie Ihre Anwendung als .zip / .war bereit: Das Archiv enthält die JAR-Datei Ihres Projekts und alle abhängigen JARs.
  • Verwenden Sie einen dynamischen Klassenlademechanismus (siehe Spring, oder Sie können dies ganz einfach selbst tun), um einen einzelnen Einstiegspunkt für Ihr Projekt zu erhalten (eine einzelne Klasse zum Starten - siehe Manifest-Mechanismus für eine andere Antwort), der (dynamisch) zum hinzugefügt wird aktueller Klassenpfad alle anderen benötigten Gläser.

So können Sie mit nur einem Manifest und einem "speziellen dynamischen Klassenladeprogramm" Ihr Projekt starten mit:

java -jar ProjectMainJar.jar com.stackoverflow.projectName.MainDynamicClassLoaderClass
SRG
quelle
1
Wie werden dann das Projektglas und alle abhängigen Gläser in ein Archiv gestellt?
4

Um eine ausführbare JAR über die Befehlszeile selbst zu erstellen, führen Sie einfach den folgenden Befehl über den Projektpfad aus:

mvn assembly:assembly
Mayank
quelle
3
Ich denke, du musst noch ein paar Sachen machen, pom.xmlsonst bekommst du Error reading assemblies: No assembly descriptors found.. Das passiert mir sowieso.
Sridhar Sarnobat
3

Dies ist der beste Weg, den ich gefunden habe:

  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>2.4</version>
    <configuration>
      <archive>
        <manifest>
        <addClasspath>true</addClasspath>
        <mainClass>com.myDomain.etc.MainClassName</mainClass>
        <classpathPrefix>dependency-jars/</classpathPrefix>
        </manifest>
      </archive>
    </configuration>
  </plugin>
  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <version>2.5.1</version>
    <executions>
      <execution>
        <id>copy-dependencies</id>
        <phase>package</phase>
        <goals>
            <goal>copy-dependencies</goal>
        </goals>
        <configuration>
            <outputDirectory>
               ${project.build.directory}/dependency-jars/
            </outputDirectory>
        </configuration>
      </execution>
    </executions>
  </plugin>

Bei dieser Konfiguration befinden sich alle Abhängigkeiten in /dependency-jars. Meine Anwendung hat keine MainKlasse, nur Kontext-Klassen, aber eine meiner Abhängigkeiten hat eine MainKlasse ( com.myDomain.etc.MainClassName), die den JMX-Server startet und eine empfängtstart oder einen stopParameter . Damit konnte ich meine Bewerbung folgendermaßen starten:

java -jar ./lib/TestApp-1.0-SNAPSHOT.jar start

Ich warte, es ist nützlich für euch alle.

EliuX
quelle
3

Ich habe die in diesem Beitrag erwähnten Baum-Plugins verglichen. Ich habe 2 Gläser und ein Verzeichnis mit allen Gläsern generiert. Ich habe die Ergebnisse verglichen und definitiv ist das Maven-Shade-Plugin das Beste. Meine Herausforderung bestand darin, dass ich über mehrere Spring-Ressourcen verfügte, die zusammengeführt werden mussten, sowie über Jax-Rs und JDBC-Services. Sie wurden alle vom Schatten-Plugin im Vergleich zum Maven-Assembly-Plugin richtig zusammengeführt. In diesem Fall schlägt die Feder fehl, es sei denn, Sie kopieren sie in Ihren eigenen Ressourcenordner und führen sie einmal manuell zusammen. Beide Plugins geben den richtigen Abhängigkeitsbaum aus. Ich hatte mehrere Bereiche wie testen, bereitstellen, kompilieren usw. Der Test und die bereitgestellten wurden von beiden Plugins übersprungen. Beide haben das gleiche Manifest erstellt, aber ich konnte Lizenzen mit dem Shadow-Plugin mithilfe ihres Transformators konsolidieren. Mit dem Maven-Dependency-Plugin natürlich nicht ' Ich habe diese Probleme nicht, weil die Gläser nicht extrahiert werden. Aber wie einige andere darauf hingewiesen haben, müssen Sie eine zusätzliche Datei (en) mit sich führen, um ordnungsgemäß zu funktionieren. Hier ist ein Ausschnitt aus der pom.xml

            <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <executions>
                <execution>
                    <id>copy-dependencies</id>
                    <phase>prepare-package</phase>
                    <goals>
                        <goal>copy-dependencies</goal>
                    </goals>
                    <configuration>
                        <outputDirectory>${project.build.directory}/lib</outputDirectory>
                        <includeScope>compile</includeScope>
                        <excludeTransitive>true</excludeTransitive>
                        <overWriteReleases>false</overWriteReleases>
                        <overWriteSnapshots>false</overWriteSnapshots>
                        <overWriteIfNewer>true</overWriteIfNewer>
                    </configuration>
                </execution>
            </executions>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>2.6</version>
            <configuration>
                <archive>
                    <manifest>
                        <addClasspath>true</addClasspath>
                        <mainClass>com.rbccm.itf.cdd.poller.landingzone.LandingZonePoller</mainClass>
                    </manifest>
                </archive>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
            <executions>
                <execution>
                    <id>make-my-jar-with-dependencies</id>
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <version>2.4.3</version>
            <configuration>
                <shadedArtifactAttached>false</shadedArtifactAttached>
                <keepDependenciesWithProvidedScope>false</keepDependenciesWithProvidedScope>
                <transformers>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                        <resource>META-INF/services/javax.ws.rs.ext.Providers</resource>
                    </transformer>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                        <resource>META-INF/spring.factories</resource>
                    </transformer>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                        <resource>META-INF/spring.handlers</resource>
                    </transformer>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                        <resource>META-INF/spring.schemas</resource>
                    </transformer>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                        <resource>META-INF/spring.tooling</resource>
                    </transformer>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer"/>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.ApacheLicenseResourceTransformer">
                    </transformer>
                </transformers>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
Fabio
quelle
2

Etwas, das für mich funktioniert hat, war:

  <plugin>
    <artifactId>maven-dependency-plugin</artifactId>
    <executions>
      <execution>
        <id>unpack-dependencies</id>
        <phase>prepare-package</phase>
        <goals>
          <goal>unpack-dependencies</goal>
        </goals>
        <configuration>
          <outputDirectory>${project.build.directory}/classes</outputDirectory>
        </configuration>
      </execution>

    </executions>
  </plugin>


  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <executions>
      <execution>
        <id>unpack-dependencies</id>
        <phase>package</phase>
      </execution>
    </executions>
    <configuration>
      <archive>
        <manifest>
          <addClasspath>true</addClasspath>
          <classpathPrefix>lib/</classpathPrefix>
          <mainClass>SimpleKeyLogger</mainClass>
        </manifest>
      </archive>
    </configuration>
  </plugin>

Ich hatte einen außergewöhnlichen Fall, weil meine Abhängigkeit System eins war:

<dependency>
  ..
  <scope>system</scope>
  <systemPath>${project.basedir}/lib/myjar.jar</systemPath>
</dependency>

Ich habe den von @ user189057 bereitgestellten Code mit folgenden Änderungen geändert: 1) Das Maven-Dependency-Plugin wird in der Phase "Prepare-Package" ausgeführt. 2) Ich extrahiere die entpackte Klasse direkt in "Ziel / Klassen".

fascynacja
quelle
2

Ich habe hier die am besten gewählte Antwort versucht und konnte das Glas zum Laufen bringen. Das Programm lief jedoch nicht richtig. Ich weiß nicht, was der Grund war. Wenn ich versuche wegzulaufenEclipse , erhalte ich ein anderes Ergebnis, aber wenn ich das JAR über die Befehlszeile , erhalte ich ein anderes Ergebnis (es stürzt mit einem programmspezifischen Laufzeitfehler ab).

Ich hatte eine ähnliche Anforderung wie das OP, nur dass ich zu viele (Maven) Abhängigkeiten für mein Projekt hatte. Glücklicherweise war die einzige Lösung, die für mich funktionierte, die Verwendung Eclipse. Sehr einfach und sehr unkompliziert. Dies ist keine Lösung für das OP, sondern eine Lösung für jemanden, der eine ähnliche Anforderung hat, aber viele Maven-Abhängigkeiten hat.

1) Klicken Sie einfach mit der rechten Maustaste auf Ihren Projektordner (in Eclipse) und wählen Sie Export

2) Wählen Sie dann Java->Runnable Jar

3) Sie werden aufgefordert, den Speicherort der JAR-Datei auszuwählen

4) Wählen Sie abschließend die Klasse mit der Hauptmethode aus, die Sie ausführen möchten, und wählen Sie sie aus Package dependencies with the Jar fileund klicken Sie daraufFinish

Rocky Inde
quelle
2

Dies könnte auch eine Option sein. Sie können Ihre JAR-Datei erstellen

<build>
    <plugins>
        <plugin>
            <!-- Build an executable JAR -->
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>2.4</version>
            <configuration>
                <archive>
                    <manifest>
                        <addClasspath>true</addClasspath>
                        <classpathPrefix>lib/</classpathPrefix>
                        <mainClass>WordListDriver</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>
    </plugins>
</build>
salmanbw
quelle
2

Für alle, die nach Optionen suchen, um bestimmte Abhängigkeiten aus dem Uber-Jar auszuschließen, ist dies eine Lösung, die für mich funktioniert hat:

<project...>
<dependencies>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.11</artifactId>
            <version>1.6.1</version>
            <scope>provided</scope> <=============
        </dependency>
</dependencies>
<build>
        <plugins>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                    <archive>
                        <manifest>
                            <mainClass>...</mainClass>
                        </manifest>
                    </archive>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Es handelt sich also nicht um eine Konfiguration des MVN-Assembly-Plugins, sondern um eine Eigenschaft der Abhängigkeit.

Paul Bormans
quelle
2

Es gibt bereits Millionen von Antworten. Ich wollte hinzufügen, dass Sie nicht benötigen, <mainClass>wenn Sie Ihrer Anwendung keinen entryPoint hinzufügen müssen. Beispielsweise müssen APIs nicht unbedingt über eine mainMethode verfügen .

Maven Plugin Konfiguration

  <build>
    <finalName>log-enrichment</finalName>
    <plugins>
      <plugin>
        <artifactId>maven-assembly-plugin</artifactId>
        <configuration>
          <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
          </descriptorRefs>
        </configuration>
      </plugin>
    </plugins>
  </build>

bauen

mvn clean compile assembly:single

überprüfen

ll target/
total 35100
drwxrwx--- 1 root vboxsf     4096 Sep 29 16:25 ./
drwxrwx--- 1 root vboxsf     4096 Sep 29 16:25 ../
drwxrwx--- 1 root vboxsf        0 Sep 29 16:08 archive-tmp/
drwxrwx--- 1 root vboxsf        0 Sep 29 16:25 classes/
drwxrwx--- 1 root vboxsf        0 Sep 29 16:25 generated-sources/
drwxrwx--- 1 root vboxsf        0 Sep 29 16:25 generated-test-sources/
-rwxrwx--- 1 root vboxsf 35929841 Sep 29 16:10 log-enrichment-jar-with-dependencies.jar*
drwxrwx--- 1 root vboxsf        0 Sep 29 16:08 maven-status/
betenagupd
quelle
2

Zur pom.xml hinzufügen:

  <dependency>
            <groupId>com.jolira</groupId>
            <artifactId>onejar-maven-plugin</artifactId>
            <version>1.4.4</version>
  </dependency>

und

<plugin>
       <groupId>com.jolira</groupId>
       <artifactId>onejar-maven-plugin</artifactId>
       <version>1.4.4</version>
       <executions>
              <execution>
                     <goals>
                         <goal>one-jar</goal>
                     </goals>
              </execution>
       </executions>
</plugin>

Das ist es. Das nächste MVN-Paket erstellt zusätzlich ein Fettglas, einschließlich aller Abhängigkeitsgläser.

Aydin K.
quelle
1

Das Maven-Assembly-Plugin hat bei mir super funktioniert. Ich habe Stunden mit dem Maven-Dependency-Plugin verbracht und konnte es nicht zum Laufen bringen. Der Hauptgrund war, dass ich im Konfigurationsabschnitt explizit die Artefaktelemente definieren musste, die enthalten sein sollten, wie es in der Dokumentation beschrieben ist . Es gibt dort ein Beispiel für die Fälle, in denen Sie es verwenden möchten, wie:, mvn dependency:copyin denen keine Artefaktelemente enthalten sind, es aber nicht funktioniert.

Chris
quelle
1

Dieser Blog-Beitrag zeigt einen anderen Ansatz mit der Kombination der Plugins Maven-Jar und Maven-Assembly. Mit der Assembly-Konfigurations-XML aus dem Blog-Beitrag kann auch gesteuert werden, ob Abhängigkeiten erweitert oder nur in einem Ordner gesammelt und durch einen Klassenpfadeintrag im Manifest referenziert werden:

Die ideale Lösung besteht darin, die Jars in einen lib-Ordner aufzunehmen, und die manifest.mf-Datei des Hauptglases enthält alle Jars im Klassenpfad.

Und genau das wird hier beschrieben: https://caffebig.wordpress.com/2013/04/05/executable-jar-file-with-dependent-jars-using-maven/

Jan Ziegler
quelle
0
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>2.4.1</version>
            <configuration>
                <!-- get all project dependencies -->
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <!-- bind to the packaging phase -->
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>
Shang Gao
quelle
1
Brauchen Sie ein bisschen mehr Erklärung dafür; Sind diese Kommentare nur Dokumentationen oder müssen zusätzliche Optionen an den Positionen dieser Kommentare platziert werden?
Mark Stewart
-2

Okay, das ist meine Lösung. Ich weiß, dass die Datei pom.xml nicht verwendet wird. Ich hatte jedoch das Problem, dass mein Programm auf Netbeans kompiliert und ausgeführt wurde, aber es schlug fehl, als ich Java -jar MyJarFile.jar ausprobierte. Jetzt verstehe ich Maven nicht ganz und ich denke, aus diesem Grund hatte Netbeans 8.0.2 Probleme, meine JAR-Datei in eine Bibliothek aufzunehmen, um sie in eine JAR-Datei zu kopieren. Ich habe darüber nachgedacht, wie ich in Eclipse JAR-Dateien ohne Maven verwendet habe.

Es ist Maven, der alle Abhängigkeiten und Plugins kompilieren kann. Nicht Netbeans. (Wenn Sie Netbeans erhalten und Java .jar verwenden können, sagen Sie mir bitte, wie (^. ^) V)

[Gelöst - für Linux] durch Öffnen eines Terminals.

Dann

cd /MyRootDirectoryForMyProject

Nächster

mvn org.apache.maven.plugins:maven-compiler-plugin:compile

Nächster

mvn install

Dadurch wird eine JAR-Datei im Zielverzeichnis erstellt.

MyJarFile-1.0-jar-with-dependencies.jar

Jetzt

cd target

(Möglicherweise müssen Sie Folgendes ausführen: chmod +x MyJarFile-1.0-jar-with-dependencies.jar )

Und schlussendlich

java -jar MyJarFile-1.0-jar-with-dependencies.jar

Bitte sehen Sie

https://cwiki.apache.org/confluence/display/MAVEN/LifecyclePhaseNotFoundException

Ich werde diese Lösung auf einigen anderen Seiten mit einem ähnlichen Problem veröffentlichen. Hoffentlich kann ich jemanden vor einer Woche der Frustration retten.

Mycowan
quelle
2
Versuchen Sie, das mit Netbeans erstellte Maven-Projekt zu öffnen. Die Grundregel von Netbeans ist immer, ein Maven-Projekt und niemals eine 'Java-Anwendung' zu erstellen. Fügen Sie ein Maven-Shade-Plugin wie eine der Antworten hinzu. Klappt wunderbar.
rjdkolb