So beheben Sie den Fehler 'no main manifest attribute' in Java

Einführung

Beim Verpacken und Ausführen von Java-Anwendungen als JAR-Dateien (Java Archive) stoßen Entwickler häufig auf den Fehler 'no main manifest attribute'. Dieser Fehler tritt auf, wenn versucht wird, eine JAR-Datei auszuführen, aber die Java Virtual Machine (JVM) nicht bestimmen kann, welche Klasse die main-Methode zur Start der Anwendung enthält.

Dieses Lab führt Sie durch das Verständnis, die Diagnose und die Behebung dieses häufigen Fehlers. Am Ende dieses Tutorials werden Sie wissen, wie Sie JAR-Dateien mit Manifestdateien richtig konfigurieren, die die Hauptklasse korrekt angeben.

Erstellen einer einfachen Java-Anwendung

Beginnen wir mit der Erstellung einer einfachen Java-Anwendung, die wir in eine JAR-Datei verpacken werden. Dies hilft uns, den Fehler 'no main manifest attribute' zu demonstrieren und später zu beheben.

Erstellen der Java-Klasse

Erstellen Sie zunächst ein Verzeichnis für unsere Java-Quelldateien und navigieren Sie dorthin:

cd ~/project/src/com/example

Öffnen Sie nun den Editor und erstellen Sie eine neue Datei namens HelloWorld.java in diesem Verzeichnis:

1. Klicken Sie auf das Symbol "Explorer" in der linken Seitenleiste der WebIDE.
2. Navigieren Sie zu /home/labex/project/src/com/example.
3. Klicken Sie mit der rechten Maustaste und wählen Sie "Neue Datei".
4. Benennen Sie die Datei HelloWorld.java.

Fügen Sie der Datei HelloWorld.java den folgenden Code hinzu:

package com.example;

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

Dies ist ein einfaches Java-Programm mit einer main-Methode, die "Hello, World!" auf der Konsole ausgibt, wenn es ausgeführt wird.

Kompilieren der Java-Klasse

Kompilieren wir nun unsere Java-Klasse. Kehren Sie zum Terminal zurück und navigieren Sie zum Projektstammverzeichnis:

cd ~/project

Kompilieren Sie die Java-Datei mit dem Befehl javac:

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

Dieser Befehl kompiliert die Java-Quelldatei und platziert die kompilierte Klassendatei in der entsprechenden Verzeichnisstruktur, basierend auf dem Paketnamen.

Sie sollten jetzt eine kompilierte Klassendatei unter ~/project/com/example/HelloWorld.class haben. Sie können dies mit folgendem Befehl überprüfen:

ls -l com/example/

Die Ausgabe sollte die Datei HelloWorld.class anzeigen:

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

Erstellen einer einfachen JAR-Datei ohne Manifest

Erstellen wir nun eine JAR-Datei, ohne eine Hauptklasse im Manifest anzugeben. Dies ermöglicht es uns, den Fehler 'no main manifest attribute' zu reproduzieren:

jar cf HelloWorld.jar com/

Dieser Befehl erstellt eine JAR-Datei namens HelloWorld.jar, die die kompilierte Klassendatei enthält.

Versuchen, die JAR-Datei auszuführen

Nachdem wir nun unsere JAR-Datei erstellt haben, versuchen wir, sie auszuführen:

java -jar HelloWorld.jar

Sie sehen die Fehlermeldung:

no main manifest attribute, in HelloWorld.jar

Dies ist der Fehler, den wir beheben lernen. Die JVM kann die Hauptklasse nicht finden, um sie auszuführen, da wir sie nicht im Manifest der JAR-Datei angegeben haben.

Verstehen des Fehlers 'no main manifest attribute'

In diesem Schritt werden wir die Ursache des Fehlers 'no main manifest attribute' untersuchen und verstehen, wie die Manifestdatei der JAR-Datei funktioniert.

Was ist die Manifestdatei?

Eine JAR-Datei enthält eine spezielle Datei namens MANIFEST.MF im Verzeichnis META-INF. Diese Manifestdatei enthält Metadaten über die JAR-Datei und ihren Inhalt. Eine wichtige Information, die das Manifest enthalten kann, ist das Attribut Main-Class, das der JVM mitteilt, welche Klasse die main-Methode enthält, die beim Ausführen der JAR-Datei ausgeführt werden soll.

Untersuchen wir das aktuelle Manifest in unserer JAR-Datei:

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

Sie sehen ein minimales Manifest, das in etwa so aussieht:

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

Beachten Sie, dass dieses Manifest kein Attribut Main-Class enthält, weshalb wir den Fehler 'no main manifest attribute' erhalten, wenn wir versuchen, die JAR-Datei auszuführen.

