it-swarm.com.de

Jar-Datei kann nicht ausgeführt werden: "no main manifest attribute"

Ich habe eine Anwendung installiert. Wenn ich versuche, sie auszuführen (es ist eine ausführbare JAR-Datei), passiert nichts. Wenn ich es von der Kommandozeile aus mit:

Java -jar "app.jar"

Ich erhalte folgende Nachricht:

kein Hauptmanifestattribut in "app.jar"

Normalerweise hätte ich der Manifestdatei ein Hauptklassenattribut hinzugefügt, wenn ich das Programm selbst erstellt hätte. Aber in diesem Fall kann ich das nicht tun, da die Datei aus einer Anwendung stammt. Ich habe auch versucht, das Glas zu extrahieren, um zu sehen, ob ich die Hauptklasse finden konnte, aber es gibt zu viele Klassen, und keine von ihnen hat das Wort "main" im Namen. Es muss eine Möglichkeit geben, dies zu beheben, da das Programm auf anderen Systemen einwandfrei ausgeführt wird.

820
Ewoud

Erstens ist es komisch zu sehen, wie Sie _Java -jar "app"_ und nicht _Java -jar app.jar_ ausführen.

Zweitens müssen Sie eine Datei namens META-INF/MANIFEST.MF jaren, um ein JAR ausführbar zu machen

die Datei selbst sollte (mindestens) diesen einen Liner haben:

_Main-Class: com.mypackage.MyClass
_

Wobei _com.mypackage.MyClass_ die Klasse ist, die den öffentlichen statischen void main-Einstiegspunkt (String [] args) enthält.

Beachten Sie, dass es mehrere Möglichkeiten gibt, dies entweder mit der CLI, Maven, Ant oder Gradle zu erreichen:

Für CLI wird der folgende Befehl ausgeführt: (tks @ dvvrt ) _jar cmvf META-INF/MANIFEST.MF <new-jar-filename>.jar <files to include>_

Für Maven sollte so etwas wie das folgende Snippet den Trick machen. Beachten Sie, dass dies nur die Plugin-Definition ist, nicht die vollständige 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>
_

(Wählen Sie einen <version> passend zu Ihrem Projekt.)

Für Ant sollte das folgende Snippet helfen:

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

Credits Michael Niemand -

Für Gradle :

_plugins {
    id 'Java'
}

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

Das hätte Java -jar app.jar statt Java -jar "app" sein sollen.

Die Option -jar funktioniert nur, wenn die JAR-Datei eine ausführbare JAR-Datei ist. Dies bedeutet, dass eine Manifestdatei mit dem Attribut Main-Class vorhanden sein muss. In Packen von Programmen in JAR-Dateien erfahren Sie, wie Sie eine ausführbare JAR-Datei erstellen.

Wenn es sich nicht um eine ausführbare JAR-Datei handelt, müssen Sie das Programm folgendermaßen ausführen:

Java -cp app.jar com.somepackage.SomeClass

dabei ist com.somepackage.SomeClass die Klasse, die die main -Methode zum Ausführen des Programms enthält. (Was diese Klasse ist, hängt vom Programm ab, es ist unmöglich, anhand der von Ihnen bereitgestellten Informationen zu sagen).

246
Jesper

Alternativ können Sie das maven-Assembly-Plugin verwenden, wie im folgenden Beispiel gezeigt:

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

In diesem Beispiel werden alle im Abschnitt angegebenen Abhängigkeitsgläser automatisch in Ihr einzelnes Glas eingeschlossen. Beachten Sie, dass jar-with-dependencies buchstäblich als geschrieben werden sollte und nicht durch die Namen der JAR-Dateien ersetzt werden soll, die Sie einschließen möchten.

106
CodeBrew

Dies liegt daran, dass Java das Main-Attribut in der MANIFEST.MF-Datei nicht finden kann. Das Main-Attribut ist erforderlich, um Java mitzuteilen, welche Klasse als Einstiegspunkt für die Anwendung verwendet werden soll. In der JAR-Datei befindet sich die Datei MANIFEST.MF im Ordner META-INF. Sie fragen sich, wie Sie sehen können, was sich in einer JAR-Datei befindet? Öffnen Sie die JAR-Datei mit WinRAR.

Das Hauptattribut in MANIFEST.MF sieht folgendermaßen aus:

Main-Class: <packagename>.<classname>

Wenn diese Zeile in der MANIFEST.MF-Datei fehlt, wird dieser Fehler "kein Hauptmanifestattribut" angezeigt.

Es ist wirklich ein großes Durcheinander, dieses Attribut in der Datei MANIFEST.MF anzugeben.

