Executando arquivo JAR no Windows

Eu tenho um arquivo JAR chamado helloworld.jar . Para executá-lo, estou executando o seguinte comando em uma janela de linha de comando:

java -jar helloworld.jar

Isso funciona bem, mas como eu o executo com um clique duplo? Preciso instalar algum software?

A rota mais fácil é provavelmente atualizar ou reinstalar o Java Runtime Environment (JRE).

Ou isto:

• Abra o Windows Explorer, em Ferramentas, selecione 'Opções de pasta ...'
• Clique na guia Tipos de arquivo, role para baixo e selecione Tipo de arquivo JAR.
• Pressione o botão Avançado.
• Na caixa de diálogo Editar tipo de arquivo, selecione abrir na caixa Ações e clique em Editar ...
• Pressione o botão Procurar e navegue até o local do interpretador Java javaw.exe.
• No campo Aplicativo usado para executar a ação, é necessário exibir algo semelhante a C:\Program Files\Java\j2re1.4.2_04\bin\javaw.exe" -jar "%1" %(Nota: a parte que começa com 'javaw' deve ser exatamente assim; a outra parte do nome do caminho pode variar dependendo da versão do Java que você está usando ) e pressione os botões OK até que todas as caixas de diálogo sejam fechadas.

Que foi roubado daqui: http://windowstipoftheday.blogspot.com/2005/10/setting-jar-file-association.html

No Windows Vista ou Windows 7, o editor manual de associação de arquivos foi removido.

A maneira mais fácil é executar o Jarfix , uma ferramenta freeware pequena, porém poderosa. Basta executá-lo e seus aplicativos Java estão de volta ... clicáveis ​​duas vezes novamente.

Se você precisar distribuir o arquivo .jar e torná-lo executável nos computadores Windows de outras pessoas, você pode criar um arquivo .bat simples como este no prompt de comando:

java -jar MyJavaTool.jar

e coloque o arquivo .bat no mesmo diretório que o arquivo .jar.

Se você tiver um arquivo jar chamado Example.jar, siga estas regras:

1. Abra um notepad.exe
2. Escrever : java -jar Example.jar
3. Salve-o com a extensão .bat
4. Copie-o para o diretório que possui o .jararquivo
5. Clique duas vezes nele para executar seu .jararquivo

Um efeito colateral interessante disso causa um problema ao iniciar arquivos jar executáveis ​​no prompt de comando.

Se você tentar (em um prompt de comando):

jarfile.jar parameter

Não há alegria, porque isso está sendo traduzido para o seguinte (o que não funciona):

javaw.exe -jar jarfile.jar parameter

No entanto, o seguinte comando funciona:

java.exe -jar jarfile.jar parameter

Se você alterar a associação no gerenciador de arquivos conforme descrito acima para:

"C:\Program Files\Java\j2re1.4.2_04\bin\java.exe" -jar "%1" %*

Então você pode digitar:

jarfile.jar parameter

no prompt de comando e agora funcionará!

EDIT: (No entanto, você obtém uma janela preta do console ao executar um aplicativo Java baseado em formulário (sem console), portanto, essa não é a solução ideal)

Se você executar esses arquivos jar clicando neles duas vezes no Windows, nenhum parâmetro será passado, portanto seu código Java precisará lidar com a exceção de estouro de pilha e incluir uma função "pressionar uma tecla" no final ou a janela simplesmente desaparecerá.

Para passar um parâmetro no Windows, você deve criar um atalho para o arquivo jar, que inclui o parâmetro na linha de destino (clique com o botão direito do mouse no atalho e selecione propriedades), não é possível adicionar parâmetros ao próprio ícone do arquivo jar neste maneira.

Não há uma solução única e consistente aqui, mas você teria o mesmo problema com qualquer outro aplicativo de console.

Existe um aplicativo freeware para Windows chamado "bat to exe", que você pode usar para criar um arquivo exe a partir de um arquivo .bat com a linha de comando apropriada. você também pode incorporar o arquivo jar no exe com este aplicativo e limpá-lo quando terminar de executar, portanto, essa pode ser uma solução mais elegante.

Primeiro conjunto de caminhos no cmd (prompt de comando):

set path="C:\Program Files\Java\jre6\bin"

então digite

java -jar yourProgramname.jar 

No Windows XP ^*, você precisa de apenas 2 comandos de shell :

   C:\>ftype myjarfile="C:\JRE1.6\bin\javaw.exe" -jar "%1" %* 
   C:\>assoc .jar=myjarfile  

obviamente, usando o caminho correto para o JRE e qualquer nome que você deseja, em vez de myjarfile .

Para apenas verificar as configurações atuais:

   C:\>assoc .jar  
   C:\>ftype jarfile  

desta vez usando o valor retornado pelo primeiro comando, se houver, em vez de jarfile .

^* não testado com Windows 7

Existe uma maneira sem exigir que o usuário faça alterações em seu PC. Runtime.getRuntime.exec () nos permite iniciar o cmd.exe e executar comandos dentro dele. Portanto, é possível que o programa java se execute no prompt de comando quando o usuário clica no arquivo .jar.