So zeigen Sie den Inhalt einer JAR-Datei an

Um unsere JAR-Datei besser zu verstehen, werfen wir einen Blick auf ihren Inhalt:

cd ~/project
jar tf HelloWorld.jar

Dieser Befehl listet alle Dateien in der JAR-Datei auf. Die Ausgabe sollte in etwa so aussehen:

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

Wie wir sehen können, enthält unsere JAR-Datei wie erwartet die kompilierte Klassendatei, aber das Manifest enthält nicht die Informationen, die zur Identifizierung der Hauptklasse benötigt werden.

Wann tritt dieser Fehler auf?

Der Fehler 'no main manifest attribute' tritt typischerweise in diesen Situationen auf:

1. Wenn eine JAR-Datei erstellt wird, ohne die Hauptklasse im Manifest anzugeben.
2. Beim Versuch, eine JAR-Datei mit java -jar auszuführen, aber die JAR-Datei nicht zur Ausführung bestimmt war.
3. Wenn die Manifestdatei existiert, aber nicht das Attribut Main-Class enthält.

In unserem Fall haben wir absichtlich eine JAR-Datei erstellt, ohne die Hauptklasse anzugeben, um den Fehler zu demonstrieren.

Löschen wir unser temporäres Verzeichnis:

cd ~/project
rm -rf temp_dir

Nachdem wir nun die Ursache des Fehlers verstanden haben, werden wir ihn im nächsten Schritt beheben, indem wir eine ordnungsgemäße Manifestdatei erstellen.

Erstellen einer Manifestdatei

Nachdem wir nun das Problem verstanden haben, beheben wir es, indem wir eine ordnungsgemäße Manifestdatei erstellen, die die Hauptklasse angibt.

Erstellen einer Manifestdatei

Navigieren Sie zunächst zurück zum Projektverzeichnis:

cd ~/project

Erstellen Sie nun eine Textdatei namens manifest.txt:

1. Klicken Sie auf das Symbol "Explorer" in der linken Seitenleiste der WebIDE.
2. Navigieren Sie zu /home/labex/project.
3. Klicken Sie mit der rechten Maustaste und wählen Sie "Neue Datei".
4. Benennen Sie die Datei manifest.txt.

Fügen Sie der Datei manifest.txt den folgenden Inhalt hinzu:

Main-Class: com.example.HelloWorld

Achten Sie darauf, am Ende der Datei eine neue Zeile hinzuzufügen (das Manifestformat erfordert, dass die Datei mit einer neuen Zeile endet). In der WebIDE drücken Sie einfach die Eingabetaste, nachdem Sie die obige Zeile eingegeben haben.

Diese einfache Manifestdatei gibt an, dass die Klasse com.example.HelloWorld die main-Methode enthält, die beim Ausführen der JAR-Datei ausgeführt werden soll.

Erstellen einer neuen JAR-Datei mit dem Manifest

Erstellen Sie nun eine neue JAR-Datei, diesmal einschließlich unseres benutzerdefinierten Manifests:

jar cfm HelloWorldWithManifest.jar manifest.txt com/

Dieser Befehl erstellt eine neue JAR-Datei namens HelloWorldWithManifest.jar, die die kompilierten Klassendateien enthält und unsere benutzerdefinierte Manifestdatei verwendet.

Die in diesem Befehl verwendeten Optionen sind:

• c: Erstellt ein neues Archiv
• f: Gibt den Archivdateinamen an
• m: Beinhaltet Manifestinformationen aus einer angegebenen Manifestdatei
• Die verbleibenden Argumente sind die Datei/das Verzeichnis, die/das in die JAR-Datei aufgenommen werden soll

Überprüfen des Manifests in der neuen JAR-Datei

Überprüfen wir, ob unser Manifest korrekt in die JAR-Datei aufgenommen wurde:

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

Sie sollten sehen, dass das Manifest jetzt unser Attribut Main-Class enthält:

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

Löschen wir nun das temporäre Verzeichnis:

cd ~/project
rm -rf temp_check

Ausführen der korrigierten JAR-Datei

Nachdem wir nun eine JAR-Datei mit einem ordnungsgemäßen Manifest erstellt haben, das die Hauptklasse angibt, lassen Sie uns sie ausführen und überprüfen, ob sie korrekt funktioniert.

Ausführen der JAR-Datei

Stellen Sie sicher, dass Sie sich im Projektverzeichnis befinden:

cd ~/project

Führen Sie nun die JAR-Datei mit dem Befehl java -jar aus:

java -jar HelloWorldWithManifest.jar