Update: Ich habe gerade eine sehr gute Möglichkeit gefunden, den Einstiegspunkt der Anwendung in Eclipse festzulegen. Wenn Sie Exportieren sagen,

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.

enter image description here

58

Die Gradle-Antwort lautet:

apply plugin: 'Java'

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

Für Maven ist dies das, was es gelöst hat (für mich für eine Veetle-Codebasis auf 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>

Prost...

25
Dave

Versuchen Sie diesen Befehl, um das Jar einzuschließen:

Java -cp yourJarName.jar your.package..your.MainClass
24
Burhan ARAS

Ich hatte dieses Problem beim Erstellen eines Glases mit IntelliJ IDEA. Siehe diese Diskussion .

Was es für mich löste, war, das JAR-Artefakt neu zu erstellen, JAR> From modules with dependencies zu wählen, aber das Standardverzeichnis für META-INF/MANIFEST.MF nicht zu akzeptieren. Ändern Sie es von -/src/main/Java in -/src/main/resources.

Andernfalls wurde eine Manifest-Datei in die JAR-Datei aufgenommen, jedoch nicht die Datei in -/src/main/Java, die sie haben sollte.

23
morningstar

Ich hatte das gleiche Problem. Durch das Hinzufügen der folgenden Zeilen zur pom-Datei hat es funktioniert. Das Plugin wird den Erstellungsprozess Ihrer Anwendung mit allen notwendigen Schritten sicherstellen.

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

Für mich hat keine der Antworten wirklich geholfen - ich hatte die Manifestdatei an der richtigen Stelle, die die Hauptklasse und alles enthielt. Was mich stolperte, war Folgendes:

Warnung: Die Textdatei, aus der Sie das Manifest erstellen, muss mit einer neuen Zeile oder einem Wagenrücklauf enden. Die letzte Zeile wird nicht richtig analysiert, wenn sie nicht mit einer neuen Zeile oder einem Zeilenumbruch endet.

( Quelle ). Das Hinzufügen einer neuen Zeile am Ende des Manifests hat das Problem behoben.

13
eis

Wenn Sie Maven verwenden, fügen Sie Folgendes in den Pom ein

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

Ich habe gerade den gleichen Fehler bekommen. Wenn Sie gradle verwenden, fügen Sie einfach den nächsten in Ihr gradle.build ein:

apply plugin: 'Java'

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

Where com.company.project.MainClass Pfad zu Ihrer Klasse mit der public static void main(String[] args) Methode.

9
Binakot

Ich hatte heute das gleiche Problem. Mein Problem wurde gelöst, als ich META-INF in den Ressourcenordner verschoben habe.

8
RegUser

Wenn das jar nicht folgt die Regeln , ist es kein ausführbares jar.

6
John M

Ich hatte das gleiche Problem und es ist jetzt behoben :) Befolgen Sie einfach die folgenden Schritte und der Fehler könnte für alles sein, aber die folgenden Schritte machen den Prozess reibungsloser. Ich verbringe viel Zeit damit, das Problem zu beheben.

1.Versuchen Sie, Eclipse neu zu starten (wenn Sie Eclipse zum Erstellen der JAR-Datei verwenden) -> Dies hat mir beim Exportieren der JAR-Datei geholfen.

2.Versuchen Sie nach dem Neustart von Eclipse, festzustellen, ob Ihre Eclipse die Hauptklasse/-methode an Ihrem Java -Projekt erkennt -> Rechtsklick -> Ausführen als -> Konfigurationen ausführen -> Haupt -> Klicken Sie auf die Schaltfläche Suchen, um festzustellen, ob Ihre Eclipse in der JAR-Datei nach Ihrer Hauptklasse suchen kann. -> Dies ist für die Validierung, dass die JAR-Datei den Einstiegspunkt in die Hauptklasse hat.

  1. Exportieren Sie anschließend Ihr dynamisches Projekt Java als "Runnable JAR" -Datei und nicht als JAR-Datei.

  2. Wählen Sie in der Java Startkonfiguration Ihre Hauptklasse aus.

  3. Verwenden Sie nach dem Exportieren der JAR-Datei den folgenden Befehl, um sie auszuführen. Java -cp [Ihr JAR] .jar [Gesamtpaket] .MainClass zB: Java -cp AppleTCRuleAudit.jar com.Apple.tcruleaudit.classes.TCRuleAudit

  4. Möglicherweise tritt der nicht unterstützte Versionsfehler Java auf. Das Update besteht darin, das Java_home in Ihrem Shell-Bash-Profil so zu ändern, dass es mit der Java -Version übereinstimmt, die zum Kompilieren des Projekts in Eclipse verwendet wurde.

