Einschließen von Abhängigkeiten in ein Glas mit Maven

Gibt es eine Möglichkeit, maven (2.0.9) zu zwingen, alle Abhängigkeiten in eine einzelne JAR-Datei aufzunehmen?

Ich habe ein Projekt, das in eine einzelne JAR-Datei eingebaut wird. Ich möchte, dass die Klassen aus Abhängigkeiten auch in das Glas kopiert werden.

Update: Ich weiß, dass ich nicht einfach eine JAR-Datei in eine JAR-Datei aufnehmen kann. Ich suche nach einer Möglichkeit, die als Abhängigkeiten angegebenen Jars zu entpacken und die Klassendateien in meine JAR zu packen.

Sie können dies mit dem Maven-Assembly-Plugin mit dem Deskriptor "jar-with-dependencies" tun. Hier ist der relevante Teil aus einer unserer pom.xml, der dies tut:

  <build>
    <plugins>
      <!-- any other plugins -->
      <plugin>
        <artifactId>maven-assembly-plugin</artifactId>
        <executions>
          <execution>
            <phase>package</phase>
            <goals>
              <goal>single</goal>
            </goals>
          </execution>
        </executions>
        <configuration>
          <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
          </descriptorRefs>
        </configuration>
      </plugin>
    </plugins>
  </build>

Mit Maven 2 können Sie dazu das Maven2 Assembly Plugin verwenden, das eine vordefinierte Deskriptordatei für diesen Zweck enthält und die Sie einfach in der Befehlszeile verwenden können:

mvn assembly:assembly -DdescriptorId=jar-with-dependencies

Wenn Sie dieses JAR ausführbar machen möchten, fügen Sie einfach die auszuführende Hauptklasse zur Plugin-Konfiguration hinzu:

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-assembly-plugin</artifactId>
  <configuration>
    <archive>
      <manifest>
        <mainClass>my.package.to.my.MainClass</mainClass>
      </manifest>
    </archive>
  </configuration>
</plugin>

Wenn Sie diese Assembly als Teil des normalen Erstellungsprozesses erstellen möchten, sollten Sie das Einzel- oder Verzeichnis-Einzelziel (das assemblyZiel sollte NUR über die Befehlszeile ausgeführt werden) an eine Lebenszyklusphase binden ( packagesinnvoll).

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-assembly-plugin</artifactId>
  <executions>
    <execution>
      <id>create-my-bundle</id>
      <phase>package</phase>
      <goals>
        <goal>single</goal>
      </goals>
      <configuration>
        <descriptorRefs>
          <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
        ...
      </configuration>
    </execution>
  </executions>
</plugin>

Passen Sie das configurationElement an Ihre Bedürfnisse an (z. B. mit dem gesprochenen Manifest).

Wenn Sie eine ausführbare JAR-Datei erstellen möchten, müssen diese auch die Hauptklasse festlegen. Also sollte die vollständige Konfiguration sein.

    <plugins>
            <plugin>
                 <artifactId>maven-assembly-plugin</artifactId>
                 <executions>
                     <execution>
                          <phase>package</phase>
                          <goals>
                              <goal>single</goal>
                          </goals>
                      </execution>
                  </executions>
                  <configuration>
                       <!-- ... -->
                       <archive>
                           <manifest>
                                 <mainClass>fully.qualified.MainClass</mainClass>
                           </manifest>
                       </archive>
                       <descriptorRefs>
                           <descriptorRef>jar-with-dependencies</descriptorRef>
                      </descriptorRefs>
                 </configuration>
         </plugin>
   </plugins>

Es gibt das Shadow Maven Plugin . Es kann zum Packen und Umbenennen von Abhängigkeiten verwendet werden (um Abhängigkeitsprobleme im Klassenpfad zu vermeiden).

Sie können das neu erstellte Glas mithilfe eines <classifier>Tags verwenden.

<dependencies>
    <dependency>
        <groupId>your.group.id</groupId>
        <artifactId>your.artifact.id</artifactId>
        <version>1.0</version>
        <type>jar</type>
        <classifier>jar-with-dependencies</classifier>
    </dependency>
</dependencies>

Wenn Sie (wie ich) den oben beschriebenen Jar-with-Dependencies- Ansatz nicht besonders mögen , ist die von mir bevorzugte Maven-Lösung, einfach ein WAR-Projekt zu erstellen, auch wenn es sich nur um eine eigenständige Java-Anwendung handelt, die Sie erstellen:

1. Erstellen Sie ein normales Maven-JAR-Projekt, das Ihre JAR-Datei erstellt (ohne die Abhängigkeiten).

