Impossible d'exécuter le fichier jar: «aucun attribut de manifeste principal»

J'ai installé une application, quand j'essaye de l'exécuter (c'est un pot exécutable), rien ne se passe. Lorsque je l'exécute à partir de la ligne de commande avec:

java -jar "app.jar"

J'obtiens le message suivant:

aucun attribut manifeste principal, dans "app.jar"

Normalement, si j'avais créé le programme moi-même, j'aurais ajouté un attribut de classe principale au fichier manifeste. Mais dans ce cas, puisque le fichier provient d'une application, je ne peux pas le faire. J'ai également essayé d'extraire le pot pour voir si je pouvais trouver la classe principale, mais il y en a de nombreuses classes et aucune d'entre elles n'a le mot "main" dans son nom. Il doit y avoir un moyen de résoudre ce problème car le programme fonctionne correctement sur d'autres systèmes.

Tout d'abord, c'est un peu bizarre de te voir courir java -jar "app"et nonjava -jar app.jar

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

le fichier lui-même doit avoir (au moins) cette doublure:

Main-Class: com.mypackage.MyClass

Où se com.mypackage.MyClasstrouve la classe contenant le point d'entrée principal public void statique ( arguments String []) .

Notez qu'il existe plusieurs façons de faire cela avec la CLI, Maven, Ant ou Gradle:

Pour CLI , la commande suivante fera l'affaire: (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 que ce n'est que la définition du plugin, pas le pom.xml complet :

<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 élément <version>approprié à votre projet.)

Pour Ant , l'extrait 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'
        )
    }
}

Cela aurait dû être java -jar app.jarau lieu de java -jar "app".

L' -jaroption 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 Main-Classattribut. Voir Empaquetage de programmes dans des fichiers JAR pour savoir comment créer un JAR exécutable.

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

java -cp app.jar com.somepackage.SomeClass

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

Vous pouvez également 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épendance spécifiés dans la section seront automatiquement inclus dans votre pot unique. Notez que jar-with-dependencies doit être mis littéralement en tant que, pour ne pas être remplacé par les noms de fichier jar que vous souhaitez inclure.

En effet, Java ne peut pas trouver l'attribut Main dans le fichier MANIFEST.MF. L'attribut Main est nécessaire pour indiquer à java quelle classe il doit utiliser comme point d'entrée de l'application. À l'intérieur du fichier jar, le fichier MANIFEST.MF se trouve dans le dossier META-INF. Vous vous demandez comment vous pourriez regarder ce qu'il y a dans un fichier jar? Ouvrez le fichier jar avec WinRAR.

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

Main-Class: <packagename>.<classname>

Vous obtenez cette erreur «aucun attribut manifeste principal» lorsque cette ligne est manquante dans le fichier MANIFEST.MF.

C'est vraiment un énorme gâchis de spécifier cet attribut dans le fichier MANIFEST.MF.

Mise à jour: je viens de trouver un moyen vraiment sympa de spécifier le point d'entrée de l'application dans eclipse. Quand vous dites Exporter,

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.

J'ai eu le même problème. en ajoutant les lignes suivantes au fichier pom l'a fait fonctionner. Le plugin assurera le 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>

La réponse Gradle consiste à ajouter un paramètre jar / manifest / attributes comme ceci:

apply plugin: 'java'

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

J'ai eu ce problème lors de la création d'un bocal à l'aide d'IntelliJ IDEA. Voir cette discussion .

Ce qui m'a résolu était de recréer l'artefact JAR, en choisissant JAR> From modules with dependencies, mais sans accepter le répertoire par défaut pour META-INF / MANIFEST.MF. Changez-le de - / src / main / java en - / src / main / resources.

Sinon, il incluait un fichier manifeste dans le bocal, mais pas celui dans - / src / main / java qu'il devrait avoir.

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

À votre santé...

Essayez cette commande pour inclure le pot:

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

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 se terminer par une nouvelle ligne ou un retour chariot. La dernière ligne ne sera pas analysée correctement si elle ne se termine pas par une nouvelle ligne ou un retour chariot.

( source ). L'ajout d'une nouvelle ligne à la fin du manifeste l'a corrigé.

Si vous utilisez Maven, incluez ce qui suit dans le 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 aujourd'hui. Mon problème a été résolu en déplaçant META-INF vers le dossier des ressources.

J'ai eu la même erreur tout à l'heure. Si vous utilisez gradle, ajoutez simplement le suivant dans votre ur gradle.build:

apply plugin: 'java'

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

Où com.company.project.MainClasschemin vers votre classe avec public static void main(String[] args)méthode.

Le problème MAVEN est qu'il essaie d'inclure le premier fichier MANIFEST.MF de la première bibliothèque des dépendances au lieu de NOTRE PROPRE MANIFEST.MF LORSQUE VOUS UTILISEZ DES ARTEFACTS! .