Hoffe das hilft! Bitte lassen Sie mich wissen, wenn Sie noch irgendwelche Probleme haben.

5
Karthik Pon

Ich hatte das gleiche problem Viele der hier erwähnten Lösungen haben mir nicht das ganze Bild vermittelt. Ich werde versuchen, Ihnen eine Zusammenfassung darüber zu geben, wie JAR-Dateien von der Kommandozeile aus packen.

  1. Wenn Sie Ihre .class -Dateien in Paketen haben möchten, fügen Sie das Paket am Anfang des .Java hinzu.

    Test.Java

    package testpackage;
    
    public class Test
    {
        ...
    }
    
  2. Um Ihren Code mit Ihren .class -Dateien zu kompilieren, die mit der durch den Paketnamen angegebenen Struktur enden, verwenden Sie:

    javac -d . Test.Java
    

    Mit dem -d . erstellt der Compiler die gewünschte Verzeichnisstruktur.

  3. Wenn Sie die Datei .jar packen, müssen Sie die jar-Routine anweisen, wie sie gepackt werden soll. Hier verwenden wir das Optionsset cvfeP. Dies geschieht, um die Paketstruktur beizubehalten (Option P), den Einstiegspunkt anzugeben, damit die Manifestdatei aussagekräftige Informationen enthält (Option e) . Mit der Option f können Sie den Dateinamen angeben, mit der Option c wird ein Archiv erstellt, und mit der Option v wird die Ausgabe auf ausführlich festgelegt. Die wichtigen Dinge, die hier zu beachten sind, sind P und e.

    Dann kommt der Name des Glases, das wir wollen test.jar.

    Dann kommt der Einstiegspunkt.

    Und dann kommt -C . <packagename>/, um die Klassendateien aus diesem Ordner abzurufen, wobei die Ordnerstruktur beibehalten wird.

    jar cvfeP test.jar testpackage.Test -C . testpackage/
    
  4. Überprüfen Sie Ihre .jar -Datei in einem Zip-Programm. Es sollte die folgende Struktur haben

    test.jar

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

    Die MANIFEST.MF sollte Folgendes enthalten

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

    Wenn Sie Ihr Manifest manuell bearbeiten stellen Sie sicher, dass Sie die neue Zeile am Ende beibehalten andernfalls erkennt Java es nicht.

  5. Führen Sie Ihre .jar -Datei mit aus

    Java -jar test.jar
    
4
CodeMonkey

Jede ausführbare JAR-Datei sollte entweder durch Klicken oder Ausführen mit der Eingabeaufforderung Java -jar app.jar ausgeführt werden (verwenden Sie "wenn der Pfad des JAR Leerzeichen enthält" - dh Java -jar "C :\Ordnername\app.jar "). Wenn Ihre ausführbare JAR-Datei nicht ausgeführt wird, bedeutet dies, dass sie nicht ordnungsgemäß erstellt wurde.

Zum besseren Verständnis extrahieren Sie die JAR-Datei (oder zeigen Sie sie mit einem beliebigen Tool an, für Windows 7-Zip ist Nizza) und überprüfen Sie die Datei unter /META-INF/MANIFEST.MF. Wenn Sie einen Eintrag wie finden

Hauptklasse: Ihr.Paketname.ClaaswithMain - dann ist es in Ordnung, sonst müssen Sie es angeben.

Achten Sie darauf, dass Sie den Hauptklasseneintrag in der Datei MANIFEST.MF anhängen. Überprüfen Sie, wo Sie ihn speichern!

4
Shekh Akther

Möglicherweise haben Sie die JAR-Datei nicht richtig erstellt:

beispiel: Fehlende Option m bei der Erstellung des Glases

Die folgenden Arbeiten:

jar -cvfm MyJar.jar Manifest.txt *.class
4
satheesh.v

Ich persönlich denke, alle Antworten hier verstehen die Frage falsch. Die Antwort darauf liegt im Unterschied, wie Springboot die .jar erstellt. Jeder weiß, dass Spring Boot ein Manifest wie dieses erstellt, das sich von jedem unterscheidet Annahme dass dies ein Standard-JAR-Start ist, der es sein kann oder nicht:

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

Vielleicht muss es mit org.springframework.boot.loader.JarLauncher auf dem Klassenpfad ausgeführt werden?

4
djangofan

Sie können einfach diesem Schritt folgen. Erstellen Sie eine JAR-Datei mit

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

Während die JAR-Datei läuft, einfach so laufen

 Java -cp jarfile-name main-classname
4
Koneri

