Incluyendo todos los frascos en un directorio dentro del classpath de Java


1019

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


3
Lo siento, nunca he aceptado esto. Debería ser un wiki comunitario. Nunca usé una de las respuestas proporcionadas. Creo que creé un script de shell que simplemente escaneó el directorio lib / y creó el classpath a partir del análisis de nombres de archivos.
Chris Serra

Hay algún tipo de error en esta nueva característica de Java, porque no funciona como se describe. Me di por vencido y usé Ant para solucionarlo, como se describe en una de las respuestas.
Alex R


1
Hay un problema con el procesamiento de comodines en Windows. stackoverflow.com/questions/11607873/…
Mykhaylo Adamovych

66
Respuesta corta: (1) suelte la .jarparte, (2) debe tener al menos 2 partes, separadas por a ;en Windows (que generalmente está en :otro lugar). Por ejemplo:java -classpath ".;lib/*" Program
Evgeni Sergeev

Respuestas:


1160

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


2
La característica está mal documentada y parece requerir que se cumplan algunas condiciones previas menos que obvias para funcionar según lo previsto.
Alex R

1
+1 para el último truco bash / tr. ¡Java / JamVM aquí no le gustan los comodines para las rutas fuera del directorio de trabajo, pero hace referencia explícita a cada JAR usando shell wildcard + trworks!
Supr

1
Tengo un comando java -classpath /jars/*:/anotherJarsDir/* com.test.MyClasssin comillas y funciona bien. Me pregunto por qué Shell no lo está expandiendo y produciendo errores.
yellavon

3
Asimismo, no se utilice ~en el -cp
Sohail Si

1
Su ejemplo de Windows no funciona con Java 8 o anterior, pero lo haría con este classpath: Test.jar; lib \ * ... la barra diagonal está bien, excepto cuando precede un asterisco y algunos otros ... vea bugs.openjdk. java.net/browse/JDK-8131329
philwalk

226

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.


17
La respuesta perfecta 2 cosas importantes a tener en cuenta: 1) Use comillas y 2) Use * solo, no * .jar
Wim Deblauwe

44
Un año y 8 meses después, la edición que hice para incluir la versión UNIX me salvó una vez más. :) Es curioso cómo no reconocería mis archivos jar con *.jarpero solo con *.
jmort253

Descubrí que el orden de los classpaths es importante (pero no sé por qué). Estaba recibiendo errores hasta que cambié el orden de classpaths.
user13107

@ jmort253, la cuestión es que este no es el shell * expandiéndose, pero el comodín es java analizando el classpath, viendo el * y completando el comodín
Sebastian

1
@SebastianGodelet - Sí, solo estoy confundiéndome entre los comodines de Regex y esta notación, que no es lo mismo, supongo. Principalmente, lo que me salvó es saber la diferencia entre :una plataforma y ;la otra. :) Compilo con Java desde la línea de comandos aproximadamente una vez al año, lo suficiente como para no recordar con qué frecuencia lo suficiente como para ser molesto.
jmort253

67

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.


Esto parece funcionar para muchas personas, sin embargo, Java parece ignorar las entradas de Class-Path en el archivo de manifiesto aquí. No podemos ejecutar la aplicación sin agregar manualmente "lib / *" al classpath usando -cp. ¿Algunas ideas?
Raku

66
La respuesta de oxbow_lakes no es del todo correcta; se respeta la cuestión de la ruta de clase (y SOLO se respeta; -cp / -classpath se ignora) si inicia este jar con java -jar myapp.jar. Supongo que oxbow_lakes tenía la intención de escribir eso cuando escribió 'java -classpath myapp.jar'.
rzwitserloot

47

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

44
Una nota graciosa. java -cp lib / * my.main.Class siempre fallará debido a la expansión de shell glob de lib / *, mientras que java -cp.: lib / * my.main.Class no lo hará porque.: lib / * no es un glob válido camino. Tómate un tiempo para notar eso
albfan

1
Esto no funciona; Linux ampliará el . puede probar: java -cp '.: lib / ' y eso funciona bien (¡tenga en cuenta las comillas simples! ¡No funcionará con comillas dobles!). En realidad,.: Lib / * podría funcionar si eso no es un problema legítimo debido al colon, pero se siente un poco dudoso. Yo agregaría las citas. Las comillas simples le dicen a bash que no toque ninguna parte del contenido.
rzwitserloot

No importa (en este contexto) si usa comillas simples o dobles. Desea evitar que el shell se expanda (englobe) *, eso es todo. Y pase el texto "lib / *" literalmente a la JVM, para que la VM reconozca esto como un "patrón especial" y busque por sí solo los archivos jar.
Angel O'Sphere

36

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.


mi problema fue con lib / *. jar en lugar de lib / *. Muchas gracias, esto lo solucionó. Noté que hay una diferencia entre: y; pero ese podría ser mi tipo de cosas de probar muchos cambios al mismo tiempo.
Eyad Ebrahim

Gracias por enfatizar la diferencia entre * y * .jar
burakhan alkan

36

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


El ejemplo de Windows no funciona para Java 8 y versiones
philwalk

Tal vez no funcione para JDK abierto, probaré esto y hablaré aquí
Wender

Lo siento, probé con HotSpot y pensé que funciona con openjdk.
Wender

Oracle Java bajo Windows requiere una barra diagonal inversa antes del asterisco en lugar de una barra diagonal, aunque no he vuelto a probar las versiones de Java más recientes o alternativas.
philwalk

no funciona en macos
Greyshack


29

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


3
Esto funciona, pero cuidado, pase -Djava.ext.dirs=ANTES-jar
Giovanni Funchal

55
java.ext.dirs funcionará de manera muy diferente a un jar normal en classpath. Tiene mayor prioridad y permiso que de alguna manera puede anular las clases en bootstamp (rt.jar)
Dennis C

Gracias. En 'java versión "1.8.0_221" Java (TM) SE Runtime Environment (compilación 1.8.0_221-b27) Java HotSpot (TM) VM de servidor de 64 bits (compilación 25.221-b27, modo mixto)', solo esta versión -D de pasar en el classpath funcionó. La forma tradicional no lo hizo.
Matt Campbell

23

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

9

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.



8

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/*;"


6

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

5

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


4

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

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

4

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)


3

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!


Este puede haber sido el único camino de regreso en el '08, pero ya no.
simo.3792

Esto no es lo peor. Es un truco, pero tengo este set en mi bashrcfor jar in $(ls $HOME/bin/*.jar); do export CLASSPATH=$jar:$CLASSPATH; done
Devon Peticolas

3

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

2

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.


3
Este puede haber sido el único camino de regreso en 2008, pero ya no.
simo.3792

2

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


2

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

no funciona para Java 8
Greyshack

1

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


1

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

0

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


-1

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!

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.