Ne peut pas exécuter jar-file: "pas d'attribut principal de manifeste"

D'abord, c'est un peu bizarre, de vous voir courir java -jar "app" et non java -jar app.jar

Deuxièmement, pour rendre un jar exécutable... vous devez ouvrir un fichier appelé META-INF/MANIFEST.MF

le fichier lui-même devrait avoir (au moins) ce liner:

Main-Class: com.mypackage.MyClass

où com.mypackage.MyClass est la classe qui détient le public static void main(String[] args) entry point.

noter que il y a plusieurs façons de le faire avec le CLI, le Maven, la fourmi ou le Grad:

Pour CLI , la commande suivante va faire: (tks @ dvvrt ) jar cmvf META-INF/MANIFEST.MF <new-jar-filename>.jar <files to include>

pour Maven , quelque chose comme l'extrait suivant devrait faire l'affaire. Notez qu'il ne s'agit que de la définition du plugin, pas de la pleine pom.xml :

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

(Choisissez un <version> approprié à votre projet.)

Pour Ant , l'extrait de code ci-dessous devrait vous aider:

<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édits Michael Niemand -

Pour Gradle :

plugins {
    id 'java'
}

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

qui aurait dû être java -jar app.jar au lieu de java -jar "app" .

l'option -jar ne fonctionne que si le fichier JAR est un fichier JAR exécutable, ce qui signifie qu'il doit contenir un fichier manifeste avec un attribut Main-Class . Voir programmes D'empaquetage dans les fichiers JAR pour savoir comment créer un JAR exécutable.

si ce n'est pas un JAR exécutable, alors vous devrez exécuter le programme avec quelque chose comme:

java -cp app.jar com.somepackage.SomeClass

où com.somepackage.SomeClass est la classe qui contient la méthode main pour exécuter le programme. (Ce que cette classe est dépend du programme, il est impossible de dire à partir des informations que vous avez fournies).

alternativement, vous pouvez utiliser maven-assembly-plugin, comme indiqué dans l'exemple ci-dessous:

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

dans cet exemple, tous les pots de dépendances spécifiés dans la section seront automatiquement inclus dans votre pot unique. Notez que jar-with-dependencies doit être littéralement mis sous, sans être remplacé par les noms de fichiers jar que vous voulez inclure.

c'est parce que Java ne peut pas trouver l'attribut principal dans le manifeste.Fichier MF. L'attribut principal est nécessaire pour indiquer à java quelle classe il doit utiliser comme point d'entrée de l'application. Dans le fichier jar, le manifeste.Le fichier MF est situé dans le dossier META-INF. Vous vous demandez comment vous pouvez regarder ce qu'il y a à l'intérieur d'un fichier jar? Ouvrez le fichier jar avec WinRAR.

l'attribut principal à l'intérieur du Manifeste.MF ressemble à ceci:

Main-Class: <packagename>.<classname>

Vous obtenez ce erreur "aucun attribut principal du manifeste" lorsque cette ligne est manquante dans le manifeste.Fichier MF.

c'est vraiment un énorme gâchis de spécifier cet attribut dans le manifeste.Fichier MF.

mise à jour: je viens de trouver une façon très soignée de spécifier le point d'entrée de L'Application dans eclipse. Quand vous dites exportation,

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.

la réponse de Gradle est d'ajouter un paramètre jar/manifest/attributes comme ceci:

apply plugin: 'java'

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

Essayez cette commande pour inclure le pot:

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

