Não é possível executar o arquivo jar: “nenhum atributo principal do manifesto”

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

java -jar "app.jar"

Recebo a seguinte mensagem:

nenhum atributo principal do manifesto, em "app.jar"

Normalmente, se eu mesmo tivesse criado o programa, 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. Também tentei extrair o jar para ver se conseguia encontrar a classe principal, mas existem muitas classes e nenhuma delas tem a palavra "main" em seu nome. Deve haver uma maneira de corrigir isso, porque o programa funciona bem em outros sistemas.

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

Segundo, para tornar um jar executável ... você precisa jarar um arquivo chamado META-INF / MANIFEST.MF

o próprio arquivo deve ter (pelo menos) este liner:

Main-Class: com.mypackage.MyClass

Onde com.mypackage.MyClassestá a classe que contém o ponto de entrada público estático void main (String [] args) .

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

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

Para 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 um <version>apropriado para o 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'
        )
    }
}

Isso deveria ter sido em java -jar app.jarvez de java -jar "app".

A -jaropção funciona apenas se o arquivo JAR for um arquivo JAR executável, o que significa que ele deve ter um arquivo de manifesto com um Main-Classatributo nele. Consulte Empacotando programas em arquivos JAR para saber como criar um JAR executável.

Se não for um JAR executável, será necessário executar o programa com algo como:

java -cp app.jar com.somepackage.SomeClass

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

Como alternativa, você pode usar o maven-assembly-plugin, conforme 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 automaticamente incluídos no seu jar único. Observe que jar-with-dependencies deve ser literalmente colocado como, para não ser substituído pelos nomes dos arquivos jar que você deseja incluir.

Isso ocorre porque o Java não pode encontrar o atributo Main no arquivo MANIFEST.MF. O atributo Main é necessário para informar ao java qual classe ele deve usar como ponto de entrada do aplicativo. Dentro do arquivo jar, o arquivo MANIFEST.MF está localizado na pasta META-INF. Quer saber como você pode ver o que há dentro de um arquivo jar? Abra o arquivo jar com o WinRAR.

O atributo principal dentro do MANIFEST.MF é parecido com este:

Main-Class: <packagename>.<classname>

Você recebe esse erro "nenhum atributo de manifesto principal" quando esta linha está ausente no arquivo MANIFEST.MF.

É realmente uma bagunça enorme especificar esse atributo dentro do arquivo MANIFEST.MF.

Atualização: Acabei de encontrar uma maneira realmente elegante de especificar o ponto de entrada do aplicativo no eclipse. Quando você diz Exportar,

Select Jar and next 

[ give it a name in the next window ] and next

and next again

and you'll see " Select the class of the application entry point".

Just pick a class and Eclipse will automatically build a cool MANIFEST.MF for you.

Eu tive o mesmo problema. adicionando as seguintes linhas ao arquivo pom fez com que funcionasse. O plugin garantirá o processo de criação do seu aplicativo com todas as etapas necessárias.

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

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

apply plugin: 'java'

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

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

O que resolveu para mim foi recriar o artefato jar, escolhendo JAR> Dos módulos com dependências, 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 o arquivo - / src / main / java que deveria ter.