Für mich ist dieser Fehler einfach deshalb aufgetreten, weil ich vergessen habe, Eclipse mitzuteilen, dass ich eine ausführbare JAR-Datei und keine einfache Bibliotheks-JAR-Datei haben möchte. Wenn Sie also die JAR-Datei in Eclipse erstellen, stellen Sie sicher, dass Sie das rechte Optionsfeld aktivieren

3

Die obigen Antworten waren für mich nur teilweise hilfreich. Java -cp war Teil der Antwort, aber ich brauchte genauere Informationen, um die auszuführende Klasse zu identifizieren. Folgendes hat bei mir funktioniert:

Schritt 1: Finde die Klasse, die ich ausführen muss

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

Die Top-Zeilen des Ergebnisses waren:

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

App.class enthielt die auszuführende Hauptklasse. Ich bin mir nicht hundertprozentig sicher, ob Sie immer davon ausgehen können, dass der von Ihnen benötigte Kurs der erste ist, aber er war für mich. Wenn nicht, würde ich mir vorstellen, dass es nicht allzu schwierig ist, mit grep bibliotheksbezogene Ergebnisse auszuschließen, um die Klassenliste auf eine überschaubare Größe zu reduzieren.

Von da an war es einfach: Ich benutze nur diesen Pfad (abzüglich des Suffixes ".class"):

Java -cp /path/to/myjar.jar somepath/App
3
mwag

Da Sie MANIFEST.MF hinzugefügt haben, sollten Sie die Reihenfolge der Felder in dieser Datei berücksichtigen. Mein env ist Java version "1.8.0_91"

und meine MANIFEST.MF wie hier

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

Dies wird jedoch wie folgt durchlaufen

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

//this run swing normally
2
Fan Yer

(erster Beitrag - so darf es nicht sauber sein)

Dies ist mein Fix für OS X 11.6, Maven-basiertes Netbeans 8.2-Programm. Bis jetzt ist meine App zu 100% Netbeans - keine Optimierung (nur ein paar Shell-Fluchten für das Unmögliche!).

Nachdem ich die meisten Antworten hier und anderswo vergeblich ausprobiert hatte, kehrte ich zur Kunst zurück, "das zu benutzen, was funktioniert".

Die beste Antwort hier ( olivier-refalo thanx) schien der richtige Ausgangspunkt zu sein, hat aber nicht geholfen.

Bei anderen Projekten, die erfolgreich waren, habe ich einige geringfügige Unterschiede in den Manifestlinien festgestellt:

  1. addClasspath, classpathPrefix fehlten (löschte sie)
  2. mainClass fehlte die "com". (verwendet das NB -> Projekteigenschaften-> Ausführen-> Hauptklasse-> Durchsuchen, um anzugeben)

Ich weiß nicht warum (ich bin erst 3 Monate in Java) oder wie, kann aber nur sagen, dass dies funktioniert hat.

Hier ist nur der modifizierte Manifest-Block:

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

Ich habe eine neue Lösung für die schlechte Manifest-Generation gefunden!

  1. Öffnen Sie die JAR-Datei mit einem Zip-Editor wie WinRAR
  2. Klicken Sie auf für META-INF

  3. Hinzufügen oder bearbeiten

    • Hinzufügen:

      • Erstellen Sie eine Textdatei mit dem Namen MANIFEST.MF in einem Ordner mit dem Namen META-INF und fügen Sie die folgende Zeile hinzu:

        • Manifest-Version: 1.0
        • Hauptklasse: package.ex.com.views.mainClassName
      • Speichern Sie die Datei und fügen Sie sie der Zip hinzu

    • Bearbeiten:

      • Ziehen Sie die Datei heraus, und ändern Sie die Datei MANIFEST.MF, um die vorherige Zeile hinzuzufügen
  4. Öffnen Sie cmd und geben Sie Folgendes ein: Java -jar c: /path/JarName.jar

Es sollte jetzt gut funktionieren!

2
Dave Beauchesne

die meisten lösungen haben bei mir nicht funktioniert, aber mein lehrer hat mir geholfen, ich möchte seine lösung hier mit anderen teilen. ich habe kali linux terminal verwendet, sollte aber in debian in ordnung sein

javac *.Java
nano MANIFEST.MF

im Dateityp

Hauptklasse: Haupt oder wie auch immer Ihr Hauptdateiname lautet (stellen Sie sicher, dass Sie den Paketnamen hinzufügen, falls vorhanden)

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

jetzt zum Ausführen der Datei verwenden

Java -jar new.jar

oder Sie können zu den Eigenschaften der Akte gehen und überprüfen

