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

StackOverflow https://stackoverflow.com/questions/574594

Frage

Ich mag mein Projekt in einer einzigen ausführbaren JAR für die Verteilung verpacken.

Wie kann ich ein Maven Projektpaket alle Abhängigkeits JARs in meiner Ausgabe JAR machen?

War es hilfreich?

Lösung 

<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 führen Sie es mit 

mvn clean compile assembly:single

Kompilieren Ziel soll vor der Montage hinzugefügt werden: Einzel- oder sonst der Code auf Ihrem eigenes Projekt ist nicht inbegriffen

.

Sehen Sie mehr Details in den Kommentaren.

Im Allgemeinen wird dieses Ziel mit einer Aufbauphase gebunden automatisch auszuführen. Dadurch wird sichergestellt, die JAR gebaut wird, wenn die Ausführung mvn install oder ein Deployment / Freigabe durchgeführt 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>

Andere Tipps

Sie können die abhängigkeits Plugin verwenden, um alle Abhängigkeiten in einem separaten Verzeichnis, bevor das Paket Phase zu erzeugen, und dann schließen, dass in dem Classpath des Manifests: 

<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 verwenden ${project.build.directory}/classes/lib als Output alle jar-Dateien in das Hauptglas zu integrieren, aber dann müssen Sie benutzerdefinierten Classloading Code hinzufügen, um die Gläser zu laden.

ich gebloggt über einige verschiedene Möglichkeiten, dies zu tun.

Siehe Executable Jar mit Apache Maven (Wordpress)

oder ausführbare-jar-with-Maven-Beispiel (GitHub )

Notizen

Diese Vor-und Nachteile werden von Stephan .

Für Manuelle Bereitstellung

  • Pros
  • Cons
    • Abhängigkeiten sind aus dem letzten Glas.

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

An diesem Punkt die jar ist tatsächlich ausführbar mit externen Classpath Elementen. 

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

Make Bereitstellbar Archiv

Die jar Datei ist nur ausführbare Datei mit dem Geschwister ...lib/ Verzeichnis. Wir müssen Archive machen mit dem Verzeichnis und dessen Inhalt zu implementieren. 

