¿Hay alguna manera de incluir todos los archivos jar dentro de un directorio en el classpath?

Estoy intentando java -classpath lib/*.jar:. my.package.Programy no puedo encontrar archivos de clase que ciertamente están en esos frascos. ¿Necesito agregar cada archivo jar al classpath por separado?

Con Java 6 o posterior, la opción classpath admite comodines. Tenga en cuenta lo siguiente:

• Usar comillas rectas ( ")
• Uso *, no*.jar

Ventanas

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

Unix

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

Esto es similar a Windows, pero usa en :lugar de ;. Si no puede usar comodines, bashpermite la siguiente sintaxis (donde libestá el directorio que contiene todos los archivos de almacenamiento Java):

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

(Tenga en cuenta que el uso de un classpath es incompatible con la -jaropción. Consulte también: Ejecutar archivo jar con múltiples bibliotecas classpath desde el símbolo del sistema )

Comprender los comodines

Del documento de Classpath :

Las entradas de ruta de clase pueden contener el carácter comodín basename *, que se considera equivalente a especificar una lista de todos los archivos en el directorio con la extensión .jaro .JAR. Por ejemplo, la entrada de ruta de clase foo/*especifica todos los archivos JAR en el directorio llamado foo. Una entrada classpath que consiste simplemente en *expandirse a una lista de todos los archivos jar en el directorio actual.

Una entrada de ruta de clase que contiene *no coincidirá con los archivos de clase. Para hacer coincidir las clases y los archivos JAR en un solo directorio foo, use uno foo;foo/*o foo/*;foo. El orden elegido determina si las clases y los recursos foose cargan antes que los archivos JAR foo, o viceversa.

Los subdirectorios no se buscan de forma recursiva. Por ejemplo, foo/*busca los archivos JAR sólo en foo, no en foo/bar, foo/baz, etc.

El orden en que se enumeran los archivos JAR en un directorio en la ruta de clase expandida no se especifica y puede variar de una plataforma a otra e incluso de un momento a otro en la misma máquina. Una aplicación bien construida no debe depender de ningún orden en particular. Si se requiere un orden específico, los archivos JAR se pueden enumerar explícitamente en la ruta de clase.

La expansión de comodines se realiza temprano, antes de la invocación del método principal de un programa, en lugar de tarde, durante el proceso de carga de clases. Cada elemento de la ruta de clase de entrada que contiene un comodín se reemplaza por la secuencia (posiblemente vacía) de elementos generados al enumerar los archivos JAR en el directorio nombrado. Por ejemplo, si el directorio foocontiene a.jar, b.jary c.jar, a continuación, la ruta de clase foo/*se expandió a foo/a.jar;foo/b.jar;foo/c.jar, y que sería la cadena de valor de la propiedad del sistema java.class.path.

La CLASSPATHvariable de entorno no se trata de manera diferente a la opción de línea de comandos -classpath(o -cp). Es decir, los comodines son honrados en todos estos casos. Sin embargo, los comodines de ruta de clase no se respetan en el Class-Path jar-manifestencabezado.

Nota: debido a un error conocido en Java 8, los ejemplos de Windows deben usar una barra diagonal inversa que preceda las entradas con un asterisco final: https://bugs.openjdk.java.net/browse/JDK-8131329

Debajo de Windows esto funciona:

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

y esto no funciona:

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

observe el * .jar, por lo que el comodín * debe usarse solo .

En Linux, lo siguiente funciona:

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

Los separadores son dos puntos en lugar de punto y coma.

Eludimos este problema implementando un archivo jar principalmyapp.jar que contiene un archivo manifest ( Manifest.mf) que especifica una ruta de clase con los otros archivos jar necesarios, que luego se implementan junto a él. En este caso, solo necesita declarar java -jar myapp.jarcuando ejecuta el código.

Entonces, si implementa el main jaren algún directorio, y luego coloca los frascos dependientes en una libcarpeta debajo de eso, el manifiesto se verá así:

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

NB: esto es independiente de la plataforma: podemos usar los mismos frascos para iniciar en un servidor UNIX o en una PC con Windows.

Mi solución en Ubuntu 10.04 usando java-sun 1.6.0_24 con todos los archivos jar en el directorio "lib":

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

Si esto falla, el siguiente comando debería funcionar (imprime todos los * .jars en el directorio lib en el parámetro classpath)

java -cp $ (para i en lib / *. jar; do echo -n $ i:; hecho). my.main.Class

Respuesta corta: java -classpath lib/*:. my.package.Program

Oracle proporciona documentación sobre el uso de comodines en classpaths aquí para Java 6 y aquí para Java 7 , en la sección titulada Descripción de comodines de ruta de clase . (Mientras escribo esto, las dos páginas contienen la misma información). Aquí hay un resumen de los aspectos más destacados:

• En general, para incluir todos los JAR en un directorio dado, puede usar el comodín *( no *.jar ).

• El comodín solo coincide con JAR, no con archivos de clase; para obtener todas las clases en un directorio, simplemente finalice la entrada classpath en el nombre del directorio.

• Las dos opciones anteriores se pueden combinar para incluir todos los archivos JAR y de clase en un directorio, y se aplican las reglas de precedencia de classpath habituales. P.ej-cp /classes;/jars/*

• El comodín no buscará JAR en subdirectorios.

• Los puntos anteriores son verdaderos si utiliza la CLASSPATHpropiedad del sistema o los indicadores de línea de comando -cpo -classpath. Sin embargo, si usa el Class-Pathencabezado de manifiesto JAR (como lo haría con un archivo de compilación de hormigas), no se aceptarán comodines .

Sí, mi primer enlace es el mismo que se proporciona en la respuesta de mayor puntuación (que no tengo esperanzas de superar), pero esa respuesta no proporciona mucha explicación más allá del enlace. Dado que este tipo de comportamiento se desaconseja en Stack Overflow en estos días , pensé en ampliarlo.

Ventanas :

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

Linux :

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

Recuerde:
- El separador de ruta de Windows es ;
- El separador de ruta de Linux es :
- En Windows si el argumento cp no contiene espacios en blanco, las "comillas" son opcionales

Para mí esto funciona en Windows.

java -cp "/lib/*;" sample

Para linux

java -cp "/lib/*:" sample

Estoy usando Java 6

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

Directorio de jarras externas cuando se ejecuta Java

Correcto :

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

Incorrecto:

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

Si realmente necesita especificar todos los archivos .jar dinámicamente, puede usar scripts de shell o Apache Ant . Hay un proyecto de commons llamado Commons Launcher que básicamente te permite especificar tu script de inicio como un archivo de compilación de hormigas (si ves lo que quiero decir).

Luego, puede especificar algo como:

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

En su archivo de compilación de lanzamiento, que iniciará su aplicación con el classpath correcto.

Si está utilizando Java 6, puede usar comodines en el classpath.

Ahora es posible usar comodines en la definición de classpath:

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

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

Tenga en cuenta que la expansión de comodines está rota para Java 7 en Windows.

Consulte este problema de StackOverflow para obtener más información.

La solución consiste en poner un punto y coma justo después del comodín. java -cp "somewhere/*;"

A quien le interese,

Encontré este comportamiento extraño en Windows bajo un shell MSYS / MinGW.

Trabajos:

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

No funciona

$ 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

Estoy bastante seguro de que el shell no expande el comodín porque, por ejemplo,

$ echo './*'
./*

(También lo probé con otro programa, en lugar del integrado echo, con el mismo resultado).

Creo que es lo javacque está tratando de expandirlo, y se comporta de manera diferente si hay un punto y coma en el argumento o no. Primero, puede estar tratando de expandir todos los argumentos que parecen caminos. Y solo entonces los analizaría, -cptomando solo la siguiente ficha. (Tenga en cuenta que com.comsol.aco_1.0.0.jares el segundo JAR en ese directorio). Eso es todo una suposición.

Esto es

$ javac -version
javac 1.7.0

Todas las soluciones anteriores funcionan muy bien si desarrolla y ejecuta la aplicación Java fuera de cualquier IDE como Eclipse o Netbeans.

Si está en Windows 7 y usó Eclipse IDE para desarrollo en Java, puede tener problemas si usa el símbolo del sistema para ejecutar los archivos de clase creados dentro de Eclipse.

Por ejemplo, su código fuente en Eclipse tiene la siguiente jerarquía de paquetes: edu.sjsu.myapp.Main.java

Tiene json.jar como una dependencia externa para Main.java

Cuando intente ejecutar Main.java desde Eclipse, se ejecutará sin ningún problema.

Pero cuando intente ejecutar esto utilizando el símbolo del sistema después de compilar Main.java en Eclipse, detectará algunos errores extraños que dicen "Error de ClassNotDef bla, bla".

Supongo que estás en el directorio de trabajo de tu código fuente.

Use la siguiente sintaxis para ejecutarla desde el símbolo del sistema:

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

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

   [No te pierdas el. encima]

Esto se debe a que ha colocado Main.java dentro del paquete edu.sjsu.myapp y java.exe buscará el patrón exacto.

Espero eso ayude !!

Para Windows se requieren cotizaciones y; debe usarse como separador. p.ej:

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

Forma abreviada: si su main está dentro de un jar, probablemente necesitará una '-jar pathTo / yourJar / YourJarsName.jar' adicional declarada explícitamente para que funcione (aunque 'YourJarsName.jar' estaba en el classpath) (o , expresado para responder a la pregunta original que se hizo hace 5 años: no es necesario volver a declarar cada jarra explícitamente, pero parece que, incluso con java6, debe volver a declarar su propia jarra ...)

Forma larga: (He hecho esto explícito hasta el punto de que espero que incluso los intrusos en Java puedan hacer uso de esto)

Como muchos aquí, estoy usando eclipse para exportar frascos: (Archivo-> Exportar -> 'Archivo JAR ejecutable'). Hay tres opciones en las ofertas de eclipse (Juno) de 'Manejo de biblioteca':

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"

Por lo general, usaría opt2 (y opt1 definitivamente se estaba rompiendo), sin embargo, el código nativo en uno de los frascos que estoy usando descubrió rupturas con el práctico truco "jarinjar" que el eclipse aprovecha cuando elige esa opción. Incluso después de darme cuenta de que necesitaba opt3, y luego encontrar esta entrada de StackOverflow, todavía me tomó un tiempo descubrir cómo iniciar mi principal fuera del eclipse, así que esto es lo que funcionó para mí, ya que es útil para otros ...

Si nombró su jar: "fooBarTheJarFile.jar" y todo está configurado para exportar al directorio: "/ theFully / qualifiedPath / toYourChosenDir".

(lo que significa que el campo 'Destino de exportación' se leerá: '/theFully/qualifiedPath/toYourChosenDir/fooBarTheJarFile.jar')

Después de presionar finalizar, encontrará eclipse y luego colocará todas las bibliotecas en una carpeta llamada 'fooBarTheJarFile_lib' dentro de ese directorio de exportación, dándole algo como:

/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

Luego puede iniciar desde cualquier lugar de su sistema con:

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

(Para los principiantes de Java: 'package.path_to.the_class_with.your_main' es la ruta del paquete declarada que encontrarás en la parte superior del archivo 'TheClassWithYourMain.java' que contiene el 'main (String [] args) {.. .} 'que desea ejecutar desde fuera de Java)

El error a tener en cuenta: es que tener 'fooBarTheJarFile.jar' dentro de la lista de jarras en su classpath declarado no es suficiente. Debe declarar explícitamente '-jar' y volver a declarar la ubicación de ese jar.

Por ejemplo, esto se rompe:

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

reexpresado con rutas relativas:

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   

(utilizando la versión de Java "1.6.0_27"; a través de OpenJDK 64-Bit Server VM en ubuntu 12.04)

La única forma en que sé cómo hacerlo es de forma individual, por ejemplo:

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

¡Espero que ayude!

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

Debe agregarlos todos por separado. Alternativamente, si realmente necesita especificar un directorio, puede deshacer todo en un directorio y agregarlo a su classpath. Sin embargo, no recomiendo este enfoque, ya que corre el riesgo de problemas extraños en el versionado de classpath y la inmanejabilidad.

No es una solución directa para poder establecer / * en -cp, pero espero que pueda usar el siguiente script para facilitar un poco la situación de las rutas de clase dinámicas y los directorios 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; 

Scripted para Linux, también podría tener uno similar para Windows. Si se proporciona el directorio apropiado como entrada a "libDir2Scan4jars"; el script escaneará todos los archivos jar y creará una cadena classpath y la exportará a una variable env "tmpCLASSPATH".

macOS, carpeta actual

Para Java 13 en macOS Mojave ...

Si todos sus .jararchivos están en la misma carpeta, use cdpara que sea su directorio de trabajo actual . Verificar con pwd.

Para el -classpathprimero debe enumerar el archivo JAR para su aplicación. Usando un carácter de dos puntos :como delimitador, agregue un asterisco *para obtener todos los demás archivos JAR dentro de la misma carpeta. Por último, pase el nombre completo del paquete de la clase con su mainmétodo .

Por ejemplo, para una aplicación en un archivo JAR llamado my_app.jarcon un mainmétodo en una clase nombrada Appen un paquete llamado com.example, junto con algunos tarros necesarios en la misma carpeta:

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

Piense en un archivo jar como la raíz de una estructura de directorio. Sí, debe agregarlos todos por separado.

Establezca el classpath de una manera adecuada para múltiples jarras y archivos de clase del directorio actual.

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

Tengo varios frascos en una carpeta. El siguiente comando funcionó para mí JDK1.8al incluir todos los frascos presentes en la carpeta. Tenga en cuenta que para incluir entre comillas si tiene un espacio en el classpath

Ventanas

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

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

Linux

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

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

Estoy tratando de ejecutar un archivo Java como jar o como clases en Ubuntu. Fallé en ambas opciones. La siguiente excepción es su salida.

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

Encontré la respuesta:

Mi estupidez

Primer paso: debe configurar el Java correspondiente: ¡tenía Java 11 pero configuré como ruta de acceso Java lib la octava versión! - Puedes configurar la versión de Java desde aquí:

  sudo update-alternatives --config java

2do paso: Luego ejecute el siguiente comando, cambiando la ruta y los nombres de archivo a su ruta y archivos correspondientes:

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

Se ejecutó con éxito!