Czy istnieje sposób na włączenie wszystkich plików jar do katalogu w ścieżce klasy?

Próbuję java -classpath lib/*.jar:. my.package.Programi nie mogę znaleźć plików klas, które z pewnością są w tych słoikach. Czy muszę osobno dodawać każdy plik jar do ścieżki klasy?

W wersji Java 6 lub nowszej opcja classpath obsługuje symbole wieloznaczne. Uwaga:

• Użyj prostych cudzysłowów ( ")
• Użyj *, nie*.jar

Windows

java -cp "Test.jar;lib/*" my.package.MainClass

Unix

java -cp "Test.jar:lib/*" my.package.MainClass

Jest to podobne do systemu Windows, ale używa :zamiast niego ;. Jeśli nie możesz używać symboli wieloznacznych, bashzezwól na następującą składnię (gdzie libjest katalog zawierający wszystkie pliki archiwów Java):

java -cp $(echo lib/*.jar | tr ' ' ':')

(Zauważ, że użycie ścieżki klasy jest niezgodne z tą -jaropcją. Zobacz także: Uruchom plik jar z wieloma bibliotekami ścieżki klasy z wiersza polecenia )

Zrozumienie symboli wieloznacznych

Z dokumentu Classpath :

Pozycje ścieżki klasy mogą zawierać znak wieloznaczny basename *, który jest uważany za równoważny z określeniem listy wszystkich plików w katalogu z rozszerzeniem .jarlub .JAR. Na przykład pozycja ścieżki klasy foo/*określa wszystkie pliki JAR w katalogu o nazwie foo. Wpis ścieżki klasy składający się z po prostu *rozwija się do listy wszystkich plików jar w bieżącym katalogu.

Wpis ścieżki klasy, który zawiera *, nie będzie pasował do plików klasy. Aby dopasować obie klasy i pliki JAR w jednym katalogu foo, użyj jednego foo;foo/*lub foo/*;foo. Wybrana kolejność określa, czy klasy i zasoby foosą ładowane przed wprowadzeniem plików JAR fooi odwrotnie.

Podkatalogi nie są przeszukiwane rekurencyjnie. Na przykład, foo/*szuka plików JAR tylko foo, a nie foo/bar, foo/bazitd

Kolejność, w jakiej pliki JAR w katalogu są wyliczane w rozszerzonej ścieżce klasy, nie jest określona i może różnić się w zależności od platformy, a nawet z chwili na chwilę na tym samym komputerze. Dobrze zbudowana aplikacja nie powinna zależeć od żadnego konkretnego zamówienia. Jeśli wymagana jest określona kolejność, pliki JAR można jawnie wyliczyć w ścieżce klasy.

Rozwinięcie symboli wieloznacznych odbywa się wcześnie, przed wywołaniem głównej metody programu, a nie późno, podczas samego procesu ładowania klasy. Każdy element ścieżki klasy wejściowej zawierający symbol wieloznaczny jest zastępowany (ewentualnie pustą) sekwencją elementów generowaną przez wyliczanie plików JAR w nazwanym katalogu. Na przykład, jeśli katalog foozawiera a.jar, b.jari c.jar, następnie droga klasy foo/*rozpręża się foo/a.jar;foo/b.jar;foo/c.jar, a łańcuch będzie wartość właściwości systemu java.class.path.

CLASSPATHZmienna nie jest traktowany inaczej niż -classpath(lub -cp) wyboru polecenia linii. Oznacza to, że symbole wieloznaczne są honorowane we wszystkich tych przypadkach. Jednak symbole wieloznaczne ścieżki klasy nie są honorowane w Class-Path jar-manifestnagłówku.

Uwaga: z powodu znanego błędu w Javie 8 przykłady Windows muszą używać ukośnika poprzedzającego wpisy z końcową gwiazdką: https://bugs.openjdk.java.net/browse/JDK-8131329

W systemie Windows działa to:

java -cp "Test.jar;lib/*" my.package.MainClass

i to nie działa:

java -cp "Test.jar;lib/*.jar" my.package.MainClass

zwróć uwagę na * .jar, więc * należy używać tylko symbolu wieloznacznego .

W systemie Linux następujące funkcje:

java -cp "Test.jar:lib/*" my.package.MainClass

Separatory to dwukropki zamiast średników.

Rozwiązujemy ten problem, wdrażając główny plik jar, myapp.jarktóry zawiera plik manifest ( Manifest.mf) określający ścieżkę klasy z innymi wymaganymi słojami, które są następnie wdrażane obok niego. W takim przypadku wystarczy zadeklarować java -jar myapp.jarpodczas uruchamiania kodu.

Jeśli więc jarumieścisz main w jakimś katalogu, a następnie umieścisz zależne słoiki w libfolderze poniżej, manifest wygląda następująco:

Manifest-Version: 1.0
Implementation-Title: myapp
Implementation-Version: 1.0.1
Class-Path: lib/dep1.jar lib/dep2.jar

Uwaga: jest to niezależne od platformy - możemy używać tych samych słoików do uruchamiania na serwerze UNIX lub na komputerze z systemem Windows.

Moje rozwiązanie na Ubuntu 10.04 przy użyciu java-sun 1.6.0_24 z wszystkimi słojami w katalogu „lib”:

java -cp.: lib / * moja.main.Class

Jeśli to się nie powiedzie, następujące polecenie powinno działać (drukuje wszystkie * .jars w katalogu lib do parametru classpath)

java -cp $ (dla i w lib / *. jar; wykonaj echo -n $ i:; gotowe). my.main.Class

Krótka odpowiedź: java -classpath lib/*:. my.package.Program

Oracle udostępnia dokumentację dotyczącą używania symboli wieloznacznych w ścieżkach klas tutaj dla Java 6 i tutaj dla Java 7 , w sekcji zatytułowanej Zrozumienie symboli wieloznacznych ścieżki klasy . (Gdy to piszę, dwie strony zawierają te same informacje.) Oto podsumowanie najważniejszych wydarzeń:

• Zasadniczo, aby uwzględnić wszystkie pliki JAR w danym katalogu, można użyć symbolu wieloznacznego *( nie *.jar ).

• Symbol wieloznaczny pasuje tylko do plików JAR, a nie do plików klas; aby wszystkie klasy znalazły się w katalogu, wystarczy zakończyć wpis klasy w nazwie katalogu.

• Powyższe dwie opcje można połączyć, aby uwzględnić wszystkie pliki JAR i klasy w katalogu, i zastosowanie mają zwykłe reguły pierwszeństwa ścieżki klas. Na przykład-cp /classes;/jars/*

• Symbol wieloznaczny nie będzie wyszukiwał plików JAR w podkatalogach.

• Powyższe wypunktowania są prawdziwe w przypadku korzystania z CLASSPATHwłasności systemu lub z -cplub -classpathpolecenia flagi linii. Jeśli jednak użyjesz Class-Pathmanifestu JAR (tak jak w przypadku pliku kompilacji mrówki), symbole wieloznaczne nie będą honorowane.

Tak, mój pierwszy link jest taki sam, jak ten podany w odpowiedzi o najwyższym wyniku (której nie mam nadziei na wyprzedzenie), ale ta odpowiedź nie zawiera wielu wyjaśnień poza linkiem. Ponieważ tego rodzaju zachowanie jest zniechęcony na przepełnienie stosu te dni , myślałem, że rozszerzenie na nim.

Windows :

 java -cp file.jar;dir/* my.app.ClassName

Linux :

 java -cp file.jar:dir/* my.app.ClassName

Przypomnij:
- Separator ścieżek systemu Windows to ;
- Separator ścieżek systemu Linux to :
- W systemie Windows, jeśli argument cp nie zawiera spacji, „cudzysłowy” są opcjonalne

Dla mnie to działa w systemie Windows.

java -cp "/lib/*;" sample

Dla systemu Linux

java -cp "/lib/*:" sample

Używam Java 6

Możesz wypróbować java -Djava.ext.dirs=jarDirectory http://docs.oracle.com/javase/6/docs/technotes/guides/extensions/spec.html

Katalog zewnętrznych słoików podczas uruchamiania Java

Poprawne :

java -classpath "lib/*:." my.package.Program

Błędny:

java -classpath "lib/a*.jar:." my.package.Program
java -classpath "lib/a*:."     my.package.Program
java -classpath "lib/*.jar:."  my.package.Program
java -classpath  lib/*:.       my.package.Program

Jeśli naprawdę potrzebujesz dynamicznie określać wszystkie pliki .jar, możesz użyć skryptów powłoki lub Apache Ant . Istnieje wspólny projekt o nazwie Commons Launcher, który w zasadzie pozwala określić skrypt startowy jako plik kompilacji mrówki (jeśli rozumiesz, co mam na myśli).

Następnie możesz określić coś takiego:

<path id="base.class.path">
    <pathelement path="${resources.dir}"/>
    <fileset dir="${extensions.dir}" includes="*.jar" />
    <fileset dir="${lib.dir}" includes="*.jar"/>
</path>

W pliku kompilacji uruchamiania, który uruchomi aplikację z poprawną ścieżką klasy.

Jeśli używasz Java 6, możesz używać symboli wieloznacznych w ścieżce klasy.

Teraz można używać symboli wieloznacznych w definicji ścieżki klas:

javac -cp libs/* -verbose -encoding UTF-8 src/mypackage/*.java  -d build/classes

Patrz: http://www.rekk.de/bloggy/2008/add-all-jars-in-a-directory-to-classpath-with-java-se-6-using-wildcards/

Pamiętaj, że rozszerzenie symboli wieloznacznych nie działa w Javie 7 w systemie Windows.

Sprawdź ten problem StackOverflow, aby uzyskać więcej informacji.

Obejściem tego problemu jest umieszczenie średnika bezpośrednio za znakiem wieloznacznym. java -cp "somewhere/*;"

Do tych których może to dotyczyć,

Znalazłem to dziwne zachowanie w systemie Windows pod powłoką MSYS / MinGW.

Pracuje:

$ javac -cp '.;c:\Programs\COMSOL44\plugins\*' Reclaim.java

Nie działa:

$ javac -cp 'c:\Programs\COMSOL44\plugins\*' Reclaim.java
javac: invalid flag: c:\Programs\COMSOL44\plugins\com.comsol.aco_1.0.0.jar
Usage: javac <options> <source files>
use -help for a list of possible options

Jestem całkiem pewien, że symbol nie jest rozszerzany przez powłokę, ponieważ np

$ echo './*'
./*

(Wypróbowałem to również z innym programem, a nie z wbudowanym echo, z tym samym rezultatem).

Wierzę, że to javacwłaśnie próbuje ją rozwinąć i zachowuje się inaczej, niezależnie od tego, czy w argumencie jest średnik, czy nie. Po pierwsze, może próbować rozwinąć wszystkie argumenty, które wyglądają jak ścieżki. I dopiero wtedy je przeanalizuje, -cpbiorąc tylko następujący token. (Zauważ, że com.comsol.aco_1.0.0.jarjest to drugi plik JAR w tym katalogu).

To jest

$ javac -version
javac 1.7.0

Wszystkie powyższe rozwiązania działają świetnie, jeśli tworzysz i uruchamiasz aplikację Java poza dowolnym środowiskiem IDE, takim jak Eclipse lub Netbeans.

Jeśli korzystasz z systemu Windows 7 i używasz Eclipse IDE do programowania w Javie, możesz napotkać problemy, jeśli użyjesz wiersza polecenia do uruchomienia plików klas wbudowanych w Eclipse.

Np. Twój kod źródłowy w Eclipse ma następującą hierarchię pakietów: edu.sjsu.myapp.Main.java

Json.jar jest zewnętrzną zależnością dla Main.java

Gdy spróbujesz uruchomić Main.java z poziomu Eclipse, uruchomi się bez żadnych problemów.

Ale kiedy spróbujesz uruchomić to za pomocą wiersza polecenia po skompilowaniu Main.java w Eclipse, wyskoczy kilka dziwnych błędów, mówiąc: „Błąd ClassNotDef bla bla”.

Zakładam, że jesteś w katalogu roboczym swojego kodu źródłowego !!

Użyj następującej składni, aby uruchomić go z wiersza polecenia:

1. javac -cp ".; json.jar" Main.java

2. java -cp ".; json.jar" edu.sjsu.myapp.Main

   [Nie przegap. powyżej]

Wynika to z faktu, że umieściłeś Main.java w pakiecie edu.sjsu.myapp, a java.exe wyszuka dokładny wzór.

Mam nadzieję, że to pomoże !!

W przypadku systemu Windows wymagane są cytaty i; powinien być używany jako separator. na przykład:

java -cp "target\\*;target\\dependency\\*" my.package.Main

Skrócony formularz: Jeśli główny plik znajduje się w słoiku, prawdopodobnie będziesz potrzebować dodatkowego „-jar pathTo / yourJar / YourJarsName.jar” jawnie zadeklarowanego, aby działał (nawet jeśli „YourJarsName.jar” znajdował się w ścieżce klas) (lub , wyrażony w celu udzielenia odpowiedzi na pierwotne pytanie, które zostało zadane 5 lat temu: nie musisz ponownie jawnie ponownie określać każdego słoika, ale wydaje się, że nawet w java6 musisz ponownie sformułować własny słoik ...)

Długa forma: (Wyjaśniłem to do tego stopnia, że ​​mam nadzieję, że nawet intruzi do java mogą z tego skorzystać)

Jak wielu tutaj używam Eclipse do eksportowania słoików: (Plik-> Eksportuj -> 'Plik Run Jble'). Istnieją trzy opcje dotyczące zaćmienia „Obsługa bibliotek” (Juno):

opt1: "Extract required libraries into generated JAR"
opt2: "Package required libraries into generated JAR"
opt3: "Copy required libraries into a sub-folder next to the generated JAR"

Zwykle używałbym opt2 (a opt1 zdecydowanie się zepsuł), jednak natywny kod w jednym ze słoików, z których korzystam, odkryłem przerwy w przydatnej sztuczce „jarinjar”, ​​która wykorzystuje zaćmienie, gdy wybierzesz tę opcję. Nawet po uświadomieniu sobie, że potrzebuję opt3, a następnie znalezieniu tego wpisu StackOverflow, zajęło mi trochę czasu, aby wymyślić, jak uruchomić moją główną poza zaćmieniem, więc oto, co działało dla mnie, ponieważ jest przydatne dla innych ...

Jeśli nazwałeś swój jar: „fooBarTheJarFile.jar”, ​​a wszystko jest ustawione na eksport do katalogu: „/ theFully / Qualified Path / toYourChosenDir”.

(co oznacza, że ​​pole „Eksportuj miejsce docelowe” będzie brzmiało: „/theFully/qualifiedPath/toYourChosenDir/fooBarTheJarFile.jar”)

Po ukończeniu znajdziesz zaćmienie, a następnie umieści wszystkie biblioteki w folderze o nazwie „fooBarTheJarFile_lib” w tym katalogu eksportu, dając ci coś takiego:

/theFully/qualifiedPath/toYourChosenDir/fooBarTheJarFile.jar
/theFully/qualifiedPath/toYourChosenDir/fooBarTheJarFile_lib/SomeOtherJar01.jar
/theFully/qualifiedPath/toYourChosenDir/fooBarTheJarFile_lib/SomeOtherJar02.jar
/theFully/qualifiedPath/toYourChosenDir/fooBarTheJarFile_lib/SomeOtherJar03.jar
/theFully/qualifiedPath/toYourChosenDir/fooBarTheJarFile_lib/SomeOtherJar04.jar

Następnie możesz uruchomić z dowolnego miejsca w systemie za pomocą:

java -classpath "/theFully/qualifiedPath/toYourChosenDir/fooBarTheJarFile_lib/*" -jar  /theFully/qualifiedPath/toYourChosenDir/fooBarTheJarFile.jar   package.path_to.the_class_with.your_main.TheClassWithYourMain

(Dla Java Newbies: „pakiet.path_to.the_class_with.your_main” to zadeklarowana ścieżka pakietu, która znajduje się u góry pliku „TheClassWithYourMain.java”, który zawiera „main (String [] argumenty) {.. .} ”, który chcesz uruchomić spoza Java)

Pułapką, którą należy zauważyć: jest to, że posiadanie pliku „fooBarTheJarFile.jar” na liście słoików w zadeklarowanej ścieżce klasy nie wystarczy. Musisz jawnie zadeklarować „-jar” i ponownie określić lokalizację tego słoika.

np. to łamie:

 java -classpath "/theFully/qualifiedPath/toYourChosenDir/fooBarTheJarFile.jar;/theFully/qualifiedPath/toYourChosenDir/fooBarTheJarFile_lib/*"  somepackages.inside.yourJar.leadingToTheMain.TheClassWithYourMain

przekształcony ze ścieżkami względnymi:

cd /theFully/qualifiedPath/toYourChosenDir/;
BREAKS:  java -cp "fooBarTheJarFile_lib/*"                                package.path_to.the_class_with.your_main.TheClassWithYourMain    
BREAKS:  java -cp ".;fooBarTheJarFile_lib/*"                              package.path_to.the_class_with.your_main.TheClassWithYourMain   
BREAKS:  java -cp ".;fooBarTheJarFile_lib/*"   -jar                       package.path_to.the_class_with.your_main.TheClassWithYourMain   
WORKS:   java -cp ".;fooBarTheJarFile_lib/*"   -jar  fooBarTheJarFile.jar package.path_to.the_class_with.your_main.TheClassWithYourMain   

(przy użyciu wersji Java „1.6.0_27”; za pośrednictwem 64-bitowej maszyny wirtualnej serwera OpenJDK w systemie Ubuntu 12.04)

Jedyny sposób, w jaki wiem, jak to zrobić indywidualnie, na przykład:

setenv CLASSPATH /User/username/newfolder/jarfile.jar:jarfile2.jar:jarfile3.jar:.

Mam nadzieję, że to pomaga!

klasa z wepapp:

  > mvn clean install

  > java -cp "webapp/target/webapp-1.17.0-SNAPSHOT/WEB-INF/lib/tool-jar-1.17.0-SNAPSHOT.jar;webapp/target/webapp-1.17.0-SNAPSHOT/WEB-INF/lib/*" com.xx.xx.util.EncryptorUtils param1 param2

Musisz dodać je wszystkie osobno. Alternatywnie, jeśli naprawdę potrzebujesz tylko określić katalog, możesz rozłączyć wszystko w jednym katalogu i dodać to do ścieżki klasy. Nie polecam jednak tego podejścia, ponieważ ryzykujesz dziwne problemy w wersjonowaniu ścieżek klas i braku możliwości zarządzania.

Nie jest to bezpośrednie rozwiązanie dla możliwości ustawienia / * na -cp, ale mam nadzieję, że możesz użyć następującego skryptu, aby nieco złagodzić sytuację w przypadku dynamicznych ścieżek klas i katalogów lib.

 libDir2Scan4jars="../test";cp=""; for j in `ls ${libDir2Scan4jars}/*.jar`; do if [ "$j" != "" ]; then cp=$cp:$j; fi; done; echo $cp| cut -c2-${#cp} > .tmpCP.tmp; export tmpCLASSPATH=`cat .tmpCP.tmp`; if [ "$tmpCLASSPATH" != "" ]; then echo .; echo "classpath set, you can now use  ~>         java -cp \$tmpCLASSPATH"; echo .; else echo .; echo "Error please check libDir2Scan4jars path"; echo .; fi; 

Skrypty dla systemu Linux mogą mieć podobny do systemu Windows. Jeśli podany zostanie właściwy katalog jako dane wejściowe do pliku „libDir2Scan4jars”; skrypt przeskanuje wszystkie słoiki i utworzy ciąg ścieżki klasy i wyeksportuje go do zmiennej env „tmpCLASSPATH”.

macOS, bieżący folder

Dla Java 13 na macOS Mojave …

Jeśli wszystkie .jarpliki znajdują się w tym samym folderze, użyj, cdaby ustawić bieżący katalog roboczy . Zweryfikuj za pomocąpwd .

W tym celu -classpathmusisz najpierw wymienić plik JAR dla swojej aplikacji. Używając znaku dwukropka :jako ogranicznika, dodaj gwiazdkę, *aby uzyskać wszystkie inne pliki JAR w tym samym folderze. Na koniec podaj pełną nazwę pakietu klasy za pomocą mainmetody .

Na przykład dla aplikacji w pliku JAR o nazwie my_app.jarz mainmetodą w klasie o nazwie Appw nazwie pakietu com.examplewraz z kilkoma potrzebnymi słojami w tym samym folderze:

java -classpath my_app.jar:* com.example.App

Pomyśl o pliku jar jako katalogu głównego struktury katalogów. Tak, musisz dodać je wszystkie osobno.

Ustaw ścieżkę klasy w sposób odpowiedni dla wielu słoików i plików klas bieżącego katalogu.

CLASSPATH=${ORACLE_HOME}/jdbc/lib/ojdbc6.jar:${ORACLE_HOME}/jdbc/lib/ojdbc14.jar:${ORACLE_HOME}/jdbc/lib/nls_charset12.jar; 
CLASSPATH=$CLASSPATH:/export/home/gs806e/tops/jconn2.jar:.;
export CLASSPATH

Mam wiele słoików w folderze. Poniższe polecenie działało dla mnie wJDK1.8 aby uwzględnić wszystkie słoiki obecne w folderze. Pamiętaj, aby uwzględnić w cudzysłowie, jeśli masz spację w ścieżce klasy

Windows

Kompilacja: javac -classpath "C:\My Jars\sdk\lib\*" c:\programs\MyProgram.java

Bieganie: java -classpath "C:\My Jars\sdk\lib\*;c:\programs" MyProgram

Linux

Kompilacja: javac -classpath "/home/guestuser/My Jars/sdk/lib/*" MyProgram.java

Bieganie: java -classpath "/home/guestuser/My Jars/sdk/lib/*:/home/guestuser/programs" MyProgram

Próbuję uruchomić plik Java jako słoik lub jako klasę w Ubuntu. Nie udało mi się w obu opcjach. Następujący wyjątek to jego dane wyjściowe.

Download link: https://upload.cat/f694139f88c663b1

java org.statmetrics.Statmetric

lub

java -cp /home/elias/statmetrics/statmetrics.jar :. org.statmetrics.Statmetrics

lub

java -classpath "/usr/lib/jvm/java-1.8.0-openjdk-amd64/jre/lib/*" -jar /home/elias/statmeics/statmetrics.jar org.statmetrics.Statmetrics

Exception in thread "Thread-0" java.lang.NoClassDefFoundError: javax/xml/bind/annotation/adapters/XmlAdapter
    at java.base/java.lang.ClassLoader.defineClass1(Native Method)
    at java.base/java.lang.ClassLoader.defineClass(ClassLoader.java:1016)
    at java.base/java.security.SecureClassLoader.defineClass(SecureClassLoader.java:174)
    at java.base/jdk.internal.loader.BuiltinClassLoader.defineClass(BuiltinClassLoader.java:802)
    at java.base/jdk.internal.loader.BuiltinClassLoader.findClassOnClassPathOrNull(BuiltinClassLoader.java:700)
    at java.base/jdk.internal.loader.BuiltinClassLoader.loadClassOrNull(BuiltinClassLoader.java:623)
    at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:581)
    at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:178)
    at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:521)
    at org.statmetrics.c.a(Unknown Source)
    at org.statmetrics.dw.a(Unknown Source)
    at org.statmetrics.dx.run(Unknown Source)
Caused by: java.lang.ClassNotFoundException: javax.xml.bind.annotation.adapters.XmlAdapter
    at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:583)
    at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:178)
    at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:521)
    ... 12 more

Znalazłem odpowiedź:

Moja głupota.

Pierwszy krok: musisz ustawić odpowiednią Javę: miałem Java 11, ale jako ścieżkę lib Java ustawiłem 8 wersję! - Możesz tutaj ustawić wersję Java:

  sudo update-alternatives --config java

Drugi krok: następnie uruchom następujące polecenie, zmieniając ścieżki i nazwy plików na odpowiednie ścieżki i pliki:

  java -classpath "/usr/lib/jvm/java-1.8.0-openjdk-amd64/jre/lib/*" -jar /home/elias/statmetrics/statmetrics.jar org.statmetrics.Statmetrics

Udało się to uruchomić!