Para o maven, foi isso que o resolveu (para mim, para uma base de código 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...

Tente este comando para incluir o jar:

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

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

Aviso: O arquivo de texto do qual você está criando o manifesto 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.

( fonte ). A adição de uma nova linha no final do manifesto foi corrigida.

Se estiver usando o Maven, inclua o seguinte no pom

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.4.2.RELEASE</version>
</parent>

<properties>
    <java.version>1.8</java.version>
</properties>

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

Eu tive o mesmo problema hoje. Meu problema foi resolvido ao mover o META-INF para a pasta de recursos.

Eu tenho o mesmo erro agora. Se você estiver usando gradle, basta adicionar o próximo em ur gradle.build:

apply plugin: 'java'

jar {
    manifest {
        attributes 'Main-Class': 'com.company.project.MainClass'
    }
}

Onde com.company.project.MainClasscaminho para sua classe com o public static void main(String[] args)método

O problema MAVEN é que ele tenta incluir o primeiro arquivo MANIFEST.MF da primeira biblioteca de dependências, em vez de NOSSO PRÓPRIO MANIFEST.MF ao usar artefatos! .

1. Renomeie yourjar.jar para yourjar.zip
2. Abra o arquivo MANIFEST.MF em META-INF \ MANIFEST.MF

3. Copie o MANIFEST.MF real que já gera em seu projeto por MAVEN. Isso inclui alguns que:

   Versão do manifesto: 1.0 Classe principal: yourpacket.yourmainclass (por exemplo, info.data.MainClass)

4. Substitua o conteúdo do MANIFEST.MF do youjar.zip por ele.

5. Renomeie yourjar.zip para yourjar.jar de volta.
6. Agora java -jar yourjar.jar funciona perfeitamente.

OU!

Simples crie seu próprio MANIFEST.MF e:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>3.2.0</version>
    <configuration>
        <archive>
            <manifestFile> Your path like: src/main/resources/META-INF/MANIFEST.MF </manifestFile>
            <index>true</index>
                <manifest>
                    <addClasspath>true</addClasspath>
                </manifest>
        </archive>
    </configuration>
</plugin>

Mas se você usar o painel maven (ou linha de comando maven), poderá forçá-lo a gerar seu próprio manifesto e incluí-lo no arquivo JAR.

1. Adicione à seção de compilação do you pom.xml este código:

   <plugins>
       <plugin>
   
       <groupId>org.apache.maven.plugins</groupId>
       <artifactId>maven-assembly-plugin</artifactId>
       <version>3.2.0</version>
       <executions>
           <execution>
               <phase>package</phase>
               <goals>
                   <goal>single</goal>
               </goals>
           </execution>
       </executions>
   
       <configuration>
           <descriptorRefs>
               <descriptorRef>jar-with-dependencies</descriptorRef>
           </descriptorRefs>
   
           <archive>
   
               <index>true</index>
   
               <manifest>
                   <addClasspath>true</addClasspath>
                   <mainClass> yourpacket.yourmainclass (for exmaple info.data.MainClass)</mainClass>
               </manifest>
               <manifestEntries>
                   <mode>development</mode>
                   <url>${project.url}</url>
               </manifestEntries>
           </archive>
       </configuration>
   </plugin>

2. Abra o painel MAVEN (no Intellij) e execute "Install". Ele irá gerar o arquivo MANIFEST e compilar a propriedade JAR com todas as dependências na pasta "Destino". Também será instalado no repositório maven local.

Se o jar não estiver seguindo as regras , não será um jar executável.

Eu enfrentei o mesmo problema e ele foi corrigido agora :) Basta seguir as etapas abaixo e o erro pode ser qualquer coisa, mas as etapas abaixo tornam o processo mais suave. Passo muito tempo para encontrar a solução.

1.Tente reiniciar o Eclipse (se você estiver usando o Eclipse para criar 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 o seu eclipse é capaz de reconhecer a classe / método principal pelo seu projeto Java -> clique com o botão direito do mouse -> Executar como -> Executar configurações -> 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 de que o arquivo JAR terá o ponto de entrada para a classe principal.

4. Depois disso, exporte seu projeto Java Dynamic como arquivo "JAR executável" e não como arquivo JAR.

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

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

7. Você pode enfrentar o erro de versão java não suportado. a correção é alterar o java_home no perfil do shell bash 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.

Eu tive o mesmo problema. Muitas das soluções mencionadas aqui não me deram a imagem completa, então tentarei dar um resumo de como compactar arquivos jar na linha de comando .

1. Se você deseja ter seus .classarquivos em pacotes, adicione o pacote no início do .java.

   Test.java

   package testpackage;
   
   public class Test
   {
       ...
   }

2. Para compilar seu código com os .classarquivos que terminam com a estrutura fornecida pelo nome do pacote, use:

   javac -d . Test.java

   Isso -d .faz com que o compilador crie a estrutura de diretórios desejada.

3. Ao empacotar o .jararquivo, você precisa instruir a rotina jar sobre como empacotá-lo. Aqui usamos o conjunto de opções cvfeP. Isso é para manter a estrutura do pacote (opção P), especifique o ponto de entrada para que o arquivo de manifesto contenha informações significativas (opção e). Option fpermite especificar o nome do arquivo, a opção ccria um archive e a opção vdefine a saída como detalhada. As coisas importantes a serem observadas aqui são Pe e.

   Depois vem o nome do frasco que queremos test.jar.

   Então vem o ponto de entrada.

   E então chega -C . <packagename>/para obter os arquivos de classe dessa pasta, preservando a estrutura da pasta.

   jar cvfeP test.jar testpackage.Test -C . testpackage/

4. Verifique seu .jararquivo em um programa zip. Deve ter a seguinte estrutura

   test.jar

   META-INF
   | MANIFEST.MF
   testpackage
   | Test.class

   O MANIFEST.MF deve conter o seguinte

   Manifest-Version: 1.0
   Created-By: <JDK Version> (Oracle Corporation)
   Main-Class: testpackage.Test

   Se você editar seu manifesto manualmente, mantenha a nova linha no final, caso contrário, o java não o reconhecerá.

5. Execute seu .jararquivo com

   java -jar test.jar

Pessoalmente, acho que todas as respostas aqui entendem mal a pergunta. A resposta para isso está na diferença de como o spring-boot cria o .jar. Todo mundo sabe que o Spring Boot configura um manifesto como este, que varia de todos os pressupostos de que este é um lançamento .jar padrão, que pode ou não ser:

Start-Class: com.myco.eventlogging.MyService
Spring-Boot-Classes: BOOT-INF/classes/
Spring-Boot-Lib: BOOT-INF/lib/
Spring-Boot-Version: 1.4.0.RELEASE
Created-By: Apache Maven 3.3.9
Build-Jdk: 1.8.0_131
Main-Class: org.springframework.boot.loader.JarLauncher

Talvez ele precise ser executado org.springframework.boot.loader.JarLauncherno caminho de classe?

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 da jar contiver espaço" - ou seja, java -jar "C: \ nome da pasta \ app.jar"). Se o seu jar executável não estiver em execução, significa que ele não foi criado corretamente.

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

Classe principal: your.package.name.ClaaswithMain - então tudo bem, caso contrário você precisará fornecê-lo.

Esteja ciente de anexar a entrada da classe principal no arquivo MANIFEST.MF, verifique onde está salvando!

Você pode simplesmente seguir esta etapa Crie um arquivo jar usando

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

Ao executar o arquivo jar, execute simples assim

 java -cp jarfile-name main-classname

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

ex: opção ausente m na criação de jar

Os seguintes trabalhos:

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

Se você estiver usando a linha de comando para montar .jar, é possível apontar para o principal sem adicionar o arquivo Manifest. 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 classe para montar)

