java - update - no main manifest attribute spring boot




Impossible d'exécuter le fichier jar: "aucun attribut de manifeste principal" (20)

(premier message - donc ce n'est peut-être pas 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 peaufinage (juste quelques coquilles échappent à l'impossible!).

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

La meilleure réponse ici ( ) 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 manifestes:

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

Je ne sais pas pourquoi (je suis seulement 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 installé une application, quand j'essaye de l'exécuter (c'est un pot exécutable) rien ne se passe. Quand je l'exécute depuis la ligne de commande avec:

java -jar "app.jar"

Je reçois le message suivant:

aucun attribut de 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 aussi essayé d'extraire le pot pour voir si je pouvais trouver la classe principale, mais il y a beaucoup de classes et aucune 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.


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 fichiers jar dépendants spécifiés dans la section seront automatiquement inclus dans votre fichier jar. Notez que jar-with-dependencies doit être mis littéralement comme, ne pas être remplacé par les noms de fichiers jar que vous souhaitez inclure.


Cela 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 apprendre à créer un fichier JAR exécutable.

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

java -cp app.jar com.somepackage.SomeClass

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


Essayez cette commande pour inclure le fichier jar:

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

J'ai eu ce problème lors de la création d'un pot en utilisant IntelliJ IDEA. Voir cette discussion .

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

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


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

apply plugin: 'java'

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

com.company.project.MainClass chemin d'accès à votre classe avec public static void main(String[] args) méthode public static void main(String[] args) .


J'ai eu le même problème. Beaucoup de solutions mentionnées ici ne m'ont pas donné une image complète, alors je vais essayer de vous donner un résumé de la façon de compresser les fichiers jar depuis la ligne de commande .

  1. Si vous voulez avoir vos fichiers .class dans des 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 terminant par la structure donnée par le nom du paquet, utilisez:

    javac -d . Test.java
    

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

  3. Lors de l'empaquetage du fichier .jar , vous devez indiquer à la routine jar comment l'emballer. Ici, nous utilisons l'option set cvfeP . C'est pour conserver la structure du paquet (option P ), spécifiez le point d'entrée pour que le fichier 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 sur verbose. Les choses importantes à noter ici sont P et e .

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

    Puis vient le point d'entrée.

    Et puis vient -C . <packagename>/ -C . <packagename>/ pour 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érifiez votre fichier .jar 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 éditez votre manifeste à la main, assurez-vous de garder le saut de ligne à la fin sinon java ne le reconnaîtra pas.

  5. Exécutez votre fichier .jar avec

    java -jar test.jar
    

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

Les réponses ci-dessus n'ont été que partiellement utiles pour moi. 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 dont j'ai besoin pour courir

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

Les premières lignes du résultat étaient:

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 la classe dont vous avez besoin est la première, mais c'était pour moi. Si ce n'est pas le cas, j'imagine que ce n'est pas trop difficile d'utiliser grep pour exclure les résultats liés aux bibliothèques afin de réduire la liste des classes à une taille gérable.

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

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

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


Pour moi, aucune des réponses n'a vraiment aidé - j'avais le fichier manifeste à la bonne place, contenant la classe principale et tout le reste. Ce qui m'a fait trébucher était ceci:

Attention: 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'un saut de ligne à la fin du manifeste le corrige.


Puisque vous avez ajouté MANIFEST.MF, je pense que vous devriez considérer l'ordre de Field dans ce fichier. Mon env est la 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, ceci comme ci-dessous traverse

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

//this run swing normally

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


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

jar cfve app.jar TheNameOfClassWithMainMethod *.class

(param "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)


Tout d'abord, c'est java -jar app.jar bizarre de vous voir lancer java -jar "app" et non java -jar app.jar

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

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

Main-Class: com.mypackage.MyClass

com.mypackage.MyClass est la classe contenant le point d'entrée public public void main (String [] args) .

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

Pour CLI , la commande suivante fera: (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 ceci est seulement la définition du plugin, pas le fichier 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 une <version> appropriée à votre projet.)

Pour Ant , l'extrait ci-dessous devrait 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 -


Vérifiez votre répertoire local .m2 pour un sous-répertoire de cet artefact. Si exixts - le supprimer, et effectuer une mise à jour Maven à nouveau


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

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

Les travaux suivants:

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

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

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

Tout en exécutant le fichier jar simple, exécutez comme ceci

 java -cp jarfile-name main-classname

vérifiez votre fichier jar à l'intérieur MANIFEST.MF Main-Class est disponible ou non

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

[email protected]:~/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

[email protected]:~/Documents$ java -jar first.jar 
Welcome to the world of Java




main