Impossibile eseguire il file jar: "nessun attributo manifest principale"

Ho installato un'applicazione, quando provo a eseguirla (è un vaso eseguibile) non succede nulla. Quando lo eseguo dalla riga di comando con:

java -jar "app.jar"

Ricevo il seguente messaggio:

nessun attributo manifest principale, in "app.jar"

Normalmente, se avessi creato il programma da solo, avrei aggiunto un attributo di classe principale al file manifest. Ma in questo caso, poiché il file proviene da un'applicazione, non posso farlo. Ho anche provato ad estrarre il vaso per vedere se riuscivo a trovare la classe principale, ma ce ne sono molte e nessuna di esse ha la parola "principale" nel suo nome. Ci deve essere un modo per risolvere questo problema perché il programma funziona correttamente su altri sistemi.

Innanzitutto, è un po 'strano vederti correre java -jar "app"e nonjava -jar app.jar

In secondo luogo, per rendere eseguibile un jar ... è necessario eseguire il jar di un file chiamato META-INF / MANIFEST.MF

il file stesso dovrebbe avere (almeno) questa riga:

Main-Class: com.mypackage.MyClass

Dove si com.mypackage.MyClasstrova la classe che detiene il punto di ingresso principale statico vuoto (String [] args) .

Nota che ci sono diversi modi per farlo con CLI, Maven, Ant o Gradle:

Per la CLI , eseguirà il comando seguente: (tks @ dvvrt ) jar cmvf META-INF/MANIFEST.MF <new-jar-filename>.jar <files to include>

Per Maven , qualcosa come il seguente frammento dovrebbe fare il trucco. Si noti che questa è solo la definizione del plug-in, non il pom.xml completo :

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

(Scegli un <version>appropriato per il tuo progetto.)

Per Ant , lo snippet di seguito dovrebbe aiutare:

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

Crediti Michael Niemand -

Per Gradle :

plugins {
    id 'java'
}

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

Quello avrebbe dovuto essere java -jar app.jarinvece di java -jar "app".

L' -jaropzione funziona solo se il file JAR è un file JAR eseguibile, il che significa che deve contenere un file manifest con un Main-Classattributo. Vedere Programmi di packaging nei file JAR per informazioni su come creare un JAR eseguibile.

Se non è un JAR eseguibile, dovrai eseguire il programma con qualcosa del tipo:

java -cp app.jar com.somepackage.SomeClass

