java cvf Não é possível executar o jar-file: "no main manifest attribute"




netbeans manifest main class (24)

Eu instalei um aplicativo, quando tento executá-lo (é um jar executável) nada acontece. Quando eu corro da linha de comando com:

java -jar "app.jar"

Eu recebo a seguinte mensagem:

nenhum atributo manifesto principal, em "app.jar"

Normalmente, se eu tivesse criado o programa eu teria adicionado um atributo de classe principal ao arquivo de manifesto. Mas neste caso, como o arquivo é de um aplicativo, não posso fazer isso. Eu também tentei extrair o jar para ver se eu poderia encontrar a classe principal, mas existem para muitas classes e nenhuma delas tem a palavra "main" em seu nome. Deve haver uma maneira de corrigir isso porque o programa roda bem em outros sistemas.


Eu tive o mesmo problema. adicionando as seguintes linhas ao arquivo pom fez o trabalho. O plugin irá certificar-se do processo de compilação da sua aplicação com todos os passos necessários.

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

Você pode ter o mesmo problema que eu. Depois de criar seu arquivo .jar, escreva jar xf app.jar META-INF/MANIFEST.MF . Isso criará uma cópia do arquivo em seu diretório atual para que você possa lê-lo. Se apenas diz algo como:

Manifesto-Versão: 1.0

Criado por: 1.8.0_51 (Oracle Corporation)

e não contém a declaração "Main-Class", então acho que você encontrou o seu problema.

Eu não sei como resolver isso, no entanto. Eu verifiquei outras pessoas com problemas iguais / similares no e não consegui encontrar uma resposta. No entanto, com esta informação, talvez você possa obter ajuda melhor (dado o fato de que você tem o mesmo problema que eu).

Edit: Eu tinha tentado com um manifest-file, mas não consegui fazê-lo funcionar, mas o meu erro foi o de nomear apenas uma das classes ao criar o jar-file. Eu escrevi * .class em vez disso e funciona agora.

Embora eu não saiba por que é necessário criar um arquivo de manifesto. Mas eu acho que está tudo bem, desde que funcione.


Isso deveria ter sido java -jar app.jar vez de java -jar "app" .

A opção -jar só funciona se o arquivo JAR for um arquivo JAR executável, o que significa que ele deve ter um arquivo de manifesto com um atributo Main-Class . Veja Pacotes de Programas em Arquivos JAR para aprender como criar um JAR executável.

Se não for um JAR executável, você precisará executar o programa com algo como:

java -cp app.jar com.somepackage.SomeClass

onde com.somepackage.SomeClass é a classe que contém o método main para executar o programa. (O que essa classe é depende do programa, é impossível dizer a partir das informações que você forneceu).


Eu encontrei uma nova solução para geração de manifesto ruim!

  1. Abra o arquivo jar com um editor zip como o WinRAR
  2. Clique para META-INF

  3. Adicionar ou editar

    • Adicionar:

      • Crie um arquivo de texto chamado MANIFEST.MF em uma pasta chamada META-INF e adicione a seguinte linha:

        • Manifesto-Versão: 1.0
        • Classe principal: package.ex.com.views.mainClassName
      • Salve o arquivo e adicione-o ao zip

    • Editar:

      • Arraste o arquivo para fora modificar o MANIFEST.MF para adicionar a linha anterior
  4. Abra o cmd e digite: java -jar c: /path/JarName.jar

Deve funcionar bem agora!


Você pode simplesmente seguir este passo Criar um arquivo jar usando

 jar -cfm jarfile-name manifest-filename Class-file name

Ao executar o arquivo jar simples executar como este

 java -cp jarfile-name main-classname

Para mim, este erro ocorreu simplesmente porque eu esqueci dizer ao Eclipse que eu queria um arquivo jar executável e não um simples arquivo jar de biblioteca. Então, quando você criar o arquivo jar no Eclipse, certifique-se de clicar no botão direito


Se você estiver usando a linha de comando para montar .jar, é possível apontar para o principal sem adicionar o arquivo de manifesto. Exemplo:

jar cfve app.jar TheNameOfClassWithMainMethod *.class

(param "e" faz isso: TheNameOfClassWithMainMethod é um nome da classe com o método main () e app.jar - nome do executável .jar e * .class - apenas todos os arquivos de classes para montar)


verifique seu arquivo jar dentro de MANIFEST.MF Main-Class está disponível ou não

first.java

class first
{
        public static void main (String arg[ ])
        {
           System.out.println("Welcome to the world of Java");
        }
}

Antes :

Manifest-Version: 1.0
Created-By: 1.7.0_80 (Oracle Corporation)

[email protected]-VPCEH25EN:~/Documents$ java -jar first.jar
no main manifest attribute, in first.jar

Depois de:

Manifest-Version: 1.0
Created-By: 1.7.0_80 (Oracle Corporation)
Main-Class: first

[email protected]-VPCEH25EN:~/Documents$ java -jar first.jar 
Welcome to the world of Java

Se o jar não está seguindo as regras , não é um jar executável.


Eu tive esse problema ao criar um jar usando IntelliJ IDEA. Veja esta discussão .