2. Richten Sie außerdem ein Maven-Kriegsprojekt ein (mit nur einer leeren Datei src / main / webapp / WEB-INF / web.xml , wodurch eine Warnung / ein Fehler im Maven-Build vermieden wird), die nur Ihr JAR-Projekt als enthält eine Abhängigkeit, und machen Sie Ihr jar-Projekt zu einem <module>unter Ihrem Kriegsprojekt. (Dieses Kriegsprojekt ist nur ein einfacher Trick, um alle Ihre JAR-Datei-Abhängigkeiten in eine Zip-Datei zu packen.)

3. Erstellen Sie das Kriegsprojekt, um die Kriegsdatei zu erstellen.

4. Benennen Sie im Bereitstellungsschritt Ihre .war-Datei einfach in * .zip um und entpacken Sie sie.

Sie sollten jetzt ein lib-Verzeichnis (das Sie verschieben können, wo Sie es möchten) mit Ihrem jar und allen Abhängigkeiten haben, die Sie zum Ausführen Ihrer Anwendung benötigen:

java -cp 'path/lib/*' MainClass

(Der Platzhalter im Klassenpfad funktioniert in Java-6 oder höher.)

Ich denke, dies ist sowohl einfacher in Maven einzurichten (Sie müssen nicht mit dem Assembly-Plugin herumspielen) als auch bietet Ihnen eine klarere Ansicht der Anwendungsstruktur (Sie sehen die Versionsnummern aller abhängigen Jars in einfacher Ansicht und) Vermeiden Sie es, alles in einer einzigen JAR-Datei zu verstopfen.

http://fiji.sc/Uber-JAR bietet eine hervorragende Erklärung der Alternativen:

Es gibt drei gängige Methoden zum Erstellen eines Uber-JAR:

1. Unschattiert. Entpacken Sie alle JAR-Dateien und packen Sie sie erneut in eine einzelne JAR.
   • Pro: Funktioniert mit dem Standard-Klassenladeprogramm von Java.
   • Con: Dateien, die in mehreren JAR-Dateien mit demselben Pfad vorhanden sind (z. B. META-INF / services / javax.script.ScriptEngineFactory), überschreiben sich gegenseitig und führen zu fehlerhaftem Verhalten.
   • Tools: Maven Assembly Plugin, Klassenwelten Uberjar
2. Schattiert. Wie nicht schattiert, jedoch alle Pakete aller Abhängigkeiten umbenennen (dh "Schatten").
   • Pro: Funktioniert mit dem Standard-Klassenladeprogramm von Java. Vermeidet einige (nicht alle) Konflikte mit Abhängigkeitsversionen.
   • Con: Dateien, die in mehreren JAR-Dateien mit demselben Pfad vorhanden sind (z. B. META-INF / services / javax.script.ScriptEngineFactory), überschreiben sich gegenseitig und führen zu fehlerhaftem Verhalten.
   • Tools: Maven Shade Plugin
3. JAR of JARs. Die endgültige JAR-Datei enthält die anderen darin eingebetteten JAR-Dateien.
   • Pro: Vermeidet Konflikte mit Abhängigkeitsversionen. Alle Ressourcendateien bleiben erhalten.
   • Con: Muss einen speziellen "Bootstrap" -Klassenlader bündeln, damit Java Klassen aus den umschlossenen JAR-Dateien laden kann. Das Debuggen von Problemen mit dem Klassenladeprogramm wird komplexer.
   • Tools: Eclipse JAR File Exporter, One-JAR.

        <!-- Method 1 -->
        <!-- Copy dependency libraries jar files to a separated LIB folder -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <configuration>
                <outputDirectory>${project.build.directory}/lib</outputDirectory>
                <excludeTransitive>false</excludeTransitive> 
                <stripVersion>false</stripVersion>
            </configuration>
            <executions>
                <execution>
                    <id>copy-dependencies</id>
                    <phase>package</phase>
                    <goals>
                        <goal>copy-dependencies</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
        <!-- Add LIB folder to classPath -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>2.4</version>
            <configuration>
                <archive>
                    <manifest>
                        <addClasspath>true</addClasspath>
                        <classpathPrefix>lib/</classpathPrefix>
                    </manifest>
                </archive>
            </configuration>
        </plugin>


        <!-- Method 2 -->
        <!-- Package all libraries classes into one runnable jar -->
        <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <executions>
              <execution>
                <phase>package</phase>
                <goals>
                  <goal>single</goal>
                </goals>
              </execution>
            </executions>
            <configuration>
              <descriptorRefs>
                <descriptorRef>jar-with-dependencies</descriptorRef>
              </descriptorRefs>
            </configuration>
        </plugin>            

Meine endgültige Lösung für Eclipse Luna und m2eclipse: Benutzerdefinierter Klassenladeprogramm (nur 5 Klassen herunterladen und zu Ihrem Projekt hinzufügen): http://git.eclipse.org/c/jdt/eclipse.jdt.ui.git/plain/org. eclipse.jdt.ui / jar% 20in% 20jar% 20loader / org / eclipse / jdt / internal / jarinjarloader / ; Dieser Classloader ist der beste Classloader mit einem Glas und sehr schnell.