pour maven, c'est ce qui l'a résolu (pour moi, pour une base de données Veetle sur 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>

santé...

j'ai eu ce problème en créant un pot en utilisant IntelliJ idée. Voir cette discussion .

ce qui l'a résolu pour moi était de recréer l'artefact jar, En choisissant JAR > à partir de modules avec des dépendances, mais en n'acceptant pas le répertoire par défaut pour META-INF/MANIFEST.MF. Variation de -/src/main/java -/src/main/resources.

sinon c'était un fichier de manifeste dans le bocal, mais pas celui dans -/src / main / java qu'il devrait avoir.

pour moi, aucune des réponses n'a vraiment aidé - j'avais le fichier manifeste au bon endroit, contenant la classe principale et tout. Ce qui m'a fait trébucher, c'est ceci:

avertissement: le fichier texte à partir duquel vous créez le manifeste doit terminez par un retour de ligne ou de chariot. La dernière ligne ne sera pas correctement analysé si elle ne se termine pas par une nouvelle ligne ou retour chariot.

( source ). L'ajout d'une nouvelle ligne à la fin du manifeste fixe.

j'ai eu la même erreur. Si vous utilisez gradle , vous n'avez qu'à ajouter le suivant dans ur gradle.build :

apply plugin: 'java'

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

où com.company.project.MainClass chemin vers la classe ur avec la méthode public static void main(String[] args) .

si vous utilisez Maven, incluez ce qui suit dans la 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>

j'ai eu le même problème. en ajoutant les lignes suivantes au fichier pom, il a fonctionné. Le plugin s'assurera du processus de construction de votre application avec toutes les étapes nécessaires.

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

si le jar ne suit pas les règles , ce n'est pas un JAR exécutable.

j'ai eu le même problème aujourd'hui. Mon problème a été résolu en déplaçant META-INF dans le dossier Ressources.

j'ai fait face au même problème et il est réparé maintenant:) Il suffit de suivre les étapes ci-dessous et l'erreur pourrait être pour n'importe quoi, mais les étapes ci-dessous rend le processus plus facile. Je passe beaucoup de temps à trouver le correctif.

1.Essayez de redémarrer L'Eclipse (si vous utilisez Eclipse pour construire le fichier JAR) -- >En fait cela a aidé mon problème en exportant le fichier JAR correctement.

2.Après le redémarrage de l'éclipse, essayez de voir si votre éclipse est capable de reconnaître la classe/méthode principale par votre projet Java -- > clic droit -- > exécuter comme -- > exécuter des configurations -- > Main -- > cliquer sur le bouton de recherche pour voir si votre éclipse est capable de rechercher votre classe principale dans le fichier JAR. --> Ceci est pour la validation que le fichier JAR aura le point d'entrée de la classe principale.

4. après cela, exportez votre projet Java Dynamic en tant que fichier" JAR exécutable " et non en tant que fichier JAR.

5. en configuration de lancement Java, choisissez votre classe principale.

6. une fois le fichier JAR exporté, utilisez la commande ci-dessous pour l'exécuter. java-cp [votre pot].pot [emballage complet].MainClass par exemple: java-cp AppleTCRuleAudit.jar com.Apple.tcruleaudit.classe.TCRuleAudit

7. vous pourriez faire face à l'erreur de version java non supportée. le correctif est de modifier le java_home de votre profil Bash shell pour qu'il corresponde à la version java utilisée pour compiler le projet dans eclipse.

Espérons que cette aide! Veuillez me faire savoir si vous avez encore des questions.

tout fichier JAR exécutable doit s'exécuter soit en cliquant soit en tournant avec l'invite de commande java-jar app.jar (utiliser " si le chemin du jar contient de l'espace "- i.e. java-jar") C:\folder nom\app.pot.)" Si votre exécutable jar ne tourne pas, ce qui signifie qu'il n'est pas créé correctement.

pour une meilleure compréhension, extraire le fichier jar (ou le visualiser à l'aide de n'importe quel outil, pour windows 7-Zip est agréable) et vérifier le fichier sous /META-INF/MANIFEST.MF. Si vous trouvez une entrée comme

Main-Class: your.paquet.nom.ClaaswithMain-alors c'est bon, sinon vous devez le fournir.

veuillez noter l'ajout de l'entrée principale sur le manifeste.Fichier MF, vérifiez où vous le Sauvegardez!

vous pouvez simplement suivre cette étape Créer un fichier jar en utilisant

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

lors de l'exécution du fichier jar simple exécuter comme ceci

 java -cp jarfile-name main-classname

vous pourriez ne pas avoir créé le fichier jar correctement:

ex: option manquante m dans la création de pots

les œuvres suivantes:

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

pour moi cette erreur s'est produite simplement parce que j'ai oublié de dire à Eclipse que je voulais un fichier JAR exécutable et non un simple fichier JAR de bibliothèque. Ainsi, lorsque vous créez le fichier jar dans Eclipse, assurez-vous que vous cliquez sur le bouton radio

j'ai eu le même problème. Beaucoup des solutions mentionnées ici ne m'ont pas donné toute l'image, donc je vais essayer de vous donner un résumé de la façon de pack jar fichiers à partir de la ligne de commande .

1. si vous voulez avoir vos fichiers .class dans les paquets, ajoutez le paquet au début du .java .

   Test.java

   package testpackage;
   
   public class Test
   {
       ...
   }
   

2. pour compiler votre code avec vos fichiers .class se terminant par la structure indiquée par le nom du paquet, utilisez:

   javac -d . Test.java
   

   le -d . permet au compilateur de créer la structure de répertoire que vous voulez.

3. lorsque vous emballez le fichier .jar , vous devez donner des instructions sur la façon de l'emballer. Ici, nous utilisons l'option cvfeP . C'est pour conserver la structure du paquet (option P ), spécifier le point d'entrée de sorte que le fichier du Manifeste contienne des informations significatives (option e ). L'Option f vous permet de spécifier le nom du fichier, l'option c crée une archive et l'option v définit la sortie à verbose. Les choses importantes à noter ici sont P et e .

   vient alors le nom du pot que nous voulons test.jar .

   vient ensuite le point d'entrée .

   et puis vient -C . <packagename>/ pour récupérer les fichiers de classe à partir de ce dossier, en préservant la structure du dossier.

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

4. Vérifiez votre fichier .jar dans un programme zip. Il devrait avoir la structure suivante

   .jar

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

   le manifeste.MF devrait

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

   si vous éditez votre manifeste à la main assurez-vous de garder la ligne à la fin sinon java ne le reconnaît pas.

5. exécutez votre .jar fichier avec

   java -jar test.jar
   

puisque vous avez ajouté le manifeste.MF, je pense que vous devriez considérer l'ordre des champs dans ce fichier. Mon env est java version "1.8.0_91"

et mon manifeste.MF comme ici

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

Toutefois, la présente comme ci-dessous courir à travers

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

//this run swing normally

(premier post de sorte qu'il peut ne pas être propre)

c'est mon correctif pour OS X 11.6, programme Netbeans 8.2 basé sur Maven. Jusqu'à présent, mon application est 100% Netbeans - pas de réglages (juste un peu d'échappements vers l'impossible!).

ayant essayé la plupart des réponses ici et ailleurs en vain, je suis retourné à l'art de "utiliser ce qui fonctionne".

la première réponse ici ( olivier-refalo thanx) ressemblait à la droite endroit pour commencer, mais ne l'a pas aidé.

en regardant d'autres projets qui ont fonctionné, j'ai remarqué quelques différences mineures dans les lignes du Manifeste:

1. addClasspath, classpathPrefix étaient absents (supprimés)
2. mainClass manquait le com."(utilisé le projet NB - > Propriétés->Exécuter->Classe Principale->Parcourir pour spécifier)

Je ne sais pas pourquoi (je suis seulement 3 mois en java) ou comment, mais ne peut que disons que ça a marché.

Voici juste le bloc de manifeste modifié utilisé:

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

je pense personnellement que toutes les réponses ici sont erronées-comprendre la question. La réponse à cette question réside dans la différence de la façon dont spring-boot construit le .pot. Tout le monde sait que la botte de printemps met en place un manifeste comme celui-ci, qui varie de tout le monde asssumption qu'il s'agit d'un standard .jar launch, qu'elle soit ou non:

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

peut-être doit-il être exécuté avec org.springframework.boot.loader.JarLauncher sur le chemin de classe?

j'ai trouvé une nouvelle solution à la mauvaise génération de manifestes !

1. ouvrir le fichier jar avec un éditeur zip comme WinRAR

2. cliquez sur pour META-INF

3. ajouter ou modifier

   • ajouter:

     • créez un fichier texte appelé MANIFEST.MF dans un dossier appelé META-INF et ajouter le ligne suivante:

       • Manifeste-Version: 1.0
       • classe principale: colis.ex.com.vues.mainClassName

     • Enregistrer le fichier et l'ajouter à l'archive

   • Edit:

     • faites glisser le fichier pour modifier le manifeste.MF pour ajouter la ligne précédente

4. Ouvrir cmd et tapez: java -jar c:/path/JarName.jar

Il devrait fonctionner correctement maintenant !

les réponses ci-dessus ne m'ont été que partiellement utiles. java -cp faisait partie de la réponse, mais j'avais besoin d'informations plus spécifiques sur la façon d'identifier la classe à exécuter. Voici ce qui a fonctionné pour moi:

Étape 1: trouver la classe que je dois exécuter

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

Les premières lignes de la suite ont été:

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

App.la classe contenait la classe principale à exécuter. Je ne suis pas sûr à 100% Si vous pouvez toujours supposer que la classe dont vous avez besoin est le première, mais c'était pour moi. Si ce n'est pas le cas, j'imagine qu'il n'est pas trop difficile d'utiliser grep pour exclure les résultats liés aux bibliothèques pour réduire la liste des classes à une taille gérable.

de là, c'était facile: j'utilise juste ce chemin (moins le".la classe" suffixe):

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

j'ai eu ce problème et je l'ai résolu récemment en le faisant dans Netbeans 8 (se référer à l'image ci-dessous):

1. aller à propriétés de votre projet.
2. cliquez sur Exécuter .
3. spécifier la classe principale de votre projet en utilisant parcourir .
4. construire et exécute le fichier Jar.

vous pourriez avoir le même problème que moi. Après la création de votre .jar file, écrivez jar xf app.jar META-INF/MANIFEST.MF . Cela créera une copie du fichier dans votre répertoire courant pour que vous puissiez le lire. Si elle dit seulement quelque chose comme:

Manifeste-Version: 1.0

Créé Par: 1.8.0_51 (Oracle Corporation)

et ne contient pas la déclaration" Main-Class", alors je pense que vous avez trouvé votre problème.

je ne sais pas comment le résoudre, si. J'ai vérifié d'autres personnes ayant des problèmes identiques ou similaires sur StackOverflow et je n'ai pas trouvé de réponse. Cependant, avec cette information, vous pouvez peut-être obtenir une meilleure aide (étant donné que vous avez le même problème que moi).

Edit: j'avais essayé avec un fichier-manifeste mais je ne l'ai pas fait fonctionner, mais mon erreur a été de ne nommer qu'une des classes lors de la création du fichier-jar. J'ai écrit *.classe à la place et il fonctionne maintenant.

bien que je ne sache pas pourquoi il est nécessaire de créer un fichier-manifeste. Mais je suppose que c'est bon tant que ça marche.

Si vous utilisez la ligne de commande à assembler .jar il est possible de pointer vers le fichier principal sans ajouter le fichier Manifest. Exemple:

jar cfve app.jar TheNameOfClassWithMainMethod *.class

(param" e " does that: TheNameOfClassWithMainMethod est un nom de la classe avec la méthode main () et app.jar - nom de l'exécutable .jar et *.classe - seulement toutes les catégories de fichiers à assembler)

vérifiez votre fichier jar dans le manifeste.MF Principal de la Classe est disponible ou pas

d'abord.java

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

avant :

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

sony@sony-VPCEH25EN:~/Documents$ java -jar first.jar
no main manifest attribute, in first.jar

après:

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

sony@sony-VPCEH25EN:~/Documents$ java -jar first.jar 
Welcome to the world of Java

, en dessous d'une syntaxe pour créer avec succès .dossier de guerre: -

jar {cvf} [jar-file] [manifeste-fichier]

manifeste Lors de la création (c) ou de la mise à jour (u) d'un fichier JAR, l'opérande manifest définit les fichiers de manifestes préexistants avec les noms et les valeurs des attributs à inclure dans le manifeste.MF dans le fichier JAR. Le manifeste de l'opérande doit être spécifié si l'option f est présente '[ 1 ]'.

afin de créer un fichier manifeste vous avez besoin de définir une valeur pour certains attributs, vous pouvez mettre un astérisque après le (.WAR) nom du fichier pour éviter de créer un manifeste fichier: -

jar-cvf foo.guerre *

Pour être honnête avec vous, je ne sais pas si c'est une meilleure pratique, mais il faire le travail pour moi :).