C'è un modo per includere tutti i file jar in una directory nel percorso di classe?

Sto provando java -classpath lib/*.jar:. my.package.Programe non è in grado di trovare file di classe che si trovano sicuramente in quei vasetti. Devo aggiungere ogni file jar al percorso di classe separatamente?

Utilizzando Java 6 o versioni successive, l'opzione classpath supporta i caratteri jolly. Nota quanto segue:

• Usa virgolette ( ")
• Usa *, no*.jar

finestre

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

Unix

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

Questo è simile a Windows, ma utilizza :invece di ;. Se non è possibile utilizzare caratteri jolly, bashconsente la sintassi seguente (dove si libtrova la directory che contiene tutti i file di archivio Java):

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

(Si noti che l'utilizzo di un percorso di classe non è compatibile con l' -jaropzione. Vedere anche: Eseguire il file jar con più librerie di percorso di classe dal prompt dei comandi )

Comprensione dei caratteri jolly

Dal documento Classpath :

Le voci del percorso di classe possono contenere il carattere jolly basename *, che è considerato equivalente alla specifica di un elenco di tutti i file nella directory con l'estensione .jaro .JAR. Ad esempio, la voce del percorso di classe foo/*specifica tutti i file JAR nella directory denominata foo. Una voce classpath composta semplicemente da si *espande in un elenco di tutti i file jar nella directory corrente.

Una voce del percorso di classe che contiene *non corrisponderà ai file di classe. Per abbinare sia le classi che i file JAR in una singola directory foo, utilizzare foo;foo/*o foo/*;foo. L'ordine scelto determina se le classi e le risorse foovengono caricate prima dei file JAR fooo viceversa.

Le sottodirectory non vengono cercate in modo ricorsivo. Ad esempio, foo/*cerca i file JAR solo foo, non in foo/bar, foo/bazecc

L'ordine in cui i file JAR in una directory sono enumerati nel percorso della classe espansa non è specificato e può variare da piattaforma a piattaforma e persino da un momento all'altro sulla stessa macchina. Un'applicazione ben costruita non dovrebbe dipendere da alcun ordine particolare. Se è richiesto un ordine specifico, i file JAR possono essere enumerati esplicitamente nel percorso della classe.

L'espansione dei caratteri jolly viene eseguita in anticipo, prima dell'invocazione del metodo principale di un programma, anziché in ritardo, durante il processo di caricamento della classe stesso. Ogni elemento del percorso della classe di input contenente un carattere jolly viene sostituito dalla sequenza (possibilmente vuota) di elementi generati dall'enumerazione dei file JAR nella directory denominata. Ad esempio, se la directory foocontiene a.jar, b.jare c.jar, quindi il percorso di classe foo/*si espande in foo/a.jar;foo/b.jar;foo/c.jar, e la stringa sarebbe il valore della proprietà di sistema java.class.path.

La CLASSPATHvariabile di ambiente non viene trattata in modo diverso dall'opzione -classpath(o -cp) della riga di comando. Cioè, i caratteri jolly sono onorati in tutti questi casi. Tuttavia, i caratteri jolly del percorso di classe non sono onorati Class-Path jar-manifestnell'intestazione.

Nota: a causa di un bug noto in Java 8, gli esempi di Windows devono usare una barra rovesciata che precede le voci con un asterisco finale: https://bugs.openjdk.java.net/browse/JDK-8131329

Sotto Windows funziona:

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

e questo non funziona:

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

notare il * .jar, quindi il carattere jolly * deve essere usato da solo .

Su Linux, funziona come segue:

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

I separatori sono due punti anziché punti e virgola.

Risolviamo questo problema distribuendo un file jar principalemyapp.jar che contiene un file manifest ( Manifest.mf) che specifica un percorso di classe con gli altri barattoli richiesti, che vengono quindi distribuiti a fianco di esso. In questo caso, è necessario dichiarare solo java -jar myapp.jarquando si esegue il codice.

Quindi, se si distribuisce il main jarin una directory e quindi si inseriscono i barattoli dipendenti in una libcartella al di sotto di ciò, il manifest appare come:

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

NB: questo è indipendente dalla piattaforma: possiamo usare gli stessi vasetti per l'avvio su un server UNIX o su un PC Windows.

La mia soluzione su Ubuntu 10.04 usando java-sun 1.6.0_24 con tutti i barattoli nella directory "lib":

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

Se fallisce, dovrebbe funzionare il seguente comando (stampa tutti * .jars nella directory lib nel parametro classpath)

java -cp $ (per i in lib / *. jar; do echo -n $ i:; done). my.main.Class

Risposta breve: java -classpath lib/*:. my.package.Program

Oracle fornisce la documentazione sull'uso dei caratteri jolly nei percorsi di classe qui per Java 6 e qui per Java 7 , nella sezione Intestazione dei caratteri jolly del percorso di classe . (Mentre scrivo, le due pagine contengono le stesse informazioni.) Ecco un riepilogo dei punti salienti:

• In generale, per includere tutti i JAR in una determinata directory, è possibile utilizzare il carattere jolly *( non *.jar ).

• Il carattere jolly corrisponde solo ai JAR, non ai file di classe; per ottenere tutte le classi in una directory, basta terminare la voce classpath nel nome della directory.

• Le due opzioni precedenti possono essere combinate per includere tutti i file JAR e di classe in una directory e si applicano le normali regole di precedenza del percorso di classe. Per esempio-cp /classes;/jars/*

• Il carattere jolly non cercherà JAR nelle sottodirectory.

• I punti elenco di cui sopra sono vere se si utilizza la CLASSPATHproprietà di sistema o le -cpo -classpathcomando flag della riga. Tuttavia, se si utilizza l' Class-Pathintestazione manifest JAR (come si potrebbe fare con un file build ant), i caratteri jolly non verranno rispettati.

Sì, il mio primo link è lo stesso fornito nella risposta con il punteggio più alto (che non ho alcuna speranza di sorpasso), ma quella risposta non fornisce molte spiegazioni oltre il link. Dal momento che quel tipo di comportamento è scoraggiato su Stack Overflow in questi giorni , ho pensato di ampliarlo.

Windows :

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

Linux :

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

Ricorda:
- Il separatore di percorso di Windows è ;
- Il separatore di percorso di Linux è :
- In Windows se l'argomento cp non contiene spazi bianchi, le "virgolette" sono facoltative

Per me questo funziona su Windows.

java -cp "/lib/*;" sample

Per linux

java -cp "/lib/*:" sample

Sto usando Java 6

Puoi provare java -Djava.ext.dirs=jarDirectory http://docs.oracle.com/javase/6/docs/technotes/guides/extensions/spec.html

Directory per vasi esterni durante l'esecuzione di Java

Corretto :

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

non corretto:

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

Se hai davvero bisogno di specificare tutti i file .jar dinamicamente potresti usare gli script di shell o Apache Ant . C'è un progetto comune chiamato Commons Launcher che sostanzialmente ti consente di specificare il tuo script di avvio come file di generazione di formiche (se vedi cosa intendo).

Quindi, puoi specificare qualcosa come:

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

Nel tuo file di build di avvio, che avvierà l'applicazione con il percorso di classe corretto.

Se si utilizza Java 6, è possibile utilizzare i caratteri jolly nel percorso di classe.

Ora è possibile utilizzare i caratteri jolly nella definizione del percorso di classe:

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

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

Si noti che l'espansione dei caratteri jolly è interrotta per Java 7 su Windows.

Dai un'occhiata a questo problema StackOverflow per ulteriori informazioni.

Per risolvere il problema, inserire un punto e virgola subito dopo il carattere jolly. java -cp "somewhere/*;"

Per chi è coinvolto,

Ho trovato questo strano comportamento su Windows sotto una shell MSYS / MinGW.

Lavori:

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

Non funziona:

$ 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

Sono abbastanza sicuro che il carattere jolly non sia espanso dalla shell, perché ad es

$ echo './*'
./*

(Ho provato anche con un altro programma, anziché con quello integrato echo, con lo stesso risultato.)

Credo che sia ciò javacche sta cercando di espanderlo, e si comporta diversamente se c'è un punto e virgola o meno nell'argomento. Innanzitutto, potrebbe tentare di espandere tutti gli argomenti che sembrano percorsi. E solo allora li analizzerebbe, -cpprendendo solo il seguente token. (Nota che com.comsol.aco_1.0.0.jarè il secondo JAR in quella directory.) È tutta una supposizione.

Questo è

$ javac -version
javac 1.7.0

Tutte le soluzioni di cui sopra funzionano perfettamente se si sviluppa ed esegue l'applicazione Java al di fuori di qualsiasi IDE come Eclipse o Netbeans.

Se si utilizza Windows 7 e si utilizza Eclipse IDE per lo sviluppo in Java, è possibile che si verifichino problemi se si utilizza il prompt dei comandi per eseguire i file di classe creati all'interno di Eclipse.

Ad esempio, il codice sorgente in Eclipse presenta la seguente gerarchia di pacchetti: edu.sjsu.myapp.Main.java

Hai json.jar come dipendenza esterna per Main.java

Quando si tenta di eseguire Main.java da Eclipse, verrà eseguito senza problemi.

Ma quando provi a eseguirlo usando il prompt dei comandi dopo aver compilato Main.java in Eclipse, verranno sparati alcuni strani errori che dicono "Errore ClassNotDef blah blah".

Presumo che tu sia nella directory di lavoro del tuo codice sorgente !!

Utilizzare la sintassi seguente per eseguirla dal prompt dei comandi:

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

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

   [Non perdere il. sopra]

Questo perché hai inserito Main.java nel pacchetto edu.sjsu.myapp e java.exe cercherà il modello esatto.

Spero che sia d'aiuto !!

Per Windows sono richiesti preventivi e; dovrebbe essere usato come separatore. per esempio:

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

Forma abbreviata: se il tuo main è all'interno di un jar, probabilmente avrai bisogno di un ulteriore '-jar pathTo / yourJar / YourJarsName.jar' dichiarato esplicitamente per farlo funzionare (anche se 'YourJarsName.jar' era sul percorso di classe) (o , espresso per rispondere alla domanda originale posta 5 anni fa: non è necessario dichiarare esplicitamente ogni vaso, ma sembra che, anche con java6, sia necessario dichiarare il proprio vaso ...)

Long Form: (L'ho reso esplicito al punto che spero che anche gli intrusi di Java possano farne uso)

Come molti qui sto usando eclipse per esportare barattoli: (File-> Esporta -> 'File JAR eseguibile'). Esistono tre opzioni sulle offerte eclipse (Juno) "Gestione librerie":

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"

Tipicamente userei opt2 (e opt1 si stava decisamente rompendo), tuttavia il codice nativo in uno dei barattoli che sto usando ho scoperto le interruzioni con il pratico trucco "jarinjar" che eclissi sfrutta quando scegli quell'opzione. Anche dopo aver realizzato che avevo bisogno di opt3, e poi aver trovato questa voce StackOverflow, mi ci è voluto ancora un po 'di tempo per capire come avviare il mio principale al di fuori di Eclipse, quindi ecco cosa ha funzionato per me, poiché è utile per gli altri ...

Se hai chiamato il tuo vaso: "fooBarTheJarFile.jar" e tutto è impostato per esportare nella directory: "/ theFully / qualificatoPath / toYourChosenDir".

(nel senso che il campo "Esporta destinazione" leggerà: "/theFully/qualifiedPath/toYourChosenDir/fooBarTheJarFile.jar")

Dopo aver premuto Finish, troverai eclipse quindi inserisce tutte le librerie in una cartella denominata 'fooBarTheJarFile_lib' all'interno di quella directory di esportazione, dandoti qualcosa del tipo:

/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

È quindi possibile avviare da qualsiasi punto del sistema con:

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

(Per i neofiti di Java: 'package.path_to.the_class_with.your_main' è il percorso del pacchetto dichiarato che troverai all'inizio del file 'TheClassWithYourMain.java' che contiene il 'main (String [] args) {.. .} "che desideri eseguire dall'esterno di Java)

La trappola da notare: è che avere 'fooBarTheJarFile.jar' nell'elenco dei barattoli sul tuo percorso di classe dichiarato non è sufficiente. Devi dichiarare esplicitamente '-jar' e dichiarare nuovamente la posizione di quel vaso.

ad esempio questo si rompe:

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

riformulato con percorsi relativi:

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   

(utilizzando la versione java "1.6.0_27"; tramite OpenJDK 64-Bit Server VM su Ubuntu 12.04)

L'unico modo per sapere come farlo è individualmente, ad esempio:

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

Spero che aiuti!

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

Devi aggiungerli tutti separatamente. In alternativa, se realmente necessario specificare solo una directory, è possibile unjar tutto in uno dir e aggiungere che al classpath. Non raccomando questo approccio, tuttavia, poiché si rischiano bizzarri problemi nel controllo delle versioni e nella gestibilità dei percorsi di classe.

Non è una soluzione diretta per poter impostare / * su -cp ma spero che tu possa usare il seguente script per facilitare un po 'la situazione per percorsi di classe dinamici e directory 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; 

Scritto per Linux, potrebbe averne uno simile anche per Windows. Se viene fornita la directory corretta come input per "libDir2Scan4jars"; lo script analizzerà tutti i barattoli e creerà una stringa di classpath ed esporterà in una variabile env "tmpCLASSPATH".

macOS, cartella corrente

Per Java 13 su macOS Mojave ...

Se tutti i .jarfile si trovano nella stessa cartella, utilizzare cdper rendere quella la directory di lavoro corrente . Verificare con pwd.

Per questo -classpathdevi prima elencare il file JAR per la tua app. Utilizzando un carattere due punti :come delimitatore, aggiungere un asterisco *per ottenere tutti gli altri file JAR nella stessa cartella. Infine, passa il nome completo del pacchetto della classe con il tuo mainmetodo .

Ad esempio, per un'app in un file JAR denominata my_app.jarcon un mainmetodo in una classe denominata Appin un pacchetto denominato com.example, insieme ad alcuni vasi necessari nella stessa cartella:

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

Pensa a un file jar come la radice di una struttura di directory. Sì, è necessario aggiungerli tutti separatamente.

Impostare il classpath in modo adeguato più barattoli e file di classe della directory corrente.

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

Ho più vasetti in una cartella. Il seguente comando ha funzionato per me JDK1.8per includere tutti i barattoli presenti nella cartella. Si noti che da includere tra virgolette se si dispone di uno spazio nel percorso di classe

finestre

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

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

Linux

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

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

Sto cercando di eseguire il file Java come jar o come classi in Ubuntu. Ho fallito in entrambe le opzioni. La seguente eccezione è il suo output.

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

java org.statmetrics.Statmetric

o

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

o

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

Ho trovato la risposta:

La mia stupidità

Primo passo: devi impostare il Java corrispondente: avevo Java 11 ma ho impostato come percorso lib Java l'ottava versione! - Puoi impostare la versione Java da qui:

  sudo update-alternatives --config java

2 ° passaggio: quindi eseguire il comando seguente, modificando il percorso e i nomi dei file nel percorso e nei file corrispondenti:

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

È stato eseguito con successo!