<project.mainClass>org.eclipse.jdt.internal.jarinjarloader.JarRsrcLoader</project.mainClass> <project.realMainClass>my.Class</project.realMainClass>

Edit in JIJConstants "Rsrc-Class-Path" auf "Class-Path"
mvn sauber Abhängigkeit: copy-Abhängigkeiten Paket
ist ein Glas mit Abhängigkeiten in lib - Ordner mit einem dünnen Classloader erstellt

<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.java</include>
                <include>**/*.properties</include>
            </includes>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <filtering>true</filtering>
            <includes>
                <include>**/*</include>
            </includes>
            <targetPath>META-INF/</targetPath>
        </resource>
        <resource>
            <directory>${project.build.directory}/dependency/</directory>
            <includes>
                <include>*.jar</include>
            </includes>
            <targetPath>lib/</targetPath>
        </resource>
    </resources>
<pluginManagement>
        <plugins>

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

                        <manifestEntries>
                            <Rsrc-Main-Class>${project.realMainClass}  </Rsrc-Main-Class>
                            <Class-Path>./</Class-Path>
                        </manifestEntries>

                    </archive>
                </configuration>
            </plugin>
<plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <executions>
                    <execution>
                        <id>copy-dependencies</id>
                        <phase>package</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </pluginManagement>
</build>

Wenn Sie Maven beiseite legen, können Sie JAR-Bibliotheken in das Hauptglas einfügen, müssen jedoch Ihren eigenen Klassenladeprogramm verwenden.

Überprüfen Sie dieses Projekt: One-JAR- Linktext

Dieser Beitrag ist vielleicht etwas alt, aber ich hatte in letzter Zeit auch das gleiche Problem. Die erste von John Stauffer vorgeschlagene Lösung ist gut, aber ich hatte einige Probleme, als ich diesen Frühling arbeite. Die von mir verwendeten Abhängigkeitsgläser des Frühlings enthalten einige Eigenschaftendateien und XML-Schemadeklarationen, die dieselben Pfade und Namen haben. Obwohl diese Gläser aus denselben Versionen stammen, sind die Gläser mit Abhängigkeiten Maven-Ziel " diese Datei mit der zuletzt gefundenen Datei überschrieben.

Am Ende konnte die Anwendung nicht gestartet werden, da die Federgläser nicht die richtigen Eigenschaftendateien finden konnten. In diesem Fall hat die von Rop vorgeschlagene Lösung mein Problem gelöst.

Auch seitdem existiert das Spring-Boot-Projekt. Es hat eine sehr coole Möglichkeit, dieses Problem zu lösen, indem ein Maven-Ziel bereitgestellt wird, das das Paketziel überlastet und einen eigenen Klassenlader bereitstellt. Siehe Referenzhandbuch für Federstiefel

Schauen Sie sich diese Antwort an:

Ich erstelle ein Installationsprogramm, das als Java-JAR-Datei ausgeführt wird und WAR- und JAR-Dateien an den entsprechenden Stellen im Installationsverzeichnis entpacken muss. Das Abhängigkeits-Plugin kann in der Paketphase mit dem Kopierziel verwendet werden. Es lädt alle Dateien im Maven-Repository (einschließlich WAR-Dateien) herunter und schreibt sie, wo immer Sie sie benötigen. Ich habe das Ausgabeverzeichnis in $ {project.build.directory} / classes geändert und das Endergebnis ist, dass die normale JAR-Aufgabe meine Dateien einwandfrei enthält. Ich kann sie dann extrahieren und in das Installationsverzeichnis schreiben.

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<executions>
    <execution>
        <id>getWar</id>
        <phase>package</phase>
        <goals>
            <goal>copy</goal>
        </goals>
        <configuration>
            <artifactItems>
                <artifactItem>
                    <groupId>the.group.I.use</groupId>
                    <artifactId>MyServerServer</artifactId>
                    <version>${env.JAVA_SERVER_REL_VER}</version>
                    <type>war</type>
                    <destFileName>myWar.war</destFileName>
                </artifactItem>
            </artifactItems>
            <outputDirectory>${project.build.directory}/classes</outputDirectory>
        </configuration>
    </execution>
</executions>

Vielen Dank, ich habe unten Snippet in POM.xml-Datei hinzugefügt und Mp-Problem behoben und erstellen Sie Fat JAR-Datei, die alle abhängigen Gläser enthält.

<plugin>
    <artifactId>maven-assembly-plugin</artifactId>
        <executions>
            <execution>
                <phase>package</phase>
                <goals>
                    <goal>single</goal>
                </goals>
            </execution>
        </executions>
        <configuration>
            <descriptorRefs>
                <descriptorRef>dependencies</descriptorRef>
            </descriptorRefs>
        </configuration>
    </plugin>
</plugins>