Vraag Hoe kan ik een uitvoerbare JAR maken met afhankelijkheden met Maven?


Ik wil mijn project verpakken in een enkele uitvoerbare JAR voor distributie.

Hoe kan ik van een Maven-project alle afhankelijke JAR's in mijn uitvoer JAR maken?


1939
2018-02-22 08:43


oorsprong


antwoorden:


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

en je voert het uit

mvn clean compile assembly:single

Compileerdoel moet vóór de montage worden toegevoegd: alleenstaand of anders is de code voor uw eigen project niet inbegrepen.

Zie meer details in opmerkingen.


Gewoonlijk is dit doel gekoppeld aan een bouwfase om automatisch uit te voeren. Dit zorgt ervoor dat de JAR wordt gebouwd tijdens het uitvoeren mvn install of een implementatie / release uitvoeren.

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

1864
2017-12-01 10:46



U kunt de dependency-plugin gebruiken om alle afhankelijkheden in een afzonderlijke map vóór de pakketfase te genereren en die vervolgens opnemen in het classpath van het manifest:

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

Als alternatief gebruiken ${project.build.directory}/classes/lib als OutputDirectory om alle jar-bestanden in de hoofdkruik te integreren, maar dan moet u aangepaste classloading-code toevoegen om de potten te laden.


294
2018-06-02 03:01



Ik heb over een aantal verschillende manieren geblogd om dit te doen.

Zien Uitvoerbare pot met Apache Maven (WordPress)

of executable-jar-with-maven-voorbeeld (GitHub)

Notes

Die voor- en nadelen worden geleverd door Stephan.


Voor handmatige implementatie

  • Pros
  • Cons
    • Afhankelijkheden zijn uit de laatste pot.

Kopieer afhankelijkheden naar een specifieke map

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

Maak de Jar uitvoerbaar en 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>

Op dit punt de jar is eigenlijk uitvoerbaar met externe klassepadelementen.

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

Maak inzetbare archieven

De jar bestand is alleen uitvoerbaar met de broer of zus ...lib/ directory. We moeten archieven maken om te implementeren met de directory en de inhoud ervan.

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

Nu heb je target/${project.build.finalName}.(zip|tar|tar.bz2|tar.gz) die elk het bevat jar en lib/*.


Apache Maven Assembly Plugin

  • Pros
  • Cons
    • Geen ondersteuning voor verhuizing van klassen (gebruik maven-shade-plugin als verhuizing van de klas nodig is).
<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>

Jij hebt target/${project.bulid.finalName}-jar-with-dependencies.jar.


Apache Maven-schaduwplug-in

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

Jij hebt target/${project.build.finalName}-shaded.jar.


onejar-maven-plugin

  • Pros
  • Cons
    • Niet actief ondersteund sinds 2012.
<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

  • Pros
  • Cons
    • Voeg potentiële, onnodige, aan het voorjaar en de lente boot gerelateerde klassen toe.
<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>

Jij hebt target/${project.bulid.finalName}-spring-boot.jar.


134
2018-02-26 04:31



We nemen het antwoord van Unswered en herformatteren, we hebben:

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

Vervolgens zou ik aanraden om dit een natuurlijk onderdeel van je build te maken, in plaats van iets om expliciet te noemen. Voeg deze plug-in toe aan je om dit een integraal onderdeel van je build te maken pom.xml en bind het aan de package levenscyclus evenement. Echter, een gok is dat je het moet bellen assembly:single doel als u dit in uw pom.xml plaatst, terwijl u 'assembly: assembly' zou noemen als u het handmatig uitvoert vanaf de opdrachtregel.

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

122
2017-09-22 15:20



Gebruik de maven-shade-plugin om alle afhankelijkheden in één uber-pot te verpakken. Het kan ook worden gebruikt om een ​​uitvoerbare pot te maken door de hoofdklasse op te geven. Na het proberen om maven-assembly en speciale pot te gebruiken, ontdekte ik dat deze plug-in het beste geschikt was voor mijn behoeften.

Ik vond deze plug-in vooral nuttig omdat hij inhoud van specifieke bestanden samenvoegt in plaats van ze te overschrijven. Dit is nodig wanneer er bronbestanden zijn met dezelfde naam in de potten en de plug-in probeert alle bronbestanden te verpakken

Zie het onderstaande voorbeeld

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

91
2018-03-13 20:55



Lange tijd gebruikt de plug-in voor mavenassemblage, maar ik kon geen oplossing voor het probleem vinden "already added, skipping". Nu gebruik ik een andere plug-in - onejar-maven-plugin. Voorbeeld hieronder (mvn package pot bouwen):

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

U moet repository voor die plug-in toevoegen:

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

15
2017-10-13 12:16



U kunt maven -pendency-plugin gebruiken, maar de vraag was hoe u een uitvoerbare JAR kunt maken. Om dat te doen, moet de volgende wijziging in het antwoord van Matthew Franglen worden aangebracht (tussen haakjes, het duurt langer om de afhankelijkheidsplug-in te bouwen als je start vanuit een schoon doelwit):

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

14
2018-03-11 15:12



Een andere optie als je de inhoud van de andere JAR's echt wilt herverpakken binnen je enige resulterende JAR is de Maven Assembly-plug-in. Het uitgepakt en vervolgens alles opnieuw in een map via <unpack>true</unpack>. Dan zou je een tweede pas hebben die hem in één enorme JAR heeft gebouwd.

Een andere optie is de OneJar-plug-in. Dit voert de bovengenoemde herverpakkingsacties allemaal in één stap uit.


13
2017-08-13 18:23