1. Renommez yourjar.jar en yourjar.zip
2. Ouvrez le fichier MANIFEST.MF à partir de META-INF \ MANIFEST.MF

3. Copiez le vrai MANIFEST.MF qui a déjà été généré dans votre projet par MAVEN.

   Manifest-Version: 1.0 Main-Class: yourpacket.yourmainclass (pour exmaple info.data.MainClass)

4. Remplacez le contenu de MANIFEST.MF de youjar.zip par celui-ci.

5. Renommez yourjar.zip en yourjar.jar en arrière.
6. Maintenant, java -jar yourjar.jar fonctionne parfaitement.

OU!

Créez simplement votre propre MANIFEST.MF et:

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

Mais si vous utilisez le panneau maven (ou la ligne de commande maven), vous pouvez le forcer à générer votre propre manifeste et à l'inclure dans le fichier JAR.

1. Ajoutez à la section de construction de you pom.xml ce code:

   <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. Ouvrez le panneau MAVEN (dans Intellij) et exécutez "Installer". Il va générer le fichier MANIFEST et compiler la propriété du fichier JAR avec toutes les dépendances dans le dossier "Target". Il sera également installé dans le référentiel maven local.

Si le bocal ne suit pas les règles , ce n'est pas un bocal exécutable.

J'ai rencontré le même problème et il est résolu maintenant :) Suivez simplement les étapes ci-dessous et l'erreur pourrait être pour n'importe quoi, mais les étapes ci-dessous rendent le processus plus fluide. Je passe beaucoup de temps à trouver la solution.

1.Essayez de redémarrer Eclipse (si vous utilisez Eclipse pour créer un fichier JAR) -> En fait, cela a aidé mon problème à exporter correctement le fichier JAR.

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 en tant que -> Exécuter les configurations -> Principal -> cliquer sur le bouton Rechercher pour voir si votre éclipse est capable de rechercher votre classe principale dans le fichier JAR. -> C'est pour la validation que le fichier JAR aura le point d'entrée vers la classe principale.

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

5. Dans la configuration de lancement Java, choisissez votre classe principale.

6. Une fois le fichier jar exporté, utilisez la commande ci-dessous pour exécuter. java -cp [Votre JAR] .jar [package complet] .MainClass par exemple: java -cp AppleTCRuleAudit.jar com.apple.tcruleaudit.classes.TCRuleAudit

7. Vous pourriez rencontrer l'erreur de version Java non prise en charge. le correctif consiste à changer le java_home dans votre profil bash shell pour correspondre à la version java utilisée pour compiler le projet dans eclipse.

J'espère que cela t'aides! Veuillez me faire savoir si vous avez encore des problèmes.

J'ai eu le même problème. Un grand nombre des solutions mentionnées ici ne m'ont pas donné une vue d'ensemble, donc je vais essayer de vous donner un résumé de la façon de compresser les fichiers jar à partir de la ligne de commande .

1. Si vous souhaitez avoir vos .classfichiers dans des packages, ajoutez le package au début de la .java.

   Test.java

   package testpackage;
   
   public class Test
   {
       ...
   }

2. Pour compiler votre code avec vos .classfichiers se terminant par la structure donnée par le nom du package, utilisez:

   javac -d . Test.java

   Le -d .fait que le compilateur crée la structure de répertoires souhaitée.

3. Lors de l'empaquetage du .jarfichier, vous devez indiquer à la routine jar comment l'emballer. Ici, nous utilisons l'ensemble d'options cvfeP. Il s'agit de conserver la structure du package (option P), de spécifier le point d'entrée afin que le fichier manifeste contienne des informations significatives (option e). L'option fvous permet de spécifier le nom du fichier, l'option ccrée une archive et l'option vdéfinit la sortie sur verbeuse. Les choses importantes à noter ici sont Pete .

   Vient ensuite le nom du pot que nous voulons test.jar .

   Vient ensuite le point d'entrée.

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

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

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

   test.jar

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

   Le MANIFEST.MF doit contenir les éléments suivants

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

   Si vous modifiez votre manifeste à la main, assurez-vous de conserver la nouvelle ligne à la fin, sinon java ne la reconnaît pas.

5. Exécutez votre .jarfichier avec

   java -jar test.jar

Personnellement, je pense que toutes les réponses ici comprennent mal la question. La réponse à cela réside dans la différence de la façon dont Spring-Boot construit le .jar. Tout le monde sait que Spring Boot met en place un manifeste comme celui-ci, qui varie de l' hypothèse de tout le monde qu'il s'agit d'un lancement standard .jar, qu'il peut ou non être:

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 qu'il doit être exécuté avec org.springframework.boot.loader.JarLaunchersur le chemin de classe?