Para mim, esse erro ocorreu simplesmente porque eu esqueci de dizer ao Eclipse que queria um arquivo jar executável e não um arquivo jar de biblioteca simples. Portanto, ao criar o arquivo jar no Eclipse, clique no botão de opção direito

As respostas acima foram apenas parcialmente úteis para mim. java -cpfazia 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 classe 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. Não tenho 100% de certeza se você sempre pode assumir que a turma de que precisa é a primeira, mas foi para mim. Se não for, imagino que não seja muito difícil usar grep para excluir resultados relacionados à biblioteca para reduzir a lista de classes a um tamanho gerenciável.

A partir daí, foi fácil: eu apenas uso esse caminho (menos o sufixo ".class"):

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

Desde que você adicionou MANIFEST.MF, acho que você deve considerar a ordem do campo neste arquivo. Meu env é 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 mostrado abaixo

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

//this run swing normally

(primeiro post - pode não estar limpo)

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

Tendo tentado quase todas as respostas aqui e em outros lugares sem sucesso, voltei à arte de "usar o que funciona".

A resposta principal aqui ( olivier-refalo 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 do manifesto:

1. addClasspath, classpathPrefix estavam ausentes (os excluíram)
2. mainClass estava faltando o "com". (usado NB -> Propriedades do projeto -> Executar -> Classe principal -> Procurar para especificar)

Não sei por que (eu tenho 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>

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

1. Abra o arquivo jar com um editor de 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:

       • Versão do manifesto: 1.0
       • Classe principal: package.ex.com.views.mainClassName

     • Salve o arquivo e adicione-o ao zip

   • Editar:

     • Arraste o arquivo, modifique o MANIFEST.MF para adicionar a linha anterior

4. Abra o cmd e digite: java -jar c: /path/JarName.jar

Deve funcionar bem agora!

a maioria das soluções não funcionou para mim, mas meu instrutor me ajudou, gostaria de compartilhar sua solução aqui, usei o terminal kali linux, mas deve estar bem em todos

javac *.java
nano MANIFEST.MF

no tipo de arquivo

Classe principal: principal ou qualquer que seja o seu nome de arquivo principal (adicione o nome do pacote, se houver)

jar -cvmf MANIFEST.MF new.jar *.class

agora para executar o arquivo use

java -jar new.jar

ou você pode acessar as propriedades do arquivo e verificar

Permitir execução de arquivo como programa

clique duas vezes nele

me ajudou enquanto a maioria das respostas acima não

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

Versão do manifesto: 1.0

Criado por: 1.8.0_51 (Oracle Corporation)

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

Eu não sei como resolvê-lo, no entanto. Eu verifiquei outras pessoas com problemas iguais / semelhantes no StackOverflow e não consegui encontrar uma resposta. No entanto, com essas informações, talvez você possa obter uma ajuda melhor (considerando que você tem o mesmo problema que eu).

Edit: Eu tentei com um arquivo de manifesto, mas não o fiz funcionar, mas meu erro foi nomear apenas uma das classes ao criar o arquivo jar. Eu escrevi * .class e agora funciona.

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

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

1. ir para propriedades do seu projeto.
2. clique em Executar .
3. especifique a classe principal do seu projeto usando Browse .
4. crie e execute o arquivo Jar.