Jak umieścić wszystkie wymagane pliki JAR w folderze biblioteki wewnątrz końcowego pliku JAR w Maven?

Używam Mavena w mojej samodzielnej aplikacji i chcę spakować wszystkie zależności z mojego pliku JAR do folderu biblioteki, jak wspomniano w jednej z odpowiedzi tutaj:

Jak mogę utworzyć wykonywalny plik JAR z zależnościami za pomocą Maven?

Chcę, aby mój końcowy plik JAR miał folder biblioteki, który zawiera zależności jako pliki JAR, a nie to, co maven-shade-pluginumieszcza zależności w postaci folderów, takich jak hierarchia Maven w folderze .m2.

Cóż, właściwie obecna konfiguracja robi to, co chcę, ale mam problem z ładowaniem plików JAR podczas uruchamiania aplikacji. Nie mogę załadować zajęć.

Oto moja konfiguracja:

<plugins>

    <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}/classes/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>com.myapp.MainClass</mainClass>
                </manifest>
            </archive>
        </configuration>
    </plugin>

    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
            <source>1.6</source>
            <target>1.6</target>
        </configuration>
    </plugin>

    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-dependency-plugin</artifactId>
        <executions>
            <execution>
                <id>install</id>
                <phase>install</phase>
                <goals>
                    <goal>sources</goal>
                </goals>
            </execution>
        </executions>
    </plugin>

    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-resources-plugin</artifactId>
        <version>2.5</version>
        <configuration>
            <encoding>UTF-8</encoding>
        </configuration>
    </plugin>

</plugins>

Projekt działa dobrze z Eclipse, a pliki JAR są umieszczane w folderze biblioteki wewnątrz mojego końcowego pliku JAR, tak jak chcę, ale podczas uruchamiania ostatecznego pliku JAR z folderu docelowego zawsze otrzymuję ClassNotFoundException:

Exception in thread "main" java.lang.NoClassDefFoundError: org/springframework/context/ApplicationContext
Caused by: java.lang.ClassNotFoundException: org.springframework.context.ApplicationContext
        at java.net.URLClassLoader$1.run(Unknown Source)
        at java.security.AccessController.doPrivileged(Native Method)
        at java.net.URLClassLoader.findClass(Unknown Source)
        at java.lang.ClassLoader.loadClass(Unknown Source)
        at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
        at java.lang.ClassLoader.loadClass(Unknown Source)
Could not find the main class: com.myapp.MainClass. Program will exit.

Jak mogę naprawić ten wyjątek?

Oto moje rozwiązanie. Sprawdź, czy to działa dla Ciebie:

<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}/classes/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>test.org.Cliente</mainClass> -->
            </manifest>
            <manifestEntries>
                <Class-Path>lib/</Class-Path>
            </manifestEntries>
        </archive>
    </configuration>
</plugin>

Pierwsza wtyczka umieszcza wszystkie zależności w folderze target / classes / lib, a druga zawiera folder biblioteki w ostatecznym pliku JAR i konfiguruje Manifest.mfplik.

Ale wtedy będziesz musiał dodać niestandardowy kod ładowania klas, aby załadować pliki JAR.

Lub, aby uniknąć ładowania klas niestandardowych, możesz użyć „$ {project.build.directory} / lib, ale w tym przypadku nie masz zależności w końcowym pliku JAR, co mija się z celem.

Od zadania tego pytania minęły dwa lata. Mimo to problem z zagnieżdżonymi plikami JAR nadal występuje. Mam nadzieję, że to komuś pomoże.

Zaktualizowano:

<build> 
  <plugins> 
    <plugin> 
    <artifactId>maven-dependency-plugin</artifactId> 
    <executions> 
      <execution> 
        <phase>install</phase> 
          <goals> 
            <goal>copy-dependencies</goal> 
          </goals> 
          <configuration> 
             <outputDirectory>${project.build.directory}/lib</outputDirectory> 
          </configuration> 
        </execution> 
      </executions> 
    </plugin> 
  </plugins> 
</build> 

Najprostszym i najbardziej wydajnym sposobem jest użycie takiej wtyczki Uber:

          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                </execution>
            </executions>
            <configuration>
                <finalName>uber-${artifactId}-${version}</finalName>
            </configuration>
        </plugin>

Będziesz miał zdenormalizowany wszystko w jednym pliku JAR.

Wykonywalny pakowacz Maven wtyczki mogą być wykorzystane do dokładnie tego celu: tworzenia aplikacji standalone Java zawierające wszystkie zależności jak pliki JAR w folderze konkretnego.

Wystarczy dodać co następuje do pom.xmlwewnątrz <build><plugins>sekcji (należy koniecznie wymienić wartość mainClassodpowiednio):

<plugin>
    <groupId>de.ntcomputer</groupId>
    <artifactId>executable-packer-maven-plugin</artifactId>
    <version>1.0.1</version>
    <configuration>
        <mainClass>com.example.MyMainClass</mainClass>
    </configuration>
    <executions>
        <execution>
            <goals>
                <goal>pack-executable-jar</goal>
            </goals>
        </execution>
    </executions>
</plugin>

Zbudowany plik JAR znajduje się target/<YourProjectAndVersion>-pkg.jarpo uruchomieniu mvn package. Wszystkie jego zależności czasu kompilacji i środowiska wykonawczego będą zawarte w lib/folderze w pliku JAR.

Zastrzeżenie: jestem autorem wtyczki.

podążając za tym linkiem:

Instrukcje: Eclipse Maven instaluje plik kompilacji jar z zależnościami

Dowiedziałem się, że nie jest to wykonalne rozwiązanie, ponieważ program ładujący klasy nie ładuje słoików z wnętrza jar, więc myślę, że rozpakuję zależności wewnątrz jar.

Oto jak to robię:

    <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>2.2</version>
            <configuration>
                <appendAssemblyId>false</appendAssemblyId>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
                <archive>
                    <manifest>
                        <mainClass>com.project.MainClass</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>

A potem po prostu biegnę:

mvn assembly:assembly

Znalazłem taką odpowiedź na pytanie:

http://padcom13.blogspot.co.uk/2011/10/creating-standalone-applications-with.html

Nie tylko otrzymujesz zależne pliki lib w folderze lib, ale także otrzymujesz bin Director z plikami wykonywalnymi unix i dos.

Plik wykonywalny ostatecznie wywołuje java z argumentem -cp, który zawiera również listę wszystkich zależnych bibliotek.

Cała partia znajduje się w folderze appasembly wewnątrz folderu docelowego. Epicki.

============= Tak, wiem, że to stary wątek, ale wciąż zajmuje wysokie pozycje w wynikach wyszukiwania, więc pomyślałem, że może pomóc komuś takiemu jak ja.

Jest to oczywiście problem ze ścieżką klas. Weź pod uwagę, że ścieżka klas musi się nieco zmienić, gdy uruchamiasz program poza IDE. Dzieje się tak, ponieważ IDE ładuje inne pliki JAR względem głównego folderu projektu, podczas gdy w przypadku ostatecznego pliku JAR zwykle nie jest to prawdą.

W takich sytuacjach lubię tworzyć JAR ręcznie. Zajmuje mi to maksymalnie 5 minut i zawsze rozwiązuje problem. Nie radzę tego robić. Znajdź sposób na użycie Mavena, taki jest jego cel.