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?

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

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.

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.

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

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.

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

Para mim, isso funciona no Windows.

java -cp "/lib/*;" sample

Para linux

java -cp "/lib/*:" sample

Estou usando Java 6

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

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

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.

Se você estiver usando o Java 6, poderá usar curingas no caminho de classe.

Agora é possível usar caracteres curinga na definição de caminho de classe:

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/

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

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

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

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

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

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)

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!

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

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.

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

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

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

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

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

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!