Como executar um arquivo JAR

207

Eu criei um arquivo JAR assim:

jar cf Predit.jar *.*

Eu executei esse arquivo JAR clicando duas vezes nele (não funcionou). Então eu executei no prompt do DOS assim:

java -jar Predit.jar

Ele levantou exceções "Falha ao carregar a classe principal". Então eu extraí esse arquivo JAR:

jar -xf Predit.jar

e eu executei o arquivo de classe:

java Predit

Funcionou bem. Não sei por que o arquivo JAR não funcionou. Por favor, diga-me as etapas para executar o arquivo JAR

Martin Prikryl
fonte

Respostas:

207

Você precisa especificar uma classe principal no manifesto do arquivo jar.

O tutorial da Oracle contém uma demonstração completa, mas aqui está outra do zero. Você precisa de dois arquivos:

Test.java:

public class Test
{
    public static void main(String[] args)
    {
        System.out.println("Hello world");
    }
}

manifest.mf:

Manifest-version: 1.0
Main-Class: Test

Observe que o arquivo de texto deve terminar com uma nova linha ou retorno de carro. A última linha não será analisada corretamente se não terminar com uma nova linha ou retorno de carro.

Então corra:

javac Test.java
jar cfm test.jar manifest.mf Test.class
java -jar test.jar

Resultado:

Hello world
Jon Skeet
fonte
1
se a classe Test se refere a outra classe via arquivo jar, nesse caso, que modificações devem ser feitas?
Anand
@Anand, você precisa incluir uma linha de caminho de classe no manifesto e referenciar os outros jar (es). docs.oracle.com/javase/tutorial/deployment/jar/downman.html
rob
Por favor, ajude-me sobre esta questão: stackoverflow.com/questions/24740803/...
Sajad
Eu acho que ter Manifest-version: 1.0 não é necessário porque o conteúdo do arquivo de manifesto fornecido é anexado ao arquivo de manifesto padrão que já possui a versão docs.oracle.com/javase/tutorial/deployment/jar/appman.html
Georgii Oleinikov 07/10
2
Esta é apenas uma amostra de ponta a ponta. Perfeito batata frita simples. Eu estava procurando algo assim por horas. Não sei por que a Internet inteira está cheia com todo o lixo, sem um exemplo tão simples, quando pesquisado como criar o java jar "Hello world". Muitíssimo obrigado.
Atul
58
java -classpath Predit.jar your.package.name.MainClass
Lynch
fonte
Se este jar usar outros jarros, o caminho da classe não deve ser "/ path / to / jars / *"?
Maxim Chetrusca
5
@Max Chetrusca Sim, mas o separador é :usar *não vai funcionar porque o seu shell irá expandir-lo assim: "/path/to/jars/a.jar" "/path/to/jars/b.jar"mas o que você realmente quer é: "/path/to/jars/a.jar:/path/to/jars/b.jar".
Lynch
29

Antes de executar, a verificação do jar Main-Class: classnameestá disponível ou não no arquivo MANIFEST.MF . MANIFEST.MF está presente no jar.

java -jar filename.jar
KARTHIKEYAN.A
fonte
16

Você precisa adicionar um manifesto ao jar, que informa ao tempo de execução do java qual é a classe principal. Crie um arquivo 'Manifest.mf' com o seguinte conteúdo:

Manifest-Version: 1.0
Main-Class: your.programs.MainClass

Altere 'your.programs.MainClass' para sua classe principal real. Agora coloque o arquivo no arquivo Jar, em uma subpasta chamada 'META-INF'. Você pode usar qualquer utilitário ZIP para isso.

Florian Fankhauser
fonte
1
Por curiosidade, o nome da subpasta 'Meta-inf' diferencia maiúsculas de minúsculas? Tenho visto tradicionalmente escrito 'META-INF'
Adam Paynter
Você está certo. A especificação diz "META-INF" e não diz nada sobre o caso insensibilidade ( java.sun.com/j2se/1.4.2/docs/guide/jar/... )
Florian Fankhauser
12

Uma abordagem muito simples para criar arquivos .class, .jar.

Executando o arquivo jar. Não precisa se preocupar muito com o arquivo de manifesto. Torne simples e elegante.

Amostra de Java Hello World Program

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

Compilando o arquivo de classe

javac HelloWorld.java

Criando o arquivo jar

jar cvfe HelloWorld.jar HelloWorld HelloWorld.class

ou

jar cvfe HelloWorld.jar HelloWorld *.class

Executando o arquivo jar

 java -jar HelloWorld.jar

Ou