Tout fichier jar exécutable doit s'exécuter en cliquant ou en exécutant à l'aide de l'invite de commande comme java -jar app.jar (utilisez "si le chemin du jar contient de l'espace" - c'est-à-dire java -jar "C: \ nom du dossier \ app.jar"). Si votre fichier exécutable n'est pas en cours d'exécution, cela signifie qu'il n'est pas créé correctement.

Pour une meilleure compréhension, extrayez le fichier jar (ou affichez-le à l'aide de n'importe quel outil, pour Windows 7-Zip, c'est bien) et vérifiez le fichier sous /META-INF/MANIFEST.MF. Si vous trouvez une entrée comme

Main-Class: your.package.name.ClaaswithMain - alors ça va, sinon vous devez le fournir.

Soyez conscient de l'ajout d'une entrée de classe principale sur le fichier MANIFEST.MF, vérifiez où vous l'enregistrez!

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, exécutez simplement comme ceci

 java -cp jarfile-name main-classname

Vous n'avez peut-être pas créé le fichier jar correctement:

ex: option m manquante dans la création du pot

Les oeuvres suivantes:

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

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

jar cfve app.jar TheNameOfClassWithMainMethod *.class

(le paramètre "e" fait cela: TheNameOfClassWithMainMethod est un nom de la classe avec la méthode main () et app.jar - nom de l'exécutable .jar et * .class - juste tous les fichiers de classes à assembler)

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. Donc, lorsque vous créez le fichier jar dans Eclipse, assurez-vous de cliquer sur le bouton radio droit

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

Étape 1: trouver la classe dont j'ai besoin pour exécuter

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

Les premières lignes du résultat sont les suivantes:

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

App.class contenait la classe principale à exécuter. Je ne suis pas sûr à 100% si vous pouvez toujours supposer que le cours dont vous avez besoin est le premier, 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 à la bibliothèque pour réduire la liste des classes à une taille gérable.

À partir de là, c'était facile: j'utilise simplement ce chemin (moins le suffixe ".class"):

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

Puisque vous avez ajouté MANIFEST.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 MANIFEST.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

Cependant, comme indiqué ci-dessous,

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

//this run swing normally

(premier message - donc il peut ne pas être propre)

Ceci 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 peaufinage (juste quelques échappements shell pour l'impossible!).

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

La meilleure réponse ici ( olivier-refalo ) semblait être le bon endroit pour commencer, mais n'a pas aidé.

En regardant d'autres projets qui ont fonctionné, j'ai remarqué quelques différences mineures dans les lignes de manifeste:

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

Je ne sais pas pourquoi (je ne suis que 3 mois en java) ou comment, mais je peux seulement dire que cela a fonctionné.

Voici juste le bloc manifeste modifié utilisé:

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

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

1. Ouvrez 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 ajoutez la ligne suivante:

       • Version manifeste: 1.0
       • Classe principale: package.ex.com.views.mainClassName

     • Enregistrez le fichier et ajoutez-le au zip

   • Éditer:

     • Faites glisser le fichier hors modifiez le MANIFEST.MF pour ajouter la ligne précédente

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

Cela devrait bien fonctionner maintenant!

la plupart des solutions n'ont pas fonctionné pour moi mais mon instructeur m'a aidé je voudrais partager sa solution ici j'ai utilisé le terminal kali linux mais ça devrait aller dans tous les debian

javac *.java
nano MANIFEST.MF

dans le type de fichier

Main-Class: Main ou quel que soit le nom de votre fichier principal (assurez-vous d'ajouter le nom du package s'il existe)

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

maintenant pour exécuter l'utilisation du fichier

java -jar new.jar

ou vous pouvez aller aux propriétés du dossier et vérifier

Autoriser l'exécution du fichier en tant que programme

double-cliquez dessus

cela m'a aidé alors que la plupart des réponses ci-dessus ne l'ont pas

Vous pourriez avoir le même problème que moi. Après avoir créé votre fichier .jar, écrivez jar xf app.jar META-INF/MANIFEST.MF. Cela créera une copie du fichier dans votre répertoire actuel afin que vous puissiez le lire. Si cela ne dit que quelque chose comme:

Version manifeste: 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.

Mais je ne sais pas comment le résoudre. J'ai vérifié d'autres personnes ayant des problèmes identiques / similaires sur StackOverflow et je n'ai pas trouvé de réponse. Cependant, avec ces informations, 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 était de ne nommer qu'une des classes lors de la création du fichier jar. J'ai plutôt écrit * .class et cela fonctionne maintenant.

Bien que je ne sache pas pourquoi il est nécessaire de créer un fichier manifeste. Mais je suppose que ça va tant que ça marche.

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

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