dove si com.somepackage.SomeClasstrova la classe che contiene il mainmetodo per eseguire il programma. (Che cos'è quella classe dipende dal programma, è impossibile dire dalle informazioni che hai fornito).

In alternativa, puoi usare maven-assembly-plugin, come mostrato nell'esempio seguente:

<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 questo esempio tutti i barattoli delle dipendenze, come specificato nella sezione, verranno automaticamente inclusi nel tuo singolo vaso. Si noti che jar-with-dependencies deve essere letteralmente messo come, per non essere sostituito con i nomi dei file jar che si desidera includere.

Questo perché Java non riesce a trovare l'attributo Main nel file MANIFEST.MF. L'attributo Main è necessario per indicare a java quale classe dovrebbe usare come punto di ingresso dell'applicazione. All'interno del file jar, il file MANIFEST.MF si trova nella cartella META-INF. Ti chiedi come potresti vedere cosa c'è dentro un file jar? Apri il file jar con WinRAR.

L'attributo principale all'interno di MANIFEST.MF è simile al seguente:

Main-Class: <packagename>.<classname>

Questo errore "nessun attributo manifest principale" viene visualizzato quando manca questa riga dal file MANIFEST.MF.

È davvero un gran casino specificare questo attributo all'interno del file MANIFEST.MF.

Aggiornamento: ho appena trovato un modo davvero accurato per specificare il punto di ingresso dell'applicazione in eclipse. Quando dici Esporta,

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.

Ho avuto lo stesso problema. aggiungendo le seguenti righe al file pom lo ha fatto funzionare. Il plugin assicurerà il processo di compilazione della tua applicazione con tutti i passaggi necessari.

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

La risposta di Gradle è aggiungere un'impostazione jar / manifest / attributi come questa:

apply plugin: 'java'

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

Ho riscontrato questo problema durante la creazione di un vaso con IntelliJ IDEA. Vedere questa discussione .

Ciò che mi ha risolto è stato ricreare l'artefatto jar, scegliendo JAR> Da moduli con dipendenze, ma non accettando la Directory predefinita per META-INF / MANIFEST.MF. Modificalo da - / src / main / java a - / src / main / resources.

Altrimenti includeva un file manifest nel vaso, ma non quello in - / src / main / java che avrebbe dovuto avere.

Per Maven, questo è ciò che ha risolto (per me, per una base di codice Veetle su 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>

Saluti...

Prova questo comando per includere il vaso:

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

Per me nessuna delle risposte mi è stata di grande aiuto: avevo il file manifest nella posizione corretta, contenente la Main-Class e tutto il resto. Ciò che mi ha inciampato è stato questo:

Avviso: il file di testo da cui si sta creando il manifest deve terminare con una nuova riga o ritorno a capo. L'ultima riga non verrà analizzata correttamente se non termina con una nuova riga o ritorno a capo.

( fonte ). Aggiunta di una nuova riga alla fine del manifest risolto.

Se si utilizza Maven, includere quanto segue nel 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>

Ho avuto lo stesso problema oggi. Il mio problema è stato risolto spostando META-INF nella cartella delle risorse.

Ho avuto lo stesso errore proprio ora. Se stai usando gradle, aggiungi il prossimo in ur gradle.build:

apply plugin: 'java'

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

Dove com.company.project.MainClasspercorso per la tua classe con il public static void main(String[] args)metodo.

Il problema di MAVEN è che cerca di includere il primo file MANIFEST.MF dalla prima libreria dalle dipendenze invece di THE OWN OWN MANIFEST.MF QUANDO USATE ARTIFACTS! .

1. Rinomina yourjar.jar in yourjar.zip
2. Aprire il file MANIFEST.MF da META-INF \ MANIFEST.MF

3. Copia il vero MANIFEST.MF che già genera nel tuo progetto di MAVEN Che include qualcosa come:

   Manifest-Version: 1.0 Classe principale: yourpacket.yourmainclass (per exmaple info.data.MainClass)

4. Sostituisci il contenuto di MANIFEST.MF da youjar.zip con esso.

5. Rinomina yourjar.zip in yourjar.jar indietro.
6. Ora java -jar yourjar.jar funziona perfettamente.

O!

Semplice crea il tuo MANIFEST.MF e:

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

Ma se usi il pannello maven (o la riga di comando di maven) puoi forzarlo a generare il proprio manifest e includerlo nel file JAR.

1. Aggiungi alla sezione build di te pom.xml questo codice:

   <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. Aprire il pannello MAVEN (in Intellij) ed eseguire "Installa". Genererà il file MANIFEST e compilerà la proprietà del file JAR con tutte le dipendenze nella cartella "Target". Inoltre verrà installato nel repository maven locale.

Se il vaso non segue le regole , non è un vaso eseguibile.

Ho riscontrato lo stesso problema e ora è stato risolto :) Basta seguire i passaggi seguenti e l'errore potrebbe essere per qualsiasi cosa, ma i passaggi seguenti rendono il processo più fluido. Trascorro molto tempo per trovare la soluzione.

1. Prova a riavviare Eclipse (se stai usando Eclipse per creare il file JAR) -> In realtà questo ha aiutato il mio problema nell'esportazione del file JAR correttamente.

2.Dopo il riavvio di eclipse, prova a vedere se eclipse è in grado di riconoscere la classe / il metodo principale dal tuo progetto Java -> tasto destro -> Esegui come -> Esegui configurazioni -> Principale -> fai clic sul pulsante Cerca per vedere se la tua eclisse è in grado di cercare la tua classe principale nel file JAR. -> Questo è per la convalida che il file JAR avrà il punto di ingresso alla classe principale.

4. Successivamente, esportare il progetto Java Dynamic come file "Runnable JAR" e non come file JAR.

5. Nella configurazione di avvio Java, scegli la tua classe principale.

6. Una volta esportato il file jar, utilizzare il comando seguente per eseguire. java -cp [Your JAR] .jar [pacchetto completo] .MainClass ad es .: java -cp AppleTCRuleAudit.jar com.apple.tcruleaudit.classes.TCRuleAudit

7. Potresti riscontrare l'errore della versione java non supportata. la soluzione è cambiare java_home nel profilo bash della shell in modo che corrisponda alla versione java utilizzata per compilare il progetto in eclipse.

Spero che sia di aiuto! Fammi sapere se hai ancora problemi.

Ho avuto lo stesso problema. Molte delle soluzioni menzionate qui non mi hanno fornito il quadro completo, quindi proverò a darti un riepilogo di come impacchettare i file jar dalla riga di comando .

1. Se vuoi avere i tuoi .classfile nei pacchetti, aggiungi il pacchetto all'inizio di .java.

   Test.java

   package testpackage;
   
   public class Test
   {
       ...
   }

2. Per compilare il codice con i .classfile che finiscono con la struttura fornita dal nome del pacchetto, utilizzare:

   javac -d . Test.java

   La -d .fa il compilatore creare la struttura di directory che si desidera.

3. Quando .jarsi comprime il file, è necessario istruire la routine jar su come impacchettarlo. Qui usiamo il set di opzioni cvfeP. Questo per mantenere la struttura del pacchetto (opzione P), specificare il punto di ingresso in modo che il file manifest contenga informazioni significative (opzione e). L'opzione fconsente di specificare il nome del file, l'opzione ccrea un archivio e l'opzione vimposta l'output su dettagliato. Le cose importanti da notare qui sono Pe e.

   Quindi viene il nome del barattolo che vogliamo test.jar.

   Quindi arriva il punto di ingresso.

   E poi arriva -C . <packagename>/per ottenere i file di classe da quella cartella, preservando la struttura delle cartelle.

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

4. Controlla il tuo .jarfile in un programma zip. Dovrebbe avere la seguente struttura

   test.jar

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

   MANIFEST.MF dovrebbe contenere quanto segue

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

   Se modifichi il tuo manifest a mano, assicurati di mantenere la nuova riga alla fine, altrimenti Java non lo riconosce.

5. Esegui il tuo .jarfile con

   java -jar test.jar

Personalmente penso che tutte le risposte qui siano fraintendendo la domanda. La risposta a questo sta nella differenza di come Spring-Boot costruisce il file .jar. Tutti sanno che Spring Boot imposta un manifest come questo, che varia dal presupposto di tutti che si tratta di un lancio .jar standard, che può essere o meno:

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

Forse deve essere eseguito con org.springframework.boot.loader.JarLaunchersul percorso di classe?

Qualsiasi file jar eseguibile Dovrebbe essere eseguito facendo clic o eseguendo utilizzando il prompt dei comandi come java -jar app.jar (utilizzare "se il percorso del vaso contiene spazio" - ovvero java -jar "C: \ nome cartella \ app.jar"). Se il tuo vaso eseguibile non è in esecuzione, significa che non è stato creato correttamente.

Per una migliore comprensione, estrarre il file jar (o visualizzarlo con qualsiasi strumento, per Windows 7-Zip è bello) e controllare il file in /META-INF/MANIFEST.MF. Se trovi una voce simile

Classe principale: your.package.name.ClaaswithMain - quindi va bene, altrimenti devi fornirlo.

Fai attenzione ad aggiungere una voce di classe principale al file MANIFEST.MF, controlla dove lo stai salvando!

Puoi semplicemente seguire questo passaggio Crea un file jar usando

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

Durante l'esecuzione del file jar, esegui semplicemente in questo modo

 java -cp jarfile-name main-classname

Potresti non aver creato correttamente il file jar:

es: opzione mancante m nella creazione del vaso

Le seguenti opere:

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

Se si utilizza la riga di comando per assemblare .jar è possibile puntare al principale senza aggiungere il file manifest. Esempio:

jar cfve app.jar TheNameOfClassWithMainMethod *.class

(param "e" lo fa: TheNameOfClassWithMainMethod è un nome della classe con il metodo main () e app.jar - nome dell'eseguibile .jar e * .class - solo tutti i file delle classi da assemblare)

Per me questo errore si è verificato semplicemente perché ho dimenticato di dire a Eclipse che volevo un file jar eseguibile e non un semplice file jar della libreria. Quindi quando crei il file jar in Eclipse assicurati di fare clic sul pulsante di opzione destro

Le risposte di cui sopra sono state solo parzialmente utili per me. java -cpfaceva parte della risposta, ma avevo bisogno di informazioni più specifiche su come identificare la classe da eseguire. Ecco cosa ha funzionato per me:

Passaggio 1: trova la classe che devo eseguire

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

Le prime linee del risultato sono state:

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

App.class conteneva la classe principale da eseguire. Non sono sicuro al 100% se puoi sempre presumere che la classe di cui hai bisogno sia la prima, ma è stata per me. In caso contrario, immagino che non sia troppo difficile usare grep per escludere i risultati relativi alla libreria per ridurre l'elenco delle classi a una dimensione gestibile.

Da lì è stato facile: uso solo quel percorso (meno il suffisso ".class"):

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

Dato che hai aggiunto MANIFEST.MF, penso che dovresti considerare l'ordine di Field in questo file. Il mio env è java version "1.8.0_91"

e il mio MANIFEST.MF come qui

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

Tuttavia, come indicato di seguito

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

//this run swing normally

(primo post - quindi potrebbe non essere pulito)

Questa è la mia soluzione per OS X 11.6, programma Netbeans 8.2 basato su Maven. Fino ad ora la mia app è Netbeans al 100% - nessuna modifica (solo poche shell scappano per l'impossibile!).

Avendo provato la maggior parte delle risposte qui e altrove senza risultati, sono tornato all'arte di "usare ciò che funziona".

La risposta migliore qui ( olivier-refalo thanx) sembrava il posto giusto per iniziare ma non ha aiutato.

Guardando altri progetti che hanno funzionato, ho notato alcune differenze minori nelle linee manifest:

1. addClasspath, classpathPrefix erano assenti (eliminati)
2. mainClass mancava la "com". (usato NB -> Proprietà progetto-> Esegui-> Classe principale-> Sfoglia per specificare)

Non so perché (sono solo 3 mesi in Java) o come, ma posso solo dire che ha funzionato.

Ecco solo il blocco manifest modificato utilizzato:

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

Ho trovato una nuova soluzione per una cattiva generazione manifest!

1. Apri il file jar con un editor zip come WinRAR

2. Fare clic su per META-INF

3. Aggiungi o modifica

   • Inserisci:

     • Creare un file di testo chiamato MANIFEST.MF in una cartella denominata META-INF e aggiungere la seguente riga:

       • Versione manifest: 1.0
       • Classe principale: package.ex.com.views.mainClassName

     • Salva il file e aggiungilo allo zip

   • Modificare:

     • Trascina il file fuori modifica MANIFEST.MF per aggiungere la riga precedente

4. Apri cmd e digita: java -jar c: /path/JarName.jar

Dovrebbe funzionare bene ora!

la maggior parte delle soluzioni non ha funzionato per me, ma il mio istruttore mi ha aiutato, vorrei condividere la sua soluzione qui ho usato il terminale kali linux, ma dovrebbe andare bene in tutti i debian

javac *.java
nano MANIFEST.MF

nel tipo di file

Classe principale: principale o qualunque sia il nome del tuo file principale (assicurati di aggiungere il nome del pacchetto se esiste)

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

ora per eseguire l'uso del file

java -jar new.jar

oppure puoi andare alle proprietà del file e controllare

Consenti esecuzione file come programma

fare doppio clic su di esso

mi ha aiutato mentre la maggior parte delle risposte di cui sopra non lo ha fatto

Potresti avere lo stesso problema. Dopo aver creato il tuo file .jar, scrivi jar xf app.jar META-INF/MANIFEST.MF. Ciò creerà una copia del file nella directory corrente in modo da poterlo leggere. Se dice solo qualcosa del tipo:

Versione manifest: 1.0

Creato da: 1.8.0_51 (Oracle Corporation)

e non contiene la dichiarazione "Classe principale", quindi penso che tu abbia riscontrato il tuo problema.

Non so come risolverlo, però. Ho controllato altre persone con problemi uguali / simili su StackOverflow e non sono riuscito a trovare una risposta. Tuttavia, con queste informazioni potresti forse ottenere un aiuto migliore (dato che hai lo stesso problema di me).

Modifica: avevo provato con un file manifest ma non riuscivo a farlo funzionare, ma il mio errore era di nominare solo una delle classi durante la creazione del file jar. Ho scritto * .class invece e ora funziona.

Anche se non so perché sia ​​necessario creare un file manifest. Ma immagino che vada bene finché funziona.

Ho avuto questo problema e l'ho risolto di recente eseguendo questa operazione in Netbeans 8 (fare riferimento all'immagine seguente):

1. vai alle proprietà del tuo progetto.
2. fai clic su Esegui .
3. specifica la classe principale del tuo progetto usando sfoglia .
4. costruire ed eseguire il file jar.