Comment corriger l'erreur 'no main manifest attribute' en Java

JavaBeginner
Pratiquer maintenant

Introduction

Lors de l'empaquetage et de l'exécution d'applications Java en tant que fichiers JAR (Java Archive), les développeurs rencontrent souvent l'erreur « no main manifest attribute ». Cette erreur se produit lors de la tentative d'exécution d'un fichier JAR, mais la Machine Virtuelle Java (JVM) ne peut pas déterminer quelle classe contient la méthode main pour démarrer l'application.

Ce lab vous guide à travers la compréhension, le diagnostic et la résolution de cette erreur courante. À la fin de ce tutoriel, vous saurez comment configurer correctement les fichiers JAR avec des fichiers manifestes qui spécifient correctement la classe principale.

Création d'une application Java simple

Commençons par créer une application Java simple que nous empaqueterons dans un fichier JAR. Cela nous aidera à démontrer et, plus tard, à corriger l'erreur « no main manifest attribute ».

Créer la classe Java

Tout d'abord, créez un répertoire pour nos fichiers sources Java et naviguez-y :

cd ~/project/src/com/example

Maintenant, ouvrez l'éditeur et créez un nouveau fichier nommé HelloWorld.java dans ce répertoire :

  1. Cliquez sur l'icône "Explorer" dans la barre latérale gauche de l'IDE Web
  2. Naviguez vers /home/labex/project/src/com/example
  3. Faites un clic droit et sélectionnez "Nouveau fichier"
  4. Nommez le fichier HelloWorld.java

Ajoutez le code suivant au fichier HelloWorld.java :

package com.example;

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Il s'agit d'un programme Java de base avec une méthode main qui affichera "Hello, World!" dans la console lors de l'exécution.

Compiler la classe Java

Maintenant, compilons notre classe Java. Retournez au terminal et naviguez vers le répertoire racine du projet :

cd ~/project

Compilez le fichier Java en utilisant la commande javac :

javac -d . src/com/example/HelloWorld.java

Cette commande compile le fichier source Java et place le fichier de classe compilé dans la structure de répertoire appropriée en fonction du nom du package.

Vous devriez maintenant avoir un fichier de classe compilé à ~/project/com/example/HelloWorld.class. Vous pouvez le vérifier avec :

ls -l com/example/

La sortie devrait afficher le fichier HelloWorld.class :

total 4
-rw-r--r-- 1 labex labex 426 [date] HelloWorld.class

Créer un fichier JAR de base sans manifeste

Maintenant, créons un fichier JAR sans spécifier de classe principale dans le manifeste. Cela nous permettra de reproduire l'erreur « no main manifest attribute » :

jar cf HelloWorld.jar com/

Cette commande crée un fichier JAR nommé HelloWorld.jar qui inclut le fichier de classe compilé.

Essayer d'exécuter le fichier JAR

Maintenant que nous avons créé notre fichier JAR, essayons de l'exécuter :

java -jar HelloWorld.jar

Vous verrez le message d'erreur :

no main manifest attribute, in HelloWorld.jar

C'est l'erreur que nous apprenons à corriger. La JVM ne peut pas trouver la classe principale à exécuter car nous ne l'avons pas spécifiée dans le manifeste du JAR.

Comprendre l'erreur « no main manifest attribute »

Dans cette étape, nous allons explorer la cause de l'erreur « no main manifest attribute » et comprendre comment fonctionne le fichier manifeste du fichier JAR.

Qu'est-ce que le fichier manifeste ?

Un fichier JAR contient un fichier spécial appelé MANIFEST.MF dans le répertoire META-INF. Ce fichier manifeste contient des métadonnées sur le JAR et son contenu. Une information importante que le manifeste peut contenir est l'attribut Main-Class, qui indique à la JVM quelle classe contient la méthode main à exécuter lors de l'exécution du JAR.

Examinons le manifeste actuel dans notre fichier JAR :

mkdir -p temp_dir
cd temp_dir
jar xf ../HelloWorld.jar META-INF/MANIFEST.MF
cat META-INF/MANIFEST.MF

Vous verrez un manifeste minimal qui ressemble à ceci :