Diesmal sollten Sie anstelle des Fehlers 'no main manifest attribute' die Ausgabe unseres Programms sehen:

Hello, World!

Herzlichen Glückwunsch. Sie haben den Fehler 'no main manifest attribute' erfolgreich behoben, indem Sie eine ordnungsgemäße Manifestdatei erstellt haben, die die Hauptklasse angibt.

Verstehen, was wir behoben haben

Nehmen wir uns einen Moment Zeit, um zu verstehen, was wir getan haben, um den Fehler zu beheben:

1. Wir haben eine Manifestdatei erstellt, die das Attribut Main-Class enthält und der JVM mitteilt, welche Klasse die main-Methode enthält, die ausgeführt werden soll.
2. Wir haben eine neue JAR-Datei erstellt, die diese Manifestinformationen enthält.
3. Wir haben die JAR-Datei mit dem Befehl java -jar ausgeführt, und die JVM konnte die main-Methode finden und ausführen.

Alternative Möglichkeiten zur Angabe der Hauptklasse

Es gibt verschiedene andere Möglichkeiten, die Hauptklasse bei der Arbeit mit JAR-Dateien anzugeben:

Methode 1: Angeben der Hauptklasse zur Erstellungszeit der JAR-Datei

Anstatt eine separate Manifestdatei zu erstellen, können Sie die Option e verwenden, um die Hauptklasse direkt beim Erstellen der JAR-Datei anzugeben:

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

Dadurch wird eine neue JAR-Datei namens HelloWorldDirect.jar erstellt, wobei die Hauptklasse als com.example.HelloWorld angegeben wird.

Lassen Sie uns diese JAR-Datei ausführen, um zu überprüfen, ob sie funktioniert:

java -jar HelloWorldDirect.jar

Sie sollten die Ausgabe sehen:

Hello, World!

Methode 2: Ausführen einer JAR-Datei ohne Verwendung des Manifests

Wenn Sie eine JAR-Datei ohne ein ordnungsgemäßes Manifest haben, können Sie sie trotzdem ausführen, indem Sie die Hauptklasse direkt im Befehl java angeben:

java -cp HelloWorld.jar com.example.HelloWorld

Dieser Befehl weist die JVM an, HelloWorld.jar im Klassenpfad (-cp) zu verwenden und die Klasse com.example.HelloWorld auszuführen.

Sie sollten die Ausgabe sehen:

Hello, World!

Dieser Ansatz umgeht die Notwendigkeit eines Manifests, indem er der JVM explizit mitteilt, welche Klasse ausgeführt werden soll.

Zusammenfassung

In diesem Lab haben Sie etwas über den Fehler 'no main manifest attribute' in Java gelernt und wie man ihn behebt. Lassen Sie uns rekapitulieren, was wir behandelt haben:

1. Verständnis des Fehlers: Der Fehler 'no main manifest attribute' tritt auf, wenn die JVM die auszuführende Hauptklasse in einer JAR-Datei nicht finden kann, da sie nicht im Manifest angegeben ist.

2. Erstellen eines ordnungsgemäßen Manifests: Sie haben gelernt, wie man eine Manifestdatei erstellt, die die Hauptklasse mithilfe des Attributs Main-Class angibt.

3. Erstellen von JAR-Dateien mit einem Manifest: Sie haben gelernt, wie man JAR-Dateien erstellt, die Manifestinformationen enthalten:

   • Verwendung einer separaten Manifestdatei (jar cfm ...)
   • Direktes Angeben der Hauptklasse während der JAR-Erstellung (jar cfe ...)

4. Ausführen von JAR-Dateien: Sie haben verschiedene Möglichkeiten kennengelernt, Java-Anwendungen auszuführen, die als JAR-Dateien verpackt sind:

   • Verwendung von java -jar mit einem korrekt konfigurierten Manifest
   • Verwendung von java -cp, um den Klassenpfad und die Hauptklasse explizit anzugeben

Diese Fähigkeiten sind für Java-Entwickler unerlässlich, die ihre Anwendungen als JAR-Dateien verpacken und verteilen müssen. Indem Sie die Rolle des Manifests verstehen und wissen, wie man es richtig konfiguriert, können Sie den Fehler 'no main manifest attribute' vermeiden und sicherstellen, dass Ihre Java-Anwendungen reibungslos laufen.

Denken Sie daran, dass eine ordnungsgemäße Verpackung genauso wichtig ist wie das Schreiben von gutem Code. Wenn Sie sich die Zeit nehmen, Ihren Build und Ihre Verpackung korrekt einzurichten, ersparen Sie sich und Ihren Benutzern spätere Frustrationen.