Incluindo todos os jars em um diretório no caminho de classe Java

1019

Existe uma maneira de incluir todos os arquivos jar em um diretório no caminho de classe?

Estou tentando java -classpath lib/*.jar:. my.package.Programe não é possível encontrar arquivos de classe que certamente estão nesses frascos. Preciso adicionar cada arquivo jar ao caminho de classe separadamente?

Chris Serra
fonte
3
Desculpe, eu nunca aceitei isso. Deve ser um wiki da comunidade. Nunca usei uma das respostas fornecidas. Acredito que criei um script de shell que apenas examinou o diretório lib / e criou o caminho de classe a partir da análise de nomes de arquivos.
Chris Serra
Há algum tipo de bug nesse novo recurso Java, porque não funciona como descrito. Desisti e usei o Ant para contorná-lo, conforme descrito em uma das respostas.
Alex R
1
Há um problema com o processamento de caracteres curinga no Windows. stackoverflow.com/questions/11607873/…
Mykhaylo Adamovych
6
Resposta curta: (1) solte a .jarpeça, (2) deve ter pelo menos 2 partes, separadas por uma ;no Windows (que geralmente está em :outro lugar). Por exemplo:java -classpath ".;lib/*" Program
Evgeni Sergeev

Respostas:

1160

Usando o Java 6 ou posterior, a opção classpath suporta caracteres curinga. Observe o seguinte:

  • Use aspas simples ( ")
  • Use *, não*.jar

janelas

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

Unix

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

Isso é semelhante ao Windows, mas usa em :vez de ;. Se você não puder usar curingas, bashpermita a seguinte sintaxe (onde libestá o diretório que contém todos os arquivos archive Java):

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

(Observe que o uso de um caminho de classe é incompatível com a -jaropção. Consulte também: Executar arquivo jar com várias bibliotecas de caminho de classe no prompt de comando )

Noções básicas sobre curingas

No documento Classpath :

As entradas do caminho da classe podem conter o caractere curinga do nome da base *, que é considerado equivalente à especificação de uma lista de todos os arquivos no diretório com a extensão .jarou .JAR. Por exemplo, a entrada do caminho da classe foo/*especifica todos os arquivos JAR no diretório denominado foo. Uma entrada de caminho de classe que consiste simplesmente em se *expande para uma lista de todos os arquivos jar no diretório atual.

Uma entrada do caminho da classe que contém *não corresponderá aos arquivos de classe. Para corresponder as classes e os arquivos JAR em um único diretório foo, use foo;foo/*ou foo/*;foo. A ordem escolhida determina se as classes e os recursos foosão carregados antes dos arquivos JAR foo, ou vice-versa.

Os subdiretórios não são pesquisados ​​recursivamente. Por exemplo, foo/*procura arquivos JAR apenas em foo, não em foo/bar, foo/baz, etc.

A ordem na qual os arquivos JAR em um diretório são enumerados no caminho da classe expandida não é especificada e pode variar de plataforma para plataforma e até de momento para momento na mesma máquina. Um aplicativo bem construído não deve depender de nenhuma ordem específica. Se uma ordem específica for necessária, os arquivos JAR poderão ser enumerados explicitamente no caminho da classe.

A expansão de curingas é feita mais cedo, antes da chamada do método principal de um programa, e não tarde, durante o próprio processo de carregamento de classe. Cada elemento do caminho da classe de entrada que contém um curinga é substituído pela sequência (possivelmente vazia) de elementos gerados pela enumeração dos arquivos JAR no diretório nomeado. Por exemplo, se o diretório foocontém a.jar, b.jare c.jar, em seguida, o caminho de classe foo/*é expandido em foo/a.jar;foo/b.jar;foo/c.jar, e essa seqüência seria o valor da propriedade do sistema java.class.path.

A CLASSPATHvariável de ambiente não é tratada de maneira diferente da opção de linha de comando -classpath(ou -cp). Ou seja, os curingas são respeitados em todos esses casos. No entanto, os curingas do caminho da classe não são respeitados no Class-Path jar-manifestcabeçalho.

Nota: devido a um bug conhecido no java 8, os exemplos do Windows devem usar uma barra invertida que precede as entradas com um asterisco à direita: https://bugs.openjdk.java.net/browse/JDK-8131329

basszero
fonte
2
O recurso está mal documentado e parece exigir que algumas pré-condições menos do que óbvias sejam atendidas para funcionar como pretendido.
Alex R
1
+1 para o último truque bash / tr. O Java / JamVM aqui não gosta de curingas para caminhos fora do diretório de trabalho, mas faz referência explícita a cada JAR usando o curinga shell + trfunciona!
Supr
1
Eu tenho um comando java -classpath /jars/*:/anotherJarsDir/* com.test.MyClasssem aspas e funciona bem. Eu estou querendo saber por que shell não está expandindo e errando?
Yellavon 03/03
3
Também não use ~na -cp
Sohail Si
1
Seu exemplo do Windows não funciona com o java 8 ou anterior, mas funcionaria com este caminho de classe: Test.jar; lib \ * ... barra é aceitável, exceto quando precede um asterisco e alguns outros ... consulte bugs.openjdk. java.net/browse/JDK-8131329
philwalk
226

No Windows, isso funciona:

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

e isso não funciona:

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

observe o * .jar, portanto , o curinga * deve ser usado sozinho .


No Linux, o seguinte funciona:

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

Os separadores são dois pontos em vez de ponto e vírgula.

davorp
fonte
17
A resposta perfeita. 2 coisas importantes a notar: 1) Use aspas e 2) o uso * apenas, não * .jar
Wim Deblauwe
4
Um ano e oito meses depois, a edição que fiz para incluir a versão UNIX me salvou mais uma vez. :) Engraçado como ele não reconheceria meus arquivos jar com *.jarmas apenas com *.
precisa saber é o seguinte
Eu descobri que a ordem dos caminhos da classe é importante (mas não sei por quê). Eu estava recebendo erros até alterar a ordem dos caminhos de classe.
user13107
@ jmort253, a coisa é, este não é o shell * expansão, mas o curinga é java analisar o classpath, vendo a * e preenchendo o curinga
Sebastian
1
@SebastianGodelet - Sim, isso é apenas eu que estou ficando confuso entre os curingas Regex e essa notação, que não é a mesma que eu acho. Principalmente, o que me salvou é saber a diferença entre :uma plataforma e ;a outra. :) Eu compilo com Java a partir da linha de comando cerca de uma vez por ano, apenas o suficiente para não lembrar quantas vezes o suficiente para ser chato.
Jmort253
67

Contornamos esse problema implantando um arquivo jar principalmyapp.jar que contém um arquivo manifest ( Manifest.mf) especificando um caminho de classe com os outros jars necessários, que são implantados ao lado dele. Nesse caso, você só precisa declarar java -jar myapp.jarao executar o código.

Portanto, se você implantar o main jarem algum diretório e, em seguida, colocar os jars dependentes em uma libpasta abaixo, o manifesto será semelhante a:

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

Nota: isso é independente da plataforma - podemos usar os mesmos jars para iniciar em um servidor UNIX ou em um PC com Windows.

oxbow_lakes
fonte
Isso parece funcionar para muitas pessoas; no entanto, o Java parece ignorar claramente as entradas do Caminho de classe no arquivo de manifesto aqui. Não podemos executar o aplicativo sem adicionar manualmente "lib / *" ao caminho de classe usando -cp. Alguma ideia?
Raku 12/10
6
a resposta de oxbow_lakes não está totalmente correta; a coisa Caminho da classe é respeitada (e SOMENTE isso é respeitado; -cp / -classpath é ignorado!) se você iniciar este jar com java -jar myapp.jar. Presumo que oxbow_lakes pretendia escrever isso quando ele escreveu 'java -classpath myapp.jar'.
precisa saber é o seguinte
47

Minha solução no Ubuntu 10.04 usando o java-sun 1.6.0_24 com todos os jars no diretório "lib":

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

Se isso falhar, o seguinte comando deverá funcionar (imprime todos os * .jars no diretório lib no parâmetro classpath)

java -cp $ (para i em lib / *. jar; echo -n $ i:; done). my.main.Class
Habi
fonte
4
uma nota engraçada. java -cp lib / * my.main.Class sempre falha porque a expansão glob da lib / *, enquanto java -cp.: lib / * my.main.Class não ocorre porque.: lib / * não é um glob válido caminho. Reserve um tempo para observar que
albfan 22/03
1
Isso não funciona; O Linux irá expandir o arquivo . você pode tentar: java -cp '.: lib / ' e isso funciona bem (observe as aspas simples! Não funcionará com aspas duplas!). Na verdade,.: Lib / * pode funcionar se não for um globo legítimo devido aos dois pontos, mas parece um pouco duvidoso. Eu adicionaria as aspas. As aspas simples dizem ao bash para não tocar em nenhuma parte do conteúdo.
precisa saber é o seguinte
Não importa (neste contexto) se você usa aspas simples ou duplas. Você deseja impedir que o shell expanda (globbing) o *, isso é tudo. E passe o texto "lib / *" literalmente para a JVM, para que a VM reconheça isso como um "padrão especial" e procure por si só arquivos jar.
Angel O'Sphere
36

Resposta curta: java -classpath lib/*:. my.package.Program

A Oracle fornece documentação sobre o uso de curingas em caminhos de classe aqui para Java 6 e aqui para Java 7 , sob o cabeçalho da seção Noções básicas sobre curingas de caminho de classe . (Enquanto escrevo isso, as duas páginas contêm as mesmas informações.) Aqui está um resumo dos destaques:

  • Em geral, para incluir todos os JARs em um determinado diretório, você pode usar o curinga *( não *.jar ).

  • O curinga corresponde apenas aos JARs, não aos arquivos de classe; para obter todas as classes em um diretório, termine a entrada do caminho de classe no nome do diretório.

  • As duas opções acima podem ser combinadas para incluir todos os arquivos JAR e de classe em um diretório, e as regras usuais de precedência de caminho de classe se aplicam. Por exemplo-cp /classes;/jars/*

  • O curinga não procurará JARs nos subdiretórios.

  • Os pontos acima são verdadeiras se você usar a CLASSPATHpropriedade do sistema ou os -cpou -classpathcomando sinalizadores de linha. No entanto, se você usar o Class-Pathcabeçalho do manifesto JAR (como faria com um arquivo de construção de formiga), os curingas não serão respeitados.

Sim, meu primeiro link é o mesmo fornecido na resposta com pontuação mais alta (que eu não tenho esperança de ultrapassar), mas essa resposta não fornece muita explicação além do link. Como esse tipo de comportamento é desencorajado no Stack Overflow hoje em dia , pensei em expandir.

Pops
fonte
meu problema foi com lib / *. jar em vez de lib / *. Muito obrigado, isso foi corrigido. Notei que há uma diferença entre: e; mas esse poderia ser o meu tipo de teste, com muitas mudanças ao mesmo tempo.
Eyad Ebrahim 19/09/12
Obrigado pela enfatizando a diferença entre * e * .jar
burakhan alkan
36

Windows :

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

Linux :

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

Lembre:
- O separador de caminhos do Windows é ;
- O separador de caminhos do Linux é :
- No Windows, se o argumento cp não contiver espaço em branco, as "aspas" serão opcionais

Wender
fonte
janelas exemplo não funciona para java 8 e anterior: ver bugs.openjdk.java.net/browse/JDK-8131329
philwalk
Talvez não funciona para JDK aberta, vou testar isso e eu vou falar aqui
Wender
Desculpe, eu testei com o HotSpot e acho que funciona com o openjdk.
Wender
O Java Java sob Windows requer uma barra invertida antes do asterisco, em vez de uma barra, embora eu não tenha testado novamente as versões java mais recentes ou alternativas.
philwalk
não funciona em macos
Greyshack
34

Para mim, isso funciona no Windows.

java -cp "/lib/*;" sample

Para linux

java -cp "/lib/*:" sample

Estou usando Java 6

SANN3
fonte
janelas exemplo parece ter funcionado para Java 6, talvez java 7, mas não para java 8 (ver bugs.openjdk.java.net/browse/JDK-8131329 )
philwalk
Trabalha para java 8 em linux
Jonathan Drapeau
29

Você pode experimentar java -Djava.ext.dirs=jarDirectory http://docs.oracle.com/javase/6/docs/technotes/guides/extensions/spec.html

Diretório para jars externos ao executar java

Navi
fonte
3
Isso funciona, mas cuidado, passe o -Djava.ext.dirs=ANTES-jar
Giovanni Funchal
5
java.ext.dirs funcionará muito diferente de um jar normal no caminho de classe. Ele tem maior prioridade e permissão que capaz de substituir de alguma forma, aulas de bootstamp (rt.jar)
Dennis C
Obrigado. Na 'versão java "1.8.0_221" Java (TM) SE Runtime Environment (versão 1.8.0_221-b27) VM do servidor Java HotSpot (TM) de 64 bits (versão 25.221-b27, modo misto)', somente esta versão -D de passar no caminho da classe funcionou. A forma tradicional não.
Matt Campbell
23

Correto :

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

Incorreta:

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
rvernica
fonte
9

Se você realmente precisar especificar todos os arquivos .jar dinamicamente, poderá usar scripts de shell ou Apache Ant . Existe um projeto comum chamado Commons Launcher que basicamente permite que você especifique seu script de inicialização como um arquivo de construção de formiga (se você entende o que eu quero dizer).

Em seguida, você pode 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>

No seu arquivo de compilação de inicialização, que iniciará seu aplicativo com o caminho de classe correto.


fonte
8

Observe que a expansão do curinga está interrompida para o Java 7 no Windows.

Confira este problema do StackOverflow para obter mais informações.

A solução alternativa é colocar um ponto-e-vírgula logo após o curinga. java -cp "somewhere/*;"

Jake Toronto
fonte
6

A quem possa interessar,

Eu encontrei esse comportamento estranho no Windows sob um shell MSYS / MinGW.

Trabalho:

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

Não 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

Tenho certeza de que o curinga não é expandido pelo shell, porque, por exemplo,

$ echo './*'
./*

(Tentei também com outro programa, em vez do incorporado echo, com o mesmo resultado.)

Acredito que é isso javacque está tentando expandi-lo, e se comporta de maneira diferente se existe um ponto e vírgula no argumento ou não. Primeiro, pode estar tentando expandir todos os argumentos que parecem caminhos. E só então os analisaria, -cpusando apenas o seguinte token. (Observe que com.comsol.aco_1.0.0.jaré o segundo JAR nesse diretório.) Isso é apenas um palpite.

Isto é

$ javac -version
javac 1.7.0
Evgeni Sergeev
fonte
5

Todas as soluções acima funcionam muito bem se você desenvolver e executar o aplicativo Java fora de qualquer IDE como Eclipse ou Netbeans.

Se você estiver no Windows 7 e usou o Eclipse IDE for Development em Java, poderá encontrar problemas se estiver usando o Prompt de Comando para executar os arquivos de classe criados dentro do Eclipse.

Por exemplo, seu código-fonte no Eclipse está com a seguinte hierarquia de pacotes: edu.sjsu.myapp.Main.java

Você tem o json.jar como uma dependência externa para o Main.java

Quando você tenta executar o Main.java no Eclipse, ele será executado sem problemas.

Mas quando você tenta executar isso usando o Prompt de Comando após compilar o Main.java no Eclipse, ele dispara alguns erros estranhos dizendo "ClassNotDef Error blah blah".

Presumo que você esteja no diretório de trabalho do seu código-fonte !!

Use a seguinte sintaxe para executá-lo no prompt de comando:

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

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

    [Não perca a. acima]

Isso ocorre porque você colocou o Main.java dentro do pacote edu.sjsu.myapp e o java.exe procurará o padrão exato.

Espero que ajude !!

realPK
fonte
4

Para Windows, são necessárias aspas e; deve ser usado como separador. por exemplo:

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

Forma abreviada: Se o seu main estiver dentro de um jar, você provavelmente precisará de um adicional '-jar pathTo / yourJar / YourJarsName.jar' declarado explicitamente para fazê-lo funcionar (mesmo que 'YourJarsName.jar' esteja no caminho de classe) (ou , expressa para responder à pergunta original que foi feita há 5 anos: você não precisa redeclarar cada frasco explicitamente, mas parece que, mesmo com java6, você precisa redeclarar seu próprio frasco ...)


Forma Longa: (Eu expliquei isso ao ponto que espero que até intrusos no java possam fazer uso disso)

Como muitos aqui, estou usando o eclipse para exportar jarros: (Arquivo-> Exportar -> 'Arquivo JAR Runnable'). Existem três opções nas ofertas do eclipse 'Library handling' (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"

Normalmente, eu usaria opt2 (e opt1 estava definitivamente quebrando), no entanto, o código nativo em um dos jarros que estou usando descobri quebras com o prático truque "jarinjar" que o eclipse utiliza quando você escolhe essa opção. Mesmo depois de perceber que eu precisava do opt3 e encontrar a entrada StackOverflow, ainda levei algum tempo para descobrir como iniciar meu principal fora do eclipse, então aqui está o que funcionou para mim, pois é útil para outros ...


Se você nomeou seu jar: "fooBarTheJarFile.jar" e tudo está definido para exportar para o diretório: "/ theFully / qualificadoPath / toYourChosenDir".

(significando que o campo 'Exportar destino' será: '/theFully/qualifiedPath/toYourChosenDir/fooBarTheJarFile.jar')

Depois de concluir, você encontrará o eclipse e colocará todas as bibliotecas em uma pasta chamada 'fooBarTheJarFile_lib' dentro desse diretório de exportação, oferecendo 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

Você pode iniciar a partir de qualquer lugar no seu sistema com:

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

(Para iniciantes em Java: 'package.path_to.the_class_with.your_main' é o caminho do pacote declarado que você encontrará na parte superior do arquivo 'TheClassWithYourMain.java' que contém os 'main (String [] args) {.. .} 'que você deseja executar de fora do java)


A armadilha a ser observada: é que ter 'fooBarTheJarFile.jar' na lista de jars no caminho de classe declarado não é suficiente. Você precisa declarar explicitamente '-jar' e redeclarar a localização desse jar.

por exemplo, isso quebra:

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

atualizado com caminhos relativos:

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   

(usando a versão java "1.6.0_27"; via VM do servidor OpenJDK de 64 bits no ubuntu 12.04)

Matt S.
fonte
3

A única maneira de saber como fazê-lo individualmente, por exemplo:

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

Espero que ajude!

ParseTheData
fonte
Este pode ter sido o único caminho de volta em 2008, mas não mais.
precisa saber é o seguinte
Esta não é a pior coisa. É um hack, mas eu tenho este conjunto no meu bashrcfor jar in $(ls $HOME/bin/*.jar); do export CLASSPATH=$jar:$CLASSPATH; done
Devon Peticolas
3

classe 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
Mindaugas K.
fonte
2

Você precisa adicioná-los todos separadamente. Como alternativa, se você realmente precisar apenas especificar um diretório, poderá descompactar tudo em um diretório e adicioná-lo ao seu caminho de classe. No entanto, não recomendo esta abordagem, pois você corre o risco de problemas bizarros no controle de versão do classpath e na impossibilidade de gerenciamento.

Daniel Spiewak
fonte
3
Este pode ter sido o único caminho de volta em 2008, mas não mais.
precisa saber é o seguinte
2

Não é uma solução direta para definir / * como -cp, mas espero que você possa usar o script a seguir para facilitar um pouco a situação para caminhos de classe dinâmicos e diretórios 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; 

Com script para Linux, poderia ter um similar para o Windows também. Se o diretório adequado for fornecido como entrada para "libDir2Scan4jars"; o script varrerá todos os jars e criará uma sequência de caminho de classe e exportará para uma variável env "tmpCLASSPATH".

Sreesankar
fonte
2

macOS, pasta atual

Para Java 13 no macOS Mojave

Se todos os seus .jararquivos estiverem na mesma pasta, use cdpara tornar esse seu diretório de trabalho atual . Verifique com pwd.

Para o -classpathprimeiro, você deve listar o arquivo JAR do seu aplicativo. Usando um caractere de dois pontos :como delimitador, anexe um asterisco *para obter todos os outros arquivos JAR na mesma pasta. Por fim, passe o nome completo do pacote da classe com seu mainmétodo .

Por exemplo, para um aplicativo em um arquivo JAR nomeado my_app.jarcom um mainmétodo em uma classe nomeada Appem um pacote nomeado com.example, ao lado de alguns jars necessários na mesma pasta:

java -classpath my_app.jar:* com.example.App
Basil Bourque
fonte
não funciona para java 8
Greyshack
1

Pense em um arquivo jar como a raiz de uma estrutura de diretório. Sim, você precisa adicioná-los todos separadamente.

Robert Van Hoose
fonte
1

Defina o caminho da classe de uma maneira adequada para vários jars e os arquivos de classe do diretório atual.

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
Girdhar Singh Rathore
fonte
0

Eu tenho vários frascos em uma pasta. O comando abaixo trabalhou para mim JDK1.8para incluir todos os frascos presentes na pasta. Observe que para incluir aspas se você tiver um espaço no caminho de classe

janelas

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

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

Linux

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

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

vkrams
fonte
-1

Estou tentando executar o arquivo Java como jar ou como classes no Ubuntu. Eu falhei nas duas opções. A seguinte exceção é sua saída.

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

java org.statmetrics.Statmetric

ou

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

ou

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

Eu encontrei a resposta:

Minha estupidez.

Primeiro passo: você deve definir o Java correspondente: eu tinha o Java 11, mas defini como caminho da lib Java a 8ª versão! - Você pode definir a versão Java aqui:

  sudo update-alternatives --config java

2º passo: Em seguida, execute o seguinte comando, alterando o caminho e os nomes de arquivo para o caminho e os arquivos correspondentes:

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

Foi executado com sucesso!

Elias EstatisticsEU
fonte