Manifest-Version: 1.0
Created-By: 1.8.0_XXX (Oracle Corporation)

Notez qu'il n'y a pas d'attribut Main-Class dans ce manifeste, c'est pourquoi nous obtenons l'erreur « no main manifest attribute » lorsque nous essayons d'exécuter le JAR.

Comment afficher le contenu d'un fichier JAR

Pour mieux comprendre notre fichier JAR, examinons son contenu :

cd ~/project
jar tf HelloWorld.jar

Cette commande liste tous les fichiers dans le JAR. La sortie devrait ressembler à ceci :

META-INF/
META-INF/MANIFEST.MF
com/
com/example/
com/example/HelloWorld.class

Comme nous pouvons le constater, notre JAR contient le fichier de classe compilé comme prévu, mais le manifeste ne contient pas les informations nécessaires pour identifier la classe principale.

Quand cette erreur se produit-elle ?

L'erreur « no main manifest attribute » se produit généralement dans les situations suivantes :

  1. Lorsqu'un fichier JAR est créé sans spécifier la classe principale dans le manifeste
  2. Lors de la tentative d'exécution d'un fichier JAR avec java -jar mais que le JAR n'était pas destiné à être exécutable
  3. Lorsque le fichier manifeste existe mais ne contient pas l'attribut Main-Class

Dans notre cas, nous avons délibérément créé un JAR sans spécifier la classe principale pour démontrer l'erreur.

Nettoyons notre répertoire temporaire :

cd ~/project
rm -rf temp_dir

Maintenant que nous comprenons la cause de l'erreur, dans l'étape suivante, nous allons la corriger en créant un fichier manifeste approprié.

Création d'un fichier manifeste

Maintenant que nous comprenons le problème, corrigeons-le en créant un fichier manifeste approprié qui spécifie la classe principale.

Créer un fichier manifeste

Tout d'abord, revenez au répertoire du projet :

cd ~/project

Maintenant, créez un fichier texte appelé manifest.txt :

  1. Cliquez sur l'icône "Explorer" dans la barre latérale gauche de l'IDE Web
  2. Naviguez vers /home/labex/project
  3. Faites un clic droit et sélectionnez "Nouveau fichier"
  4. Nommez le fichier manifest.txt

Ajoutez le contenu suivant au fichier manifest.txt :

Main-Class: com.example.HelloWorld

Assurez-vous d'ajouter un saut de ligne à la fin du fichier (le format du manifeste exige que le fichier se termine par un saut de ligne). Dans l'IDE Web, appuyez simplement sur Entrée après avoir tapé la ligne ci-dessus.

Ce simple fichier manifeste spécifie que la classe com.example.HelloWorld contient la méthode main qui doit être exécutée lors de l'exécution du JAR.

Créer un nouveau fichier JAR avec le manifeste

Maintenant, créez un nouveau fichier JAR, cette fois en incluant notre manifeste personnalisé :

jar cfm HelloWorldWithManifest.jar manifest.txt com/

Cette commande crée un nouveau fichier JAR nommé HelloWorldWithManifest.jar qui inclut les fichiers de classe compilés et utilise notre fichier manifeste personnalisé.

Les options utilisées dans cette commande sont :

  • c : Créer une nouvelle archive
  • f : Spécifier le nom du fichier d'archive
  • m : Inclure les informations du manifeste à partir d'un fichier manifeste spécifié
  • Les arguments restants sont le fichier/répertoire à inclure dans le JAR

Vérifier le manifeste dans le nouveau JAR

Vérifions si notre manifeste a été correctement inclus dans le JAR :

mkdir -p temp_check
cd temp_check
jar xf ../HelloWorldWithManifest.jar META-INF/MANIFEST.MF
cat META-INF/MANIFEST.MF

Vous devriez voir que le manifeste inclut désormais notre attribut Main-Class :

Manifest-Version: 1.0
Created-By: [Java version info]
Main-Class: com.example.HelloWorld

Maintenant, nettoyons le répertoire temporaire :

cd ~/project
rm -rf temp_check

Exécution du fichier JAR corrigé