<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) die jeweils enthält die jar und lib/*.

Apache Maven Assembly Plugin

  • Pros
  • Cons
    • Keine Klasse Relocation-Unterstützung (Verwendung Maven-Schatten-Plugin, wenn Klasse Verlagerung ist erforderlich). 
<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>

Sie haben target/${project.bulid.finalName}-jar-with-dependencies.jar.

Apache Maven Shade Plugin

  • Pros
  • Cons 
<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>

Sie haben target/${project.build.finalName}-shaded.jar.

onejar-Maven-Plugin

  • Pros
  • Cons
    • Nicht aktiv seit 2012 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>

Frühling Boot-Maven Plugin

  • Pros
  • Cons
    • Fügen Potential unecessary Spring and Spring Boot-verwandte Klassen. 
<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>

Sie haben target/${project.bulid.finalName}-spring-boot.jar.

Unter Offener Antwort und Neuformatierung, die wir haben: 

<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, das ein natürlicher Teil des Build machen, anstatt etwas explizit zu nennen. dies ein integraler Bestandteil Ihres Build zu machen, fügen Sie das Plugin auf Ihre pom.xml und binden Sie es an den package Lifecycle-Ereignis. Allerdings ist eine Gotcha ist, dass Sie das assembly:single Ziel anrufen müssen, wenn dies in Ihrem pom.xml setzen, während Sie nennen würden ‚Montag: Montag‘. Wenn 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>

Mit der Maven-Schatten-Plugin alle Abhängigkeiten in einem uber-jar zu verpacken. Es kann auch eine ausführbare jar zu bauen durch die Angabe der Hauptklasse verwendet werden. Nach dem Versuch, Maven-Montage und Maven-Glas zu verwenden, fand ich, dass dieses Plugin meiner Bedürfnisse am besten geeignet ist.

Ich fand dieses Plugin besonders nützlich, da es Inhalte bestimmter Dateien verschmilzt, anstatt sie zu überschreiben. Dies ist erforderlich, wenn Ressourcendateien gibt, die den gleichen Namen für die Gläser haben und das Plugin versucht, alle Ressource-Dateien 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>

Lange verwendet, um die Maven Montage Plugin , aber ich konnte keine Lösung für das Problem mit "already added, skipping" . Nun, ich bin mit einem anderen Plugin - onejar-Maven-Plugin . Beispiel unten (mvn package build 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 hinzufügen Repository für das Plugin: 

<pluginRepositories>
    <pluginRepository>
        <id>onejar-maven-plugin.googlecode.com</id>
        <url>http://onejar-maven-plugin.googlecode.com/svn/mavenrepo</url>
    </pluginRepository>
</pluginRepositories>

Sie können mit Maven-Abhängigkeit-Plugin, aber die Frage war, wie eine ausführbare JAR zu erstellen. Um dies zu tun erfordert Antwort die folgende Änderung Matthew Franglen der (btw, nimmt die Abhängigkeit Plugin länger zu bauen, wenn sie von einem sauberen Soll-Start): 

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

Eine andere Option, wenn Sie wirklich die anderen JARs Inhalte in Ihrem einzelnen resultierenden JAR neu zu verpacken will, ist die Eine weitere Option ist die OneJar Plugin . Dies führt die oben Umpacken alle Aktionen in einem Schritt.

Sie können fügen Sie folgendes zu Ihrem pom.xml : 

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

Danach haben Sie über die Konsole in das Verzeichnis wechseln, in dem der pom.xml befindet. Dann müssen Sie ausführen mvn assembly: Single und dann ausführbare JAR-Datei mit Abhängigkeiten werden hoffentlich bauen. Sie können es, wenn mit dem Ausgang (Ziel) Verzeichnis mit cd ./target und starten Sie Ihr Glas mit einem Befehl ähnlich zu java -jar mavenproject1-1.0-snapshot-jar-mit- Schalen dependencies.jar .

Getestet habe ich diese mit Apache Maven 3.0.3 .

Sie können die maven-shade-plugin und maven-jar-plugin kombinieren.

  • Die maven-shade-plugin packt Ihre Klassen und alle Abhängigkeiten in einer einzigen JAR-Datei.
  • die maven-jar-plugin Konfigurieren Sie die Hauptklasse Ihres ausführbare jar angeben (siehe Einrichten Der Classpath , Kapitel "Make The Jar Executable").

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

Schließlich die ausführbare jar erstellen durch den Aufruf: 

mvn clean package shade:shade

ging ich durch jede dieser Antworten suchen, um eine Fett ausführbare jar alle Abhängigkeiten enthalten zu machen und keiner von ihnen arbeitete richtig. Die Antwort ist die 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 brauchen einen Umfang von Kompilierung oder zur Laufzeit für diese haben ordnungsgemäß funktioniert.

Dieses Beispiel stammt aus mkyong.com

Sie können Maven-Schatten-Plugin verwenden, um ein Glas uber wie unter

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

Ken Liu hat es richtig in meiner Meinung nach. Die Maven-Abhängigkeit-Plugin ermöglicht es Ihnen, alle Abhängigkeiten zu erweitern, die Sie dann als Ressourcen behandeln. Auf diese Weise können Sie diese in der main Artefakt aufzunehmen. Die Verwendung der Anordnung Plugin erzeugt eine sekundäre Artefakt, das nur schwer zu ändern - in meinem Fall habe ich benutzerdefiniertes manifest Einträge hinzufügen wollte. 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>

Hier ist eine ausführbare jar-Plugin für Maven, die wir bei der Credit Karma verwenden. Es schafft ein Glas Glas mit einem Klassenlader der Lage Belastungsklassen von verschachtelten Gläsern. Auf diese Weise können Sie die gleiche Classpath in dev und prod haben und immer noch alle Klassen in einer einzigen signierten JAR-Datei.

https://github.com/creditkarma/maven-exec-jar-plugin

Und hier ist eine Blog-Post mit Informationen über das Plugin und warum wir es gemacht: https://engineering.creditkarma.com/ General-Engineering / new-ausführbaren-jar-plugin-verfügbar-apache-maven /

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>

Auspacken müssen sein in generate-Ressourcen Phase, denn wenn in Paket Phase wird nicht als Ressourcen einbezogen werden. Versuchen sauber Paket und Sie werden sehen.

Verwenden Sie onejar Plugin , um es als eine ausführbare jar zu bauen Datei, die alle dependancy Gläser darin verpackt. Das löste mein Problem, das auf diese ähnlich war. Wenn die Montage-Plugin verwendet wurde, packte er alle dependancy Gläser in Quellordner und packen sie als Glas, hatte es über geschrieben alle ähnliche Implementierungen ich in meinem Code hatte, die die gleichen Klassennamen hatten. onejar ist eine einfache Lösung hier.

Problem mit geteiltem Baugruppendatei Ortung mit Maven-Montage-plugin-2.2.1?

Versuchen descriptorId Konfigurationsparameter statt Deskriptoren / Descriptor oder descriptorRefs / descriptorRef Parameter angeben können.

Keiner von ihnen tun, was Sie brauchen: suchen Sie die Datei auf Classpath. Natürlich müssen Sie das Paket hinzugefügt werden, wobei die freigegebene Assembly auf Maven-Montage-Plugins Classpath befindet (siehe unten). Wenn Sie mit Maven 2.x (nicht Maven 3.x), müssen Sie diese Abhängigkeit Zugabe in der obersten meisten Eltern pom.xml in pluginManagement Abschnitt.

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

Ich werde nicht direkt die Frage beantworten, wie andere schon zuvor getan haben, aber ich frage mich wirklich, ob es eine gute Idee ist, alle Abhängigkeiten in dem Projekt jar einzubetten selbst.

Ich sehe den Punkt (einfache Bereitstellung / Nutzung), aber es hängt von dem Anwendungsfall Ihrer poject (und es kann Alternativen sein (siehe unten)).

Wenn Sie es völlig eigenständige, warum nicht.

Aber wenn Sie Ihr Projekt in einem anderen Kontext verwenden (wie in einer Webapp oder in einem Ordner abgelegt, wo andere Gläser sitzen), können Sie jar Duplikate in Ihrem Classpath (die, die in den Ordner haben, die man in den Gläsern ). Vielleicht kein Gebot Deal, aber ich dies in der Regel vermeiden.

Eine gute Alternative:

  • Bereitstellung Ihrer Anwendung als ZIP / .war: das Archiv Ihres Projekts Glas enthält und alle abhängigen Gläser;
  • verwenden, um einen dynamischen Classloader-Mechanismus (siehe Spring, oder Sie können diese ganz einfach selbst tun) einen einzigen Eintrittspunkt des Projekts zu haben (eine einzige Klasse zu starten - das Manifest Mechanismus auf eine andere Antwort sehen), die hinzufügen werden (dynamisch ) auf den aktuellen classpath alle anderen benötigten Gläser.

Wie diese mit am Ende nur ein Manifests und ein „besonderer Dynamik Classloader main“, können Sie Ihr Projekt mit Start: 

java -jar ProjectMainJar.jar com.stackoverflow.projectName.MainDynamicClassLoaderClass

Um dieses Problem zu lösen wir Maven Assembly Plugin nutzen, die die JAR zusammen mit seiner Abhängigkeit JAR-Dateien in eine einzige ausführbare JAR-Datei erstellen werden. Fügen Sie einfach unten Plugin-Konfiguration in Ihrer pom.xml-Datei. 

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

Nach dem Handeln dies nicht vergessen MAVEN Werkzeug mit dieser Befehl mvn sauberen Übersetzung Montag auszuführen: Single

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

Ich vergleichen den Baum-Plugins in diesem Beitrag erwähnt. Ich erzeugen 2 Gläser und ein Verzeichnis mit allen Gläsern. Ich vergleichen die Ergebnisse und auf jeden Fall die Maven-Schatten-Plugin ist die beste. Meine Herausforderung war, dass ich mehrere Federn Ressourcen habe, die zusammengeführt werden müssen, sowie JAX-RS-und JDBC-Dienste. Sie waren alle richtig im Schatten Plugin im Vergleich mit der Maven-Montage-Plugin verschmolzen. In diesem Fall wird die Feder fehlschlagen, wenn Sie sie zu Ihren eigenen Ressourcen-Ordner kopieren und die Inhalte von Hand einmal. Beide Plug-ins Ausgabe des richtige Abhängigkeitsbaum. Ich hatte mehrere Bereiche wie Test liefern, kompilieren, etc den Test und zur Verfügung gestellt von den beiden Plugins übersprungen wurden. Beide erzeugen das gleiche manifest, aber ich war in der Lage Lizenzen mit Schatten-Plugin zu konsolidieren, um ihren Transformator. Mit der Maven-Abhängigkeit-Plugin natürlich müssen Sie nicht diese Probleme, weil die Gläser nicht extrahiert werden. Aber wie einige andere haben darauf Sie eine zusätzliche Datei (en) zu tragen brauchen, um richtig zu arbeiten. Hier ist ein Schnipsel 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>

Um eine ausführbare JAR von der Kommandozeile erstellen sich einfach den unten Befehl aus dem Projektpfad laufen: 

mvn assembly:assembly

Sie können auch dieses Plug-in verwenden, ist es ziemlich gut und ich benutze es meine Gläser für die Verpackung von

Etwas, das für mich gearbeitet 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 außergewöhnlichen Fall, weil mein Abhängigkeitssystem war: 

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

Ich habe den Code zur Verfügung gestellt geändert durch @ user189057 mit Änderungen: 1) maven-Abhängigkeit-Plugin ist in "prepare-Paket" Phase ausgeführt 2) Ich bin Extrahieren entpackten jeweilige Kategorie direkt an "target / classes"

Ich habe versucht, die meisten up-gestimmt Antwort hier und konnte das Glas runnable bekommen. Aber das Programm nicht ordnungsgemäß ausgeführt. Ich weiß nicht, was der Grund dafür war. Wenn ich versuche, von Eclipse zu laufen, ich ein anderes Ergebnis bekommen, aber wenn ich das Glas von der Kommandozeile ausgeführt bekomme ich ein anderes Ergebnis (stürzt mit einem programmspezifischen Laufzeitfehler).

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

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

2) Dann Java wählen -> Runnable Jar

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

4) Schließlich wählen Sie die Klasse, die die Main-Methode, die Sie wollen Package dependencies with the Jar file laufen und wählen, und klicken Sie Finish

Dies ist die beste Art, wie ich gefunden: 

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

Mit dieser Konfiguration werden alle Abhängigkeiten in /dependency-jars befindet. Meine Anwendung hat keine Main Klasse, nur Kontext sind, aber einer meiner Abhängigkeiten haben eine Main Klasse (com.myDomain.etc.MainClassName), der die JMX-Server gestartet wird, und erhält eine start oder einen stop Parameter. Also mit dieser konnte ich meine Anwendung wie diese starten: 

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

Ich warte es für euch alle von Nutzen sein.

Dies ist auch eine Option sein könnte, können Sie 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>

Für alle, die Optionen suchen bestimmte Abhängigkeiten von dem uber-jar auszuschließen, ist dies eine Lösung, die für mich gearbeitet: 

<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 ist also nicht eine Konfiguration der MVN-Montage-Plugin aber eine Eigenschaft der Abhängigkeit.

Es gibt Millionen von Antworten schon, ich wollte Sie nicht brauchen <mainClass> hinzufügen, wenn Sie Einsprungs auf Ihre Bewerbung nicht hinzufügen müssen. Zum Beispiel APIs kann nicht notwendigerweise main Verfahren haben.

Maven Plugin Config 

  <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

verifizieren 

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/

In der pom.xml: 

  <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. Weiter mvn Paket wird zusätzlich auch ein Fett jar erstellen, einschließlich aller Abhängigkeit Gläser.

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top