W tym zależności w słoiku z Maven

W Maven 2, dobrym sposobem na to jest użycie Maven2 Assembly Plugin, który ma predefiniowany plik deskryptora do tego celu i który możesz użyć w wierszu poleceń:

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

Jeśli chcesz, aby ten jar był wykonywalny, po prostu dodaj główną klasę, która ma być uruchomiona do konfiguracji wtyczki:

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

Jeśli chcesz utworzyć ten zbiór jako część normalnego procesu budowania, powinieneś powiązać single lub katalog-single cel (cel assembly powinien być uruchamiany tylko z linii poleceń) do fazy cyklu życia (package ma sens), coś takiego:

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

Dostosuj element configuration do swoich potrzeb(na przykład z oczywistymi rzeczami, jak mówiono).

Jeśli chcesz zrobić plik wykonywalny jar, musisz również ustawić klasę główną. Więc pełna konfiguracja powinna być.

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

Jest wtyczka shade maven . Można go użyć do pakietu i zmiany nazwy Zależności(aby pominąć problemy z zależnościami na classpath).

If you (like me) dont specially like the jar-with-dependencies approach described above, maven-rozwiązanie, które preferuję, to po prostu zbudować projekt wojenny, nawet jeśli budujesz tylko samodzielną aplikację java:

1. Stwórz normalny maven jar-projekt, który zbuduje Twój plik jar (bez zależności).

2. Ponadto, skonfiguruj Maven war-project (tylko z pustym src/main/webapp/WEB-INF/web.plik xml , który pozwoli uniknąć warning / error in the Maven-build), który ma tylko twój jar-project jako zależność i uczyni Twój jar-project <module> pod twoim war-project. (Ten projekt wojny jest tylko prostą sztuczką, aby zawinąć wszystkie zależności pliku JAR w plik zip.)

3. Zbuduj projekt wojny, aby stworzyć plik wojny.

4. W kroku wdrażania po prostu zmień nazwę .wojna-plik do *.zapnij i rozpakuj.

Powinieneś teraz mieć katalog lib (który możesz przenieść tam, gdzie chcesz to) z Twoim jar i wszystkimi zależnościami, których potrzebujesz do uruchomienia aplikacji:

java -cp 'path/lib/*' MainClass

Myślę, że jest to zarówno prostsze do skonfigurowania w maven (nie ma potrzeby bałaganu z wtyczką montażu), a także daje jaśniejszy widok struktury aplikacji (zobaczysz numery wersji wszystkich zależnych słoików w widoku zwykłym i unikniesz zapychania wszystkiego do jednego pliku jar).

Nowo utworzony jar można użyć znacznika <classifier>.

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

Http://fiji.sc/Uber-JAR zapewnia doskonałe wyjaśnienie alternatyw:

Istnieją trzy popularne metody konstruowania uber-JAR:

1. Unshaded. Rozpakuj wszystkie pliki JAR, a następnie przepakuj je do jednego JAR.
   • Pro: działa z domyślnym loaderem klas Javy.
   • Con: pliki obecne w wielu plikach JAR o tej samej ścieżce (np., META-INF / services / javax.scenariusz.ScriptEngineFactory) nadpisze jeden inny, skutkuje wadliwym zachowaniem.
   • Narzędzia: Maven Assembly Plugin, Classworlds Uberjar
Cieniowane. Tak samo jak bezcieniowe, ale zmień nazwę (tzn." odcień") wszystkich pakietów wszystkich zależności.

• Pro: działa z domyślnym loaderem klas Javy. Unika niektórych (Nie wszystkich) kolizji wersji zależności.
• Con: Pliki obecne w wielu plikach JAR o tej samej ścieżce (np., META-INF / services / javax.scenariusz.ScriptEngineFactory) nadpisze jeden inny, skutkuje wadliwym zachowaniem.
• Narzędzia: Maven Shade Plugin

słoik słoików. Ostateczny plik JAR zawiera inne osadzone w nim pliki JAR.

• Pro: unika kolizji wersji zależności. Wszystkie pliki zasobów są zachowywane.
• Con: musi połączyć specjalny "bootstrap" classloader umożliwiający Javie Ładowanie klas z zawinięte pliki słoika. Debugowanie problemów z ładowaniem klas staje się bardziej złożone.
• Narzędzia: Eclipse Jar File Exporter, Jeden słoik.

Moje ostateczne rozwiązanie na Eclipse Luna i m2eclipse: Niestandardowy Classloader (Pobierz i dodaj do swojego projektu, tylko 5 klas) :http://git.eclipse.org/c/jdt/eclipse.jdt.ui.git/plain/org.eclipse.jdt.ui/jar%20in%20jar%20loader/org/eclipse/jdt/internal/jarinjarloader/; ten classloader jest najlepszy z jednego słoika classloadera i bardzo szybki;

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

Edytuj w JIJConstants "RSRC-Class-Path "do"Class-Path"
mvn clean dependency:copy-dependencies package
na tworzenie jar z zależnościami w folderze lib za pomocą thin classloader

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

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

Pomijając Mavena, możesz umieścić biblioteki JAR w głównym Jar, ale będziesz musiał użyć własnego classloadera.

Sprawdź ten projekt: One-JAR link text

Ten post może być trochę stary, ale ostatnio też miałem ten sam problem. Pierwsze rozwiązanie zaproponowane przez Johna Stauffera jest dobre, ale miałem pewne problemy, ponieważ pracuję tej wiosny. Używane przeze mnie zależności springa mają pewne pliki właściwości i deklaracje schematów xml, które mają te same ścieżki i nazwy. Chociaż te Jary pochodzą z tych samych wersji, jar-with-dependencies maven-goal nadpisywał plik tezy ostatnim znalezionym plikiem.

In the end, the aplikacja nie mogła się uruchomić, ponieważ słoiki sprężynowe nie mogły znaleźć poprawnych plików właściwości. W tym przypadku rozwiązanie zaproponowane przez Rop rozwiązało mój problem.

Od tego czasu istnieje również projekt spring-boot. Ma bardzo fajny sposób na poradzenie sobie z tym problemem, zapewniając cel Mavena, który przeciąża cel pakietu i zapewnia własną ładowarkę klasy. Zobacz spring-boots Reference Guide

Spójrz na tę odpowiedź:

Tworzę instalator, który działa jako plik Java jar i musi rozpakować pliki WAR I JAR do odpowiednich miejsc w katalogu instalacyjnym. Wtyczka zależności może być używana w fazie pakietu z celem kopiowania i pobierze dowolny plik z repozytorium Maven (w tym pliki wojenne) i zapisze je tam, gdzie ich potrzebujesz. Zmieniłem katalog wyjściowy na ${project.buduj.katalog} / classes I wtedy efekt końcowy jest taki, że normalne zadanie JAR obejmuje moje pliki w porządku. Następnie mogę je wyodrębnić i zapisać do katalogu instalacyjnego.

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

Dzięki Dodałem poniżej fragment w POM.problem z plikiem xml i Mp rozwiązany i Utwórz plik fat jar zawierający wszystkie zależne Jary.

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