Como executar um arquivo JAR

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

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

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

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

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.

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

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.

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

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

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.

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

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)

Para executar jar, primeiro você tem que criar

jar executável

então

java -jar xyz.jar

comando funcionará