Erlaube die Ausführung der Datei als Programm

doppelklicken Sie darauf

es hat mir geholfen, während die meisten der obigen Antworten nicht taten

1
user10356724

Möglicherweise haben Sie das gleiche Problem wie ich. Schreiben Sie nach dem Erstellen der JAR-Datei jar xf app.jar META-INF/MANIFEST.MF. Dadurch wird eine Kopie der Datei in Ihrem aktuellen Verzeichnis erstellt, damit Sie sie lesen können. Wenn es nur so aussagt:

Manifest-Version: 1.0

Erstellt von: 1.8.0_51 (Oracle Corporation)

und enthält nicht die "Main-Class" -Deklaration, dann haben Sie wohl Ihr Problem gefunden.

Ich weiß jedoch nicht, wie ich es lösen soll. Ich habe andere Leute mit gleichen/ähnlichen Problemen auf StackOverflow überprüft und konnte keine Antwort finden. Mit diesen Informationen können Sie jedoch möglicherweise eine bessere Hilfe erhalten (angesichts der Tatsache, dass Sie dasselbe Problem haben wie ich).

Bearbeiten: Ich hatte versucht, eine Manifest-Datei zu verwenden, konnte sie aber nicht zum Laufen bringen. Mein Fehler war jedoch, beim Erstellen der JAR-Datei nur eine der Klassen zu benennen. Ich habe stattdessen * .class geschrieben und es funktioniert jetzt.

Obwohl ich nicht weiß, warum eine Manifest-Datei erstellt werden muss. Aber ich denke, es ist in Ordnung, solange es funktioniert.

1
Gendarme

Wenn Sie die Befehlszeile zum Assemblieren von .jar verwenden, können Sie auf das Hauptverzeichnis verweisen, ohne eine Manifest-Datei hinzuzufügen. Beispiel:

jar cfve app.jar TheNameOfClassWithMainMethod *.class

(param "e" macht das: TheNameOfClassWithMainMethod ist ein Name der Klasse mit der Methode main () und app.jar - Name der ausführbaren .jar und * .class - nur alle zu assemblierenden Klassendateien)

1
Andrey

Ich hatte dieses Problem und habe es kürzlich in Netbeans 8 behoben (siehe Abbildung unten):

Netbeans project properties

  1. gehen Sie zu Eigenschaften Ihres Projekts.
  2. klicken Sie auf Ausführen.
  3. geben Sie die Hauptklasse Ihres Projekts mit durchsuchen an.
  4. build und run die Jar-Datei.
1

Nur um einen Punkt klar zu machen

Main-Class: <packagename>.<classname>

Wenn Sie kein Paket haben, müssen Sie diesen Teil wie folgt ignorieren:

Main-Class: <classname>
1
Reihan_amn

überprüfen Sie, ob Ihre JAR-Datei in MANIFEST.MF Main-Class verfügbar ist oder nicht

first.Java

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

Vorher:

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

Nach:

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
0
KARTHIKEYAN.A

Ich hatte ein ähnliches Problem wie Sie, im Folgenden eine Syntax zum erfolgreichen Erstellen einer .war-Datei: -

jar {cvf} [jar-datei] [manifest-datei]

manifest Beim Erstellen (c) oder Aktualisieren (u) einer JAR-Datei definiert der Manifest-Operand die zuvor vorhandenen Manifest-Dateien mit Namen und Werten von Attributen, die in MANIFEST.MF in der JAR-Datei enthalten sein sollen. Der Manifest-Operand muss angegeben werden, wenn die Option f '[ 1 ]' vorhanden ist.

Um eine Manifest-Datei zu erstellen, müssen Sie für einige Attribute einen Wert definieren. Um zu vermeiden, dass eine Manifest-Datei erstellt wird, können Sie nach dem Dateinamen (.WAR) ein Sternchen einfügen: -

jar -cvf foo.war *

Um ehrlich zu sein, ich weiß nicht, ob das eine bewährte Methode ist, aber sie erledigt die Arbeit für mich :).

0
M.87

Fanden eine großartige Lösung, die in einer solchen Situation helfen würde, vorausgesetzt, Sie benötigen nur ein lauffähiges Gefäß, was Sie in den meisten Fällen tun. Wenn Ihre Anwendung in Intellij Idea ausgeführt wird, gehen Sie wie folgt vor: 1) Gehen Sie zu den Moduleinstellungen und dann zu den Artefakten, fügen Sie eine JAR hinzu und definieren Sie die Hauptklasse .

Dies hat auch dann funktioniert, wenn ich den Quellordner geändert und statt Java scala verwendet habe.

0
Ritesh Tyagi