O que resolveu para mim foi recriar o jar do artefato, escolhendo JAR> From modules with dependencies, mas não aceitando o diretório padrão para META-INF / MANIFEST.MF. Altere-o de - / src / main / java para - / src / main / resources.

Caso contrário, estava incluindo um arquivo de manifesto no jar, mas não aquele em - / src / main / java que deveria ter.


Eu tive esse problema e resolvi isso recentemente fazendo isso no NetBeans 8 (consulte a imagem abaixo):

  1. vá para as propriedades do seu projeto.
  2. clique em Executar .
  3. especifique a classe principal do seu projeto usando o browse .
  4. construa e execute o arquivo Jar.

Para mim, nenhuma das respostas realmente ajudou - eu tinha o arquivo manifesto no lugar correto, contendo o Main-Class e tudo mais. O que me tropeçou foi isso:

Aviso: O arquivo de texto a partir do qual você está criando o manifesto deve terminar com uma nova linha ou retorno de carro. A última linha não será analisada adequadamente se não terminar com uma nova linha ou retorno de carro.

( source ). Adicionando uma nova linha no final do manifesto, ela foi corrigida.


Tente este comando para incluir o jar:

java -cp yourJarName.jar your.package..your.MainClass

Apenas para esclarecer um ponto sobre

Main-Class: <packagename>.<classname>

Se você não tem pacote, você tem que ignorar essa parte, assim:

Main-Class: <classname>

Alternativamente, você pode usar o maven-assembly-plugin, como mostrado no exemplo abaixo:

<plugin>
    <artifactId>maven-assembly-plugin</artifactId>
    <executions>
      <execution>
        <phase>package</phase>
        <goals>
          <goal>single</goal>
        </goals>
      </execution>
    </executions>
    <configuration>
      <archive>
        <manifest>
          <addClasspath>true</addClasspath>
          <mainClass>com.package.MainClass</mainClass>
        </manifest>
      </archive>
      <descriptorRefs>
        <descriptorRef>jar-with-dependencies</descriptorRef>
      </descriptorRefs>
    </configuration>
  </plugin> 

Neste exemplo, todos os jars de dependência, conforme especificado na seção, serão incluídos automaticamente em seu único jar. Observe que jar-with-dependencies devem ser literalmente colocados como, para não serem substituídos pelos nomes de arquivos jar que você deseja incluir.


Eu enfrentei o mesmo problema e está consertado agora :) Apenas siga os passos abaixo e o erro pode ser para qualquer coisa, mas as etapas abaixo tornam o processo mais suave. Eu gasto muito tempo para encontrar a correção.

1.Tente reiniciar o Eclipse (se você estiver usando o Eclipse para construir o arquivo JAR) -> Na verdade, isso ajudou meu problema ao exportar o arquivo JAR corretamente.

2.Após a reinicialização do eclipse, tente ver se seu eclipse é capaz de reconhecer a classe / método principal pelo seu projeto Java -> clique com o botão direito -> Executar como -> Configurações de execução -> Principal -> clique no botão Pesquisar para ver se o seu eclipse é capaz de procurar sua classe principal no arquivo JAR. -> Isto é para a validação que o arquivo JAR terá o ponto de entrada para a classe principal.

  1. Depois disso, exporte seu projeto Java Dynamic como o arquivo "Runnable JAR" e não o arquivo JAR.

  2. Na configuração de ativação do Java, escolha sua classe principal.

  3. Depois de exportar o arquivo jar, use o comando abaixo para executar. java -cp [Seu JAR] .jar [pacote completo] .MainClass, por exemplo: java -cp AppleTCRuleAudit.jar com.apple.tcruleaudit.classes.TCRuleAudit

  4. Você pode enfrentar o erro de versão do java sem suporte. a correção é alterar o java_home em seu perfil bash do shell para corresponder à versão java usada para compilar o projeto no eclipse.

Espero que isto ajude! Por favor, deixe-me saber se você ainda tem algum problema.


Para o maven, foi isso que resolveu (para mim, para uma base de código do Veetle no GitHub):

<build>
<plugins>
  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-shade-plugin</artifactId>
    <version>2.0</version>
    <executions>
      <execution>
        <phase>package</phase>
        <goals>
          <goal>shade</goal>
        </goals>
        <configuration>
          <transformers>
            <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
              <mainClass>org.lazydevs.veetle.api.VeetleAPI</mainClass>
            </transformer>
          </transformers>
        </configuration>
      </execution>
    </executions>
  </plugin>
 </plugins>
</build>

Felicidades...


A resposta do Gradle é adicionar uma configuração de jar / manifest / attributes como esta:

apply plugin: 'java'

jar {
    manifest {
        attributes 'Main-Class': 'com.package.app.Class'
    }
}

Qualquer arquivo jar executável Deve ser executado clicando ou executando usando o prompt de comando como java -jar app.jar (use "se o caminho do jar contiver espaço" - isto é, java -jar "C: \ nome da pasta \ app.jar"). Se o jar do executável não estiver em execução, o que significa que ele não foi criado corretamente.