public static void main(String[] args) throws IOException {
    if(args.length == 0) {
        Process p = Runtime.getRuntime().exec("cmd.exe /c start java -jar " + (new File(NameOfClass.class.getProtectionDomain().getCodeSource().getLocation().getPath())).getAbsolutePath() + " cmd");
    } else {
        //code to be executed
    }
}

Além de todas as outras sugestões, há uma outra coisa que você precisa considerar. O seu helloworld.jar é um programa de console? Se for, não acredito que você consiga transformá-lo em um arquivo jar clicável duas vezes. Os programas de console usam a janela de shell normal do cmd.exe para entrada e saída. Normalmente, o jar "launcher" está vinculado ao javaw.exe, que não cria uma janela do shell de comando.

Estou executando o Windows 7 x64 e não consegui usar nenhuma dessas correções.

Este funcionou para mim afinal:

http://thepanz.netsons.org/post/windows7-jar-file-association-broken-with-nokia-ovi

Há um arquivo que você pode baixar contendo um arquivo .bat para executar, mas verifique o caminho do javaw.exe real !!!!

No regedit, abra HKEY_CLASSES_ROOT\Applications\java.exe\shell\open\command

Clique duas vezes no padrão à esquerda e adicione -jar entre o java.execaminho e o %1argumento " ".

Você quer checar algumas coisas; se esse for seu próprio arquivo jar, verifique se você definiu uma classe principal no manifesto. Como sabemos que você pode executá-lo na linha de comando, a outra coisa a fazer é criar um atalho do Windows e modificar as propriedades (você precisará dar uma olhada, eu não tenho uma máquina Windows para olhar) para que o comando que executa em aberto é o comando java -jar que você mencionou.

A outra coisa: se algo não está confuso, deve funcionar de qualquer maneira; verifique e verifique se você tem o java associado à extensão .jar.

Infelizmente, não é tão fácil quanto a Microsoft removeu o diálogo avançado de associação de arquivos nas edições recentes do Windows. - Nas versões mais recentes do Windows, você pode especificar apenas o aplicativo que será usado para abrir o arquivo .jar.

A correção da abertura do arquivo .jar no Windows requer duas etapas.

1. Abra o Painel de Controle e escolha "Programas Padrão -> Definir Associações". Encontre a extensão .jar ( arquivo JAR executável ) lá e escolha Java como programa padrão para abrir esta extensão. Provavelmente será listado como " Java Platform (SE) ". Uma alternativa mais rápida talvez seja o botão direito do mouse em um arquivo .jar e, em seguida, altere o programa associado clicando no botão "Alterar ...".

2. Agora abra o regedit e abra a HKEY_CLASSES_ROOT\jarfile\shell\open\commandchave. Para nossa sorte, podemos especificar parâmetros para o (Default)valor. No meu sistema Windows, parece: C:\app\32\jre7\bin\javaw.exe" -jar "%1" %*mas na maioria dos casos, é a seguinte string:C:\Program Files\Java\jre7\bin\javaw.exe" -jar "%1" %*

NOTAS:

• Não use java.exelá, pois isso abrirá a janela do shell.
• A ferramenta jarfix mencionada neste segmento provavelmente não faz mais que a modificação do registro para você. Prefiro o método de alteração manual do registro, pois isso implica que o administrador do sistema pode "enviar" a alteração do registro para todas as estações de trabalho na rede.

Eu tive o mesmo problema no Windows 10. Corrigi- o usando o botão direito do mouse em " helloworld.jar ", acesse Propriedades e clique no botão Alterar em "Abre com:" e selecione " Procurar outro aplicativo neste PC ". Na caixa de diálogo " Abrir com ... ", vá para o local da pasta Java no seu PC e abra a pasta jdk correspondente, abra a pasta bin e selecione " javaw.exe " a partir daí. Da próxima vez, o seu " helloworld.jar " abrirá da maneira normal.

Exemplo comum de localização em java: " C: \ Arquivos de Programas (x86) \ Java \ jdk1.8.0_111 \ bin ".

Outra maneira de executar arquivos jar com um clique / clique duplo é anexar "-jar" ao nome do arquivo. Por exemplo, você renomeia o arquivo MyJar.jarpara -jar MyJar.jar.

Você deve ter os .classarquivos associados java.exe, é claro. Isso pode não funcionar em todos os casos, mas funcionou na maioria das vezes para mim.

Prescrição : se o seu prompt aparecer e desaparecer imediatamente, o motivo é que o programa seja executado e desligado automaticamente. Tente colocar um scanner no final para finalizar e ele manterá seu prompt aguardando a entrada antes de finalizar. (Ou use atraso, talvez)

Estava na mesma situação em que a execução de .jar do cmd estava funcionando bem, mas o clique duplo não fez nada.

Solução: Abra qualquer editor de texto e escreva a linha de comando: java -jar Example.jar Salve o arquivo como um arquivo .bat. Execute este arquivo bat para obter a saída necessária.

