java - cvf - netbeans manifest main class




Não é possível executar o jar-file: "no main manifest attribute" (20)

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

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.


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'
    }
}

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>

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

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.


Eu pessoalmente acho que todas as respostas aqui estão entendendo mal a questão. A resposta para isso está na diferença de como o spring-boot constrói o .jar. Todo mundo sabe que o Spring Boot configura um manifesto como esse, que varia de todos os membros, assumindo 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 precise ser executado com org.springframework.boot.loader.JarLauncher no classpath?


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.

Eu tive o mesmo problema. Muitas das soluções mencionadas aqui não me deram a visão completa, então vou tentar dar um resumo de como empacotar arquivos jar a partir da linha de comando .

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

    Test.java

    package testpackage;
    
    public class Test
    {
        ...
    }
  2. Para compilar seu código com seus arquivos .class terminando com a estrutura dada pelo uso do nome do pacote:

    javac -d . Test.java

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

  3. Ao empacotar o arquivo .jar , você precisa instruir a rotina do jar em como compactá-lo. Aqui nós usamos a opção set cvfeP . Isto é para manter a estrutura do pacote (opção P ), especificar o ponto de entrada para que o arquivo de manifesto contenha informações significativas (opção e ). A opção f permite especificar o nome do arquivo, a opção c cria um arquivo e a opção v define a saída como detalhada. As coisas importantes a serem observadas aqui são P e e .

    Então vem o nome do jarro que queremos test.jar .

    Então vem o ponto de entrada.

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

    jar cvfeP test.jar testpackage.Test -C . testpackage/
  4. Verifique seu arquivo .jar 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, certifique-se de manter a nova linha no final, caso contrário, o java não a reconhecerá.

  5. Execute seu arquivo .jar com

    java -jar test.jar

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>

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


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


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


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'
        )
    }
}

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>

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


Tente este comando para incluir o jar:

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

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

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.


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




main