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

971

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.

Ewoud
fonte
Procure os principais métodos; você não pode confiar nos nomes das classes.
21412 Dave
2
Eu sei, mas como só tenho arquivos .class, não consigo ver os métodos. Ou posso?
Ewoud
Você não está realmente digitando as aspas, está? De qualquer forma, existem várias maneiras de ver métodos, incluindo o uso javap. Você pode descompactá-lo e verificar se realmente não há manifesto.
Dave Newton
Relacionado: com dependências: stackoverflow.com/a/23986765/360211
weston
E se eu não tenho classe principal como eu estou executando o código usando CommandLineJobRunner
Kamini

Respostas:

946

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'
        )
    }
}
Olivier Refalo
fonte
15
Em Formiga sua <manifest> <nome do atributo = valor "Main-Class" = "com.mypackage.MyClass" /> </ manifest> dentro do <jar> elemento
Michael Niemand
1
Obrigado. Só queria adicionar que você pode copiar dependências para a pasta lib usando este: stackoverflow.com/a/996915/1121497 . Como o caminho de classe inclui essa libpasta, você só precisa executar o jar com java -jar myproject.jare ele encontrará as dependências.
Ferran Maylinch
4
COMO "jar um arquivo chamado META-INF / MANIFEST.MF"? Eu tenho um .jar, por um lado, e um .MF, por outro, como vinculá-los? Coloquei o manifesto na mesma pasta que o .jar, mas não funciona, ainda tenho o problema!
Wicelo
4
@Wicelo Para especificar um arquivo MANIFEST.MF específico ao criar um arquivo jar, use o sinalizador m para jar. por exemplo. jar cmvf META-INF/MANIFEST.MF <new-jar-filename>.jar <files to include>
dvvrt
1
Nota: Para o Maven, eu já tinha um maven-jar-pluginitem no arquivo Maven gerado pelo VSC, então acabei de adicionar a <configuration>seção a ele.
Aaron Franke
279

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

Jesper
fonte
3
obrigado pela resposta, mas sua solução só funcionará se eu souber o nome da classe que contém o método principal. E foi um erro de digitação ... Era para ser "app.jar". Mas como você explica por que ele é executado em outros sistemas clicando duas vezes no arquivo?
Ewoud
Se é realmente um JAR executável, você pode extrair o arquivo de manifesto (está no META-INFdiretório dentro do arquivo JAR). Ele deve conter um Main-Classatributo que fornece o nome da classe principal.
Jesper
Se ele não for executado em um sistema, talvez esse sistema tenha uma versão Java muito antiga. Se, por exemplo, o JAR for compilado com o Java 7, não será possível executá-lo em um sistema que possua o Java 6 ou mais antigo.
Jesper
Isso é engraçado, já que o outro sistema está executando o win7 e este pc com os problemas roda win8.
Ewoud
2
@ Jesper Olá, e se o eclipse estiver usando o pacote padrão? Acabei de colocar o nome da turma?
Ogen
127

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.

CodeBrew
fonte
3
Perfeito, isso funciona. Ele agrupa todas as dependências em um jar, permitindo que você compile / construa um projeto e execute-o imediatamente.
Paul Paul
2
No contexto do plugin de sombra , é necessário seguir a ajuda do Executable JAR .
Koppor # 6/17
3
Isso maven-assembly-pluginfuncionou. maven-jar-pluginnao fiz.
Martynas Jusevičius
Nota: insira esse código em seu pom.xmlarquivo <build><plugins> PUT IT HERE </plugins></build>e execute o maven Package (no menu aberto do IDEA open maven deslizante à direita, procure projeto> Lifecycle> package). Em seguida, seu arquivo jar estará na pasta Target. Felicidades!
precisa
Eu estava realmente lutando com esse problema ... Isso funciona perfeitamente. Obrigado!
jmojico
60

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.

insira a descrição da imagem aqui

Sasanka Panguluri
fonte
32

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>
Naga Srinu Kapusetti
fonte
2
funcionou perfeitamente, mas considere adicionar a versão a partir de abril de 2018 <plugin> <groupId> org.springframework.boot </groupId> <artifactId> spring-boot-maven-plugin </artifactId> <version> 2.0.1.RELEASE < / version> </plugin>
Tenflex 16/04
Desculpe, mas não é uma solução, porque ele não está falando sobre Spring Bota, é problema geral com a execução jar :)
Lamrim TAWSRAS
Muito obrigado, isso resolveu o problema da bota de mola!
AleksandarT
Estou trabalhando na inicialização da Primavera 2.2.0.Release. Infelizmente, esta solução não funcionou para mim. No entanto, ele funciona quando você se refere a um <parent>...</parent>aplicativo no pom.xml. Meu palpite é que, se visitarmos o parentpom.xml do aplicativo, teremos uma ideia clara.
tusar 6/02
Finalmente resolvi meu problema com o costume repackage-classifier. Visite docs.spring.io/spring-boot/docs/2.2.0.RELEASE/maven-plugin/…
tusar
30

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'
    }
}
QED
fonte
1
a resposta mais simples até agora.
precisa saber é o seguinte
29

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.