Maintenant que nous avons créé un fichier JAR avec un manifeste approprié qui spécifie la classe principale, exécutons-le et vérifions qu'il fonctionne correctement.

Exécuter le fichier JAR

Assurez-vous d'être dans le répertoire du projet :

cd ~/project

Maintenant, exécutez le fichier JAR en utilisant la commande java -jar :

java -jar HelloWorldWithManifest.jar

Cette fois, au lieu de l'erreur « no main manifest attribute », vous devriez voir la sortie de notre programme :

Hello, World!

Félicitations. Vous avez réussi à corriger l'erreur « no main manifest attribute » en créant un fichier manifeste approprié qui spécifie la classe principale.

Comprendre ce que nous avons corrigé

Prenons un moment pour comprendre ce que nous avons fait pour corriger l'erreur :

  1. Nous avons créé un fichier manifeste qui inclut l'attribut Main-Class, indiquant à la JVM quelle classe contient la méthode main à exécuter
  2. Nous avons créé un nouveau fichier JAR qui incorpore ces informations de manifeste
  3. Nous avons exécuté le JAR en utilisant la commande java -jar, et la JVM a pu trouver et exécuter la méthode main

Autres façons de spécifier la classe principale

Il existe plusieurs autres façons de spécifier la classe principale lorsque vous travaillez avec des fichiers JAR :

Méthode 1 : Spécifier la classe principale au moment de la création du JAR

Au lieu de créer un fichier manifeste séparé, vous pouvez utiliser l'option e pour spécifier la classe principale directement lors de la création du JAR :

jar cfe HelloWorldDirect.jar com.example.HelloWorld com/

Cela crée un nouveau fichier JAR nommé HelloWorldDirect.jar avec la classe principale spécifiée comme com.example.HelloWorld.

Exécutons ce JAR pour vérifier qu'il fonctionne :

java -jar HelloWorldDirect.jar

Vous devriez voir la sortie :

Hello, World!

Méthode 2 : Exécuter un JAR sans utiliser le manifeste

Si vous avez un fichier JAR sans manifeste approprié, vous pouvez toujours l'exécuter en spécifiant la classe principale directement dans la commande java :

java -cp HelloWorld.jar com.example.HelloWorld

Cette commande indique à la JVM d'utiliser HelloWorld.jar dans le classpath (-cp) et d'exécuter la classe com.example.HelloWorld.

Vous devriez voir la sortie :

Hello, World!

Cette approche contourne la nécessité d'un manifeste en indiquant explicitement à la JVM quelle classe exécuter.

Résumé

Dans ce lab, vous avez appris l'erreur « no main manifest attribute » en Java et comment la résoudre. Récapitulons ce que nous avons couvert :

  1. Comprendre l'erreur : L'erreur « no main manifest attribute » se produit lorsque la JVM ne peut pas trouver la classe principale à exécuter dans un fichier JAR car elle n'est pas spécifiée dans le manifeste.

  2. Création d'un manifeste approprié : Vous avez appris à créer un fichier manifeste qui spécifie la classe principale en utilisant l'attribut Main-Class.

  3. Construction de fichiers JAR avec un manifeste : Vous avez appris à créer des fichiers JAR qui incluent les informations du manifeste :

    • En utilisant un fichier manifeste séparé (jar cfm ...)
    • En spécifiant la classe principale directement lors de la création du JAR (jar cfe ...)
  4. Exécution de fichiers JAR : Vous avez appris différentes façons d'exécuter des applications Java empaquetées en tant que fichiers JAR :

    • En utilisant java -jar avec un manifeste correctement configuré
    • En utilisant java -cp pour spécifier explicitement le classpath et la classe principale

Ces compétences sont essentielles pour les développeurs Java qui doivent empaqueter et distribuer leurs applications en tant que fichiers JAR. En comprenant le rôle du manifeste et comment le configurer correctement, vous pouvez éviter l'erreur « no main manifest attribute » et vous assurer que vos applications Java s'exécutent sans problème.

Rappelez-vous qu'un empaquetage correct est tout aussi important que l'écriture d'un bon code. Prendre le temps de configurer correctement votre build et votre empaquetage vous évitera, à vous et à vos utilisateurs, des frustrations par la suite.