java -cp HelloWorld.jar HelloWorld
nagendra547
fonte
Sim, a jaropção 's epermite especificar o Main-Class(ponto de entrada ) e também cria um arquivo de manifesto correspondente para você. Veja a documentação oficial para jar .
Petr Bodnár 12/11/19
11

Se você não deseja criar um manifesto apenas para executar o arquivo jar, você pode referenciar a classe principal diretamente na linha de comando quando executar o arquivo jar.

java -jar Predit.jar -classpath your.package.name.Test

Isso define a classe principal a ser executada no arquivo jar.

Egil
fonte
2
-classpathvem logo depois javae se livrar de -jar(ou seja, esta resposta está incorreta)
Pete
4

Java

class Hello{
   public static void main(String [] args){
    System.out.println("Hello Shahid");
   }
}

manifest.mf

Manifest-version: 1.0
Main-Class: Hello

Na linha de comando:

$ jar cfm HelloMss.jar  manifest.mf Hello.class 
$ java -jar HelloMss.jar

Resultado:

Hello Shahid
Mohammad Shahid Siddiqui
fonte
3

Se você não quiser lidar com esses detalhes, também poderá usar os assistentes de jar de exportação do Eclipse ou NetBeans.

fortran
fonte
3

Arquivo JAR executável do Eclipse

Crie um projeto Java - RunnableJAR

  • Se algum arquivo jar for usado, adicione-os ao caminho de construção do projeto.
  • Selecione a classe que possui main () ao criar o arquivo Jar Runnable. insira a descrição da imagem aqui

Classe principal

public class RunnableMainClass {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("Name : "+args[0]);
        System.out.println(" ID  : "+args[1]);
    }
}

Execute o arquivo Jar usando o programa java ( cmd ) fornecendo argumentos e obtenha a saída e a exibição no console do eclipse.

public class RunJar { 
    static StringBuilder sb = new StringBuilder();
    public static void main(String[] args) throws IOException {
        String jarfile = "D:\\JarLocation\\myRunnable.jar";
        String name = "Yash";
        String id = "777";

        try { // jarname arguments has to be saperated by spaces
            Process process = Runtime.getRuntime().exec("cmd.exe start /C java -jar "+jarfile+" "+name+" "+id);
                    //.exec("cmd.exe /C start dir java -jar "+jarfile+" "+name+" "+id+" dir");
            BufferedReader br = new BufferedReader(new InputStreamReader(process.getInputStream ()));
            String line = null;
            while ((line = br.readLine()) != null){
                sb.append(line).append("\n");
            }
            System.out.println("Console OUTPUT : \n"+sb.toString());
            process.destroy();
        }catch (Exception e){
            System.err.println(e.getMessage());
        }
   }
}

No Eclipse, para encontrar Atalhos :

Ajuda ► Conteúdo da Ajuda ► Guia do Usuário de Desenvolvimento Java ► Referências ► Menus e Ações

Yash
fonte
3

Eu tenho esta estrutura de pastas:

D: \ JavaProjects \ OlivePressApp \ com \ lynda \ olivepress \ Main.class D: \ JavaProjects \ OlivePressApp \ com \ lynda \ olivepress \ press \ OlivePress.class D: \ JavaProjects \ OlivePressApp \ com \ lynda \ olivepress \ oliveiras \ Kalamata classe D: \ JavaProjects \ OlivePressApp \ com \ lynda \ olivepress \ azeitonas \ Ligurian.classe D: \ JavaProjects \ OlivePressApp \ com \ lynda \ olivepress \ azeitonas \ Olive.class

Main.class está no pacote com.lynda.olivepress

Existem outros dois pacotes:

com.lynda.olivepress.press

com.lynda.olivepress.olive

1) Crie um arquivo nomeado "Manifest.txt"com duas linhas, primeiro com a classe principal e uma segunda linha vazia.

Main-Class: com.lynda.olivepress.Main

D: \ JavaProjects \ OlivePressApp \ Manifest.txt

2) Criar JAR com manifesto e ponto de entrada de classe principal

D: \ JavaProjects \ OlivePressApp>jar cfm OlivePressApp.jar Manifest.txt com/lynda/olivepress/Main.class com/lynda/olivepress/*

3) Execute o JAR

java -jar OlivePressApp.jar

Nota: com/lynda/olivepress/*significa incluir os outros dois pacotes mencionados acima, antes do ponto 1)

Gabriel D
fonte
-2

Para executar jar, primeiro você tem que criar

jar executável

então

java -jar xyz.jar

comando funcionará

Deepa
fonte