Dando um passo à frente, você pode converter esse arquivo bat em exe usando uma ferramenta GUI simples como o Bat To Exe Converter.

Agora você pode compartilhar seu .jar como uma distribuição no arquivo .exe que qualquer pessoa pode usar, apenas certifique-se de manter todos os arquivos juntos. (Especialmente os arquivos .jar e .bat fazem com que .bat seja apenas um prompt de cmd) (como parece lógico)

Eu sou bastante novo no desenvolvimento e aprendendo muito. Desculpe por qualquer erro, se cometido. Sugestões são bem vindas.

use .batfile:

Coloque seu comando em um arquivo .bat. aqui, seu comando será java -jar path\yourJarName.jar. Something like: java -jar C:\workspace\myApplication.jar

Salve-o e clique duas vezes no arquivo bat para executar o seu jar. O nome do seu arquivo será algo comofileName.bat

Se você usar o eclipse para criar seus arquivos java, poderá optar por exportá-lo como um arquivo jar executável. Eu fiz isso com meus programas e posso apenas clicar no jar e ele será executado assim. Isso funcionará nas duas janelas, bem como no OS X.

Fazer um start.bat foi a única coisa que funcionou para mim.

abra um documento de texto e insira. java -jar como se chama .jar

salve como start.bat na mesma pasta que o arquivo .jar que você deseja executar. e depois execute o. bastão

Se você precisar executar o arquivo jar clicando duas vezes nele, precisará criá-lo como um " JAR Executável ". você pode fazer isso simplesmente com seu IDE.

Se você estiver usando o eclipse, siga estas etapas:

    To create a new runnable JAR file in the workbench:

1.From the menu bar's File menu, select Export.
2.Expand the Java node and select Runnable JAR file. Click Next.
3.In the  Opens the Runnable JAR export wizard Runnable JAR File Specification page, select a 'Java Application' launch configuration to use to create a runnable JAR.
4.In the Export destination field, either type or click Browse to select a location for the JAR file.
5.Select an appropriate library handling strategy.
Optionally, you can also create an ANT script to quickly regenerate a previously created runnable JAR file.

mais informações podem ser encontradas na página de ajuda do Eclipse: LINK

Existem muitos métodos para executar o arquivo .jar no Windows. Um deles está usando o prompt de comando.

Passos :

1. Abrir prompt de comando (Executar como administrador)
2. Agora escreva o comando "cd \" para o diretório raiz
3. Digite "java jar filename.jar" Nota: você também pode usar aplicativos de terceiros, como WinRAR, jarfix, etc.

Passos:

1.) pesquise o Java SE Runtime Environment no Google: https://www.google.com/search?q=Java+SE+Runtime+Environment

2.) instale a versão apropriada no seu computador

Criar .batarquivo:

start javaw -jar %*

E escolha o aplicativo padrão para abrir .jarcom este .batarquivo.

Ele será fechado cmdquando o .jararquivo for iniciado .

Para compilar:

javac  -cp ".;./mysql-connector-java-5.0.8.jar;mybatis-3.0.1.jar;ibatis-2.3.0.677.jar" MainStart.java

Para correr:

java  -cp ".;./mysql-connector-java-5.0.8.jar;mybatis-3.0.1.jar;ibatis-2.3.0.677.jar" MainStart

Na verdade, eu também enfrentei esse problema, resolvi-o criando um corredor .bat para o meu arquivo jar.

Aqui está o código:

class FileHandler{
   public static File create_CMD_Rnner(){
      int exitCode = -1625348952;
      try{
           File runner = new File(Main.batName);
           PrintWriter printer = new PrintWriter(runner);
           printer.println("@echo off");
           printer.println("title " + Main.applicationTitle);
           printer.println("java -jar " + Main.jarName + " " + Main.startCode );
           printer.println("PAUSE");
           printer.flush();
           printer.close();
           return runner;
       }catch(Exception e){
           System.err.println("Coudln't create a runner bat \n exit code: " + exitCode);
           System.exit(exitCode);
           return null;
       }
   }
}

Em seguida, na sua classe de aplicativo principal, faça o seguinte:

public class Main{
    static String jarName = "application.jar";
    static String applicationTitle = "java Application";
    static String startCode = "javaIsTheBest";
    static String batName = "_.bat";


    public static void main(String args[]) throws Exception{
        if(args.length == 0 || !args[0].equals(startCode)) {
            Desktop.getDesktop().open(FilesHandler.create_CMD_Rnner());
            System.exit(0);
        }else{
            //just in case you wanted to hide the bat
            deleteRunner();
            // Congratulations now you are running in a cmd window ... do whatever you want
            //......
            System.out.println("i Am Running in CMD");
            //......
            Thread.sleep(84600);
        }
    }


    public static void deleteRunner(){
        File batRunner = new File(batName);
        if(batRunner.exists()) batRunner.delete();
    }
}

Observe que

1. esse código (meu código) funciona apenas com um arquivo jar, não com um arquivo de classe.

2. o arquivo jar deve ter o mesmo nome que a string "jarName" é a classe principal