estrela da Manhã
fonte
Isso funcionou para mim com o IDEA 14.1.6. Também adicionei a propriedade build para pom.xml, mas ela não teve efeito. Mas sua resposta resolveu, obrigado.
Lsrom
3
Obrigado por evitar que minha área de trabalho seja prejudicada pela pura frustração de mais nada funcionar;) Seu link parece quebrado, mas posso confirmar que isso funciona perfeitamente. Testado com o IntelliJ IDEA 2018.2.5 (Community Edition)
Matthias Bö
confirmou que isso funciona, mesmo que eu não tenha um diretório / resources #
lxknvlk #
28

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

Dave
fonte
Achei isso funcionado, mas tive que executar, pois mvn package shade:shadeapenas a execução mvn packagenão acionava o plug-in de sombra.
Raystorm
24

Tente este comando para incluir o jar:

java -cp yourJarName.jar your.package..your.MainClass
Burhan ARAS
fonte
1
Uma maneira é incluir a classe principal no pom.xml e usar o comando java -jar, outra é usar o comando java -cp.
Gaurav Khare
15

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.

eis
fonte
11

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>
shuang
fonte
3
Quem disse que este era um projeto do Spring Boot?
James.garriss 12/09/19
2
@ james.garriss bem, eu diria, eu vim para este post procurando por no main manifest attributeerro, mas estou trabalhando no aplicativo de inicialização da primavera, então essa resposta me ajudou. Eu já sabia como criar META-INF/MANIFEST.MFarquivo, mas não como fazer o boot por mola lida automaticamente com ele.
Vishrant
5
Não vejo motivo para votar esta resposta. Se você não estiver usando, spring-bootignore-o. O Stackoverflow também ajuda a criar seu próprio repositório de problemas que você enfrenta durante a programação.
Vishrant
@ Vishrant Eu não sei sobre os outros, mas diminuí a votação porque esta resposta não aborda a questão como foi colocada. Pode ter acontecido apenas para responder à sua pergunta, mas sua pergunta não foi exatamente o que foi perguntado.
Bane
@Bane sure. mas a pergunta pode ser feita em sentido amplo e esta resposta se aplica a ela e pode ajudar outras pessoas no sentido em que usarão a bota de mola.
Vishrant
10

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

MTA
fonte
Isso funcionou para mim também. Tentar se você estiver usando JetBrains IntelliJ
NickSoft
Obrigado que realmente funcionou para mim :)
Syed Mehtab Hassan
Isso funcionou para mim também no intellij. Obrigado cara.
Waqas
10

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

Binakot
fonte
Isso me ajudou! tutoriais Gradle tinha especificado usando o alto nível mainClassNameconjunto de variáveis, mas isso só ajuda com gradle runcomando, não com a criação de um .jar executável
kevlarr
8

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.

Yury Finchenko
fonte
5

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.

  1. Depois disso, exporte seu projeto Java Dynamic como arquivo "JAR executável" e não como 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 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.

KarthikPon
fonte
5

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
CodeMonkey
fonte
1
O quarto passo da sua resposta é muito importante! Meu manifesto não estava funcionando por causa dessa nova linha no final que eu não sabia que tinha que colocar. Todas as respostas que visitei sobre esse tópico (muito) não mencionaram isso e é obrigatório para quem não usa maven, form, gradle etc.
Maude
1
@Maude obrigado pelo feedback. Foi exatamente por isso que adicionei a resposta com a dica de nova linha em negrito . Procurei dias até descobrir isso comparando com um manifesto gerado automaticamente.
CodeMonkey 22/08/18
Hah, obrigada. Eu estava apenas batendo minha cabeça nessa coisa de nova linha.
Richard Thomas
5

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?

djangofan
fonte
Isso parece promissor. Como exatamente você adiciona o JarLauncher ao caminho de classe?
21418 MarkHu
4

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!

Shekh Akther
fonte
4

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
Koneri
fonte
4

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
satheesh.v
fonte
4

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)

Andrey
fonte
3

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

Neeraj Bhatnagar
fonte
3

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
mwag
fonte
Nem sempre é a primeira aula. Quase nunca. Linha de comando deve ser java -cp ... somepackage.App.
Marquês de Lorne
2

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
Fan Yer
fonte
Eh? A ordem é imaterial. Não está claro o que você está reivindicando.
Marquês de Lorne
2

(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>
MichaelT
fonte
2

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!

Dave Beauchesne
fonte
2

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


fonte
1

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.

Gendarme
fonte
1

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

Propriedades do projeto Netbeans

  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.
Abdelsalam Shahlol
fonte