Para entender melhor, extraia o arquivo jar (ou visualize usando qualquer ferramenta, para o windows 7-Zip é bom) e verifique o arquivo em /META-INF/MANIFEST.MF. Se você encontrar alguma entrada como

Main-class: your.package.name.ClaaswithMain - então tudo bem, caso contrário você terá que fornecer.

Esteja ciente de anexar a entrada Main-Class no arquivo MANIFEST.MF, verifique onde você está salvando!


Como você adicionou MANIFEST.MF, acho que você deve considerar a ordem de Field nesse arquivo. Meu env é a java version "1.8.0_91"

e meu MANIFEST.MF como aqui

// MANIFEST.MF
Manifest-Version: 1.0
Created-By: 1.8.0_91 (Oracle Corporation)
Main-Class: HelloWorldSwing

// run
~ java -jar HelloWorldSwing.jar
no main manifest attribute, in HelloWorldSwing.jar

No entanto, isso como abaixo percorrer

Manifest-Version: 1.0
Main-Class: HelloWorldSwing
Created-By: 1.8.0_91 (Oracle Corporation)

//this run swing normally

Primeiro, é meio estranho ver você rodando java -jar "app" e não java -jar app.jar

Em segundo lugar, para fazer um executável jar ... você precisa jar em um arquivo chamado META-INF / MANIFEST.MF

o arquivo em si deve ter (pelo menos) este forro:

Main-Class: com.mypackage.MyClass

Onde com.mypackage.MyClass é a classe que contém o ponto de entrada public static void main (String [] args) .

Note que existem várias maneiras de fazer isso com o CLI, o Maven, o Ant ou o Gradle:

Para CLI , o comando a seguir fará: (tks @ dvvrt ) jar cmvf META-INF/MANIFEST.MF <new-jar-filename>.jar <files to include>

Para o Maven , algo como o seguinte trecho deve fazer o truque. Observe que esta é apenas a definição do plug-in, não o pom.xml completo:

<build>
  <plugins>
    <plugin>
      <!-- Build an executable JAR -->
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-jar-plugin</artifactId>
      <version>3.1.0</version>
      <configuration>
        <archive>
          <manifest>
            <addClasspath>true</addClasspath>
            <classpathPrefix>lib/</classpathPrefix>
            <mainClass>com.mypackage.MyClass</mainClass>
          </manifest>
        </archive>
      </configuration>
    </plugin>
  </plugins>
</build>

(Escolha uma <version> apropriada ao seu projeto.)

Para Ant , o snippet abaixo deve ajudar:

<jar destfile="build/main/checksites.jar">
  <fileset dir="build/main/classes"/>
  <zipfileset includes="**/*.class" src="lib/main/some.jar"/>
  <manifest>
    <attribute name="Main-Class" value="com.acme.checksites.Main"/>
  </manifest>
</jar>

Créditos Michael Niemand -

Para Gradle :

plugins {
    id 'java'
}

jar {
    manifest {
        attributes(
                'Main-Class': 'com.mypackage.MyClass'
        )
    }
}

As respostas acima foram apenas parcialmente úteis para mim. java -cp fazia parte da resposta, mas eu precisava de informações mais específicas sobre como identificar a classe a ser executada. Aqui está o que funcionou para mim:

Etapa 1: encontre a turma que preciso executar

jar tf /path/to/myjar.jar | more

As principais linhas do resultado foram:

META-INF/
META-INF/MANIFEST.MF
somepath/
somepath/App.class
META-INF/maven/
...

App.class continha a classe principal a ser executada. Eu não tenho 100% de certeza se você pode sempre assumir que a classe que você precisa é a primeira, mas foi para mim. Se não for, imagino que não seja muito difícil usar o grep para excluir resultados relacionados à biblioteca para reduzir a lista de classes a um tamanho gerenciável.

De lá, foi fácil: eu apenas uso esse caminho (menos o sufixo ".class"):

java -cp /path/to/myjar.jar somepath/App

Você pode não ter criado o arquivo jar corretamente:

ex: falta da opção m na criação do jar

Os seguintes trabalhos:

jar -cvfm MyJar.jar Manifest.txt *.class

(primeiro post - então pode não estar limpo)

Esta é a minha correção para o OS X 11.6, programa Netbeans 8.2 baseado em Maven. Até agora meu aplicativo é 100% Netbeans - sem ajustes (apenas alguns escapes para o impossível!).

Tendo tentado a maioria das respostas aqui e em outros lugares sem sucesso, voltei à arte de "usar o que funciona".

A resposta principal aqui ( thanx) parecia o lugar certo para começar, mas não ajudou.

Olhando para outros projetos que funcionaram, notei algumas pequenas diferenças nas linhas de manifesto:

  1. addClasspath, classpathPrefix estavam ausentes (foram excluídos)
  2. mainClass estava faltando o "com". (usado o NB -> Propriedades do Projeto-> Executar-> Classe Principal-> Navegar para especificar)

Não tenho certeza porque (eu sou apenas 3 meses em java) ou como, mas só posso dizer que isso funcionou.

Aqui está apenas o bloco de manifesto modificado usado:

    <manifest>
        <mainClass>mypackage.MyClass</mainClass>
    </manifest>




main