Imansible eseguire jar-file: “nessun attributo manifest principale”

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

java-jar “app.jar”

Ottengo il seguente messaggio:

nessun attributo manifest principale, in “app.jar”

Normalmente, se avessi creato il programma da solo, avrei aggiunto un attributo di class principale al file manifest. Ma in questo caso, poiché il file proviene da un’applicazione, non posso farlo. Ho anche provato ad estrarre il barattolo per vedere se riuscivo a trovare la class principale, ma ci sono molte classi e nessuna ha la parola “main” nel suo nome. Ci deve essere un modo per risolvere questo problema perché il programma funziona bene su altri sistemi.

Innanzitutto, è java -jar "app" strano vedere che java -jar "app" java -jar app.jar e non java -jar app.jar

In secondo luogo, per rendere un eseguibile jar … devi jar un file chiamato META-INF / MANIFEST.MF

il file stesso dovrebbe avere (almeno) questo rivestimento:

 Main-Class: com.mypackage.MyClass 

Dove com.mypackage.MyClass è la class che detiene il punto di ingresso statico void principale (String [] args) .

Tieni presente che esistono diversi modi per eseguire questa operazione con CLI, Maven, Ant o Gradle:

Per CLI , eseguirà il seguente comando: (tks @ dvvrt ) jar cmvf META-INF/MANIFEST.MF .jar

Per Maven , qualcosa come il seguente frammento dovrebbe fare il trucco. Nota che questa è solo la definizione del plugin, non il completo pom.xml :

     org.apache.maven.plugins maven-jar-plugin 3.1.0    true lib/ com.mypackage.MyClass       

(Scegli una appropriata per il tuo progetto.)

Per Ant , il frammento di seguito dovrebbe aiutare:

        

Crediti Michael Niemand –

Per Gradle :

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

Avrebbe dovuto essere java -jar app.jar invece di java -jar "app" .

L’opzione -jar funziona solo se il file JAR è un file JAR eseguibile, il che significa che deve avere un file manifest con un attributo Main-Class in esso. Vedere Programmi di imballaggio in file JAR per informazioni su come creare un JAR eseguibile.

Se non è un JAR eseguibile, è necessario eseguire il programma con qualcosa di simile:

 java -cp app.jar com.somepackage.SomeClass 

dove com.somepackage.SomeClass è la class che contiene il metodo main per eseguire il programma. (Ciò che questa class dipende dal programma, è imansible da capire dalle informazioni che hai fornito).

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

  maven-assembly-plugin   package  single       true com.package.MainClass    jar-with-dependencies    

In questo esempio tutti i barattivi delle dipendenze come specificato nella sezione verranno automaticamente inclusi nel tuo singolo jar. Si noti che jar-with-dependencies dovrebbe essere letteralmente messo come, non per 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 dire a java quale class deve 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 ha il seguente aspetto:

 Main-Class: . 

Si ottiene questo errore “nessun attributo manifest principale” 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 Export,

 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. 

inserisci la descrizione dell'immagine qui

La risposta di Gradle è di aggiungere un’impostazione jar / manifest / attributes in questo modo:

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

Prova questo comando per includere il barattolo:

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

Per Maven, questo è quello che l’ha risolto (per me, per un codebase di Veetle su GitHub):

    org.apache.maven.plugins maven-shade-plugin 2.0   package  shade     org.lazydevs.veetle.api.VeetleAPI         

Saluti…

Ho riscontrato questo problema durante la creazione di un jar con IntelliJ IDEA. Vedi questa discussione .

Quello che mi ha risolto è stato ricreare l’artefatto del jar, scegliendo JAR> Dai moduli con dipendenze, ma non accettando la Directory predefinita per META-INF / MANIFEST.MF. Cambialo da – / src / main / java a – / src / main / resources.

Altrimenti includeva un file manifest nel jar, ma non quello in – / src / main / java che avrebbe dovuto.

Per me, nessuna delle risposte mi è stata di aiuto: avevo il file manifest nel posto giusto, contenente la Main-Class e tutto il resto. Ciò che mi ha fatto inciampare è stato questo:

Avvertenza: il file di testo dal quale si sta creando il manifest deve terminare con una nuova riga o un ritorno a capo. L’ultima riga non verrà analizzata correttamente se non termina con una nuova riga o un ritorno a capo.

( fonte ). Aggiungendo una nuova riga alla fine del manifest l’ha risolto.

Se si utilizza Maven, includere i seguenti nel pom

  org.springframework.boot spring-boot-starter-parent 1.4.2.RELEASE   1.8     org.springframework.boot spring-boot-maven-plugin    

Ho ricevuto lo stesso errore proprio ora. Se gradle usando gradle , aggiungi il prossimo nel tuo gradle.build :

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

Dove com.company.project.MainClass path to ur class con il metodo public static void main(String[] args) .

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

    org.springframework.boot spring-boot-maven-plugin    

Se il jar non sta seguendo le regole , non è un jar eseguibile.

Ho affrontato lo stesso problema ed è risolto ora 🙂 Basta seguire i passaggi di seguito e l’errore potrebbe essere per qualsiasi cosa, ma i passaggi di seguito rendono il processo più agevole. Trascorro molto tempo per trovare la soluzione.

1.Prova a riavviare Eclipse (se utilizzi 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 class / il metodo principale dal tuo progetto Java -> fai clic con il pulsante destro del mouse -> Esegui come -> Esegui configurazioni -> Principale -> fai clic sul pulsante Cerca per vedere se la tua eclipse è in grado di cercare la tua class principale nel file JAR. -> Questo è per la convalida che il file JAR avrà il punto di ingresso alla class principale.

  1. Successivamente, esportare il progetto Java Dynamic come file “JN eseguibile” e non il file JAR.

  2. Nella configurazione di avvio di Java, scegli la tua class principale.

  3. Una volta esportato il file jar, utilizzare il comando seguente per eseguire. java -cp [Il tuo JAR] .jar [pacchetto completo]. MainClass ad esempio: java -cp AppleTCRuleAudit.jar com.apple.tcruleaudit.classs.TCRuleAudit

  4. Potresti dover affrontare l’errore di versione java non supportato. la soluzione è cambiare la java_home nel tuo profilo bash della shell in modo che corrisponda alla versione java utilizzata per compilare il progetto in eclipse.

Spero che questo ti aiuti! Gentilmente fammi sapere se hai ancora problemi.

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

Qualsiasi file jar eseguibile deve essere eseguito facendo clic o eseguendo il prompt dei comandi come java -jar app.jar (utilizzare “se il percorso di jar contiene spazio”, ad esempio java-jar “C: \ nome cartella \ app.jar”). Se il tuo jar eseguibile non è in esecuzione, il che significa che non è stato creato correttamente.

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

Main-Class: your.package.name.ClaaswithMain – allora va bene, altrimenti devi fornirlo.

Essere consapevoli di aggiungere la voce Main-Class sul file MANIFEST.MF, controllare dove lo si sta salvando!

Puoi semplicemente seguire questo passaggio Creare un file jar usando

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

Durante l’esecuzione del file jar, esegui una corsa semplice come questa

  java -cp jarfile-name main-classname 

Potresti non aver creato correttamente il file jar:

ex: opzione mancante m nella creazione del jar

I seguenti lavori:

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

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. Pertanto, quando crei il file jar in Eclipse, assicurati di fare clic sul pulsante di opzione corretto

Personalmente penso che tutte le risposte qui siano sbagliate a capire la domanda. La risposta a questo sta nella differenza di come spring-boot costruisce il .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 non essere:

 Start-Class: com.myco.eventlogging.MyService Spring-Boot-Classes: BOOT-INF/classs/ 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.JarLauncher sul classpath?

Ho avuto lo stesso problema. Molte delle soluzioni qui menzionate non mi hanno dato l’intera immagine, quindi cercherò di darti un riassunto su come impacchettare i file jar dalla riga di comando .

  1. Se vuoi avere i tuoi file .class nei pacchetti, aggiungi il pacchetto all’inizio di .java .

    Test.java

     package testpackage; public class Test { ... } 
  2. Per compilare il tuo codice con i tuoi file .class finiscono con la struttura data dal nome del pacchetto usa:

     javac -d . Test.java 

    Il -d . fa in modo che il compilatore crei la struttura di directory che desideri.

  3. Quando si .jar file .jar , è necessario istruire la routine jar su come imballarla. Qui usiamo l’opzione set 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 f consente di specificare il nome del file, l’opzione c crea un archivio e l’opzione v imposta l’output su dettagliato. Le cose importanti da notare qui sono P ed e .

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

    Quindi arriva il punto di ingresso.

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

     jar cvfeP test.jar testpackage.Test -C . testpackage/ 
  4. Controlla il tuo file .jar 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:  (Oracle Corporation) Main-Class: testpackage.Test 

    Se modifichi il tuo manifest a mano assicurati di mantenere il newline alla fine altrimenti java non lo riconosce.

  5. Esegui il tuo file .jar con

     java -jar test.jar 

Dato che hai aggiunto MANIFEST.MF, penso che dovresti considerare l’ordine di campo in questo file. Il mio env è la 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, questo come sotto scorre attraverso

 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 correzione per OS X 11.6, programma Netbeans 8.2 basato su Maven. Fino ad ora la mia app è al 100% Netbeans – nessun tweaking (solo poche shell escapes per l’imansible!).

Avendo provato la maggior parte delle risposte qui e altrove inutilmente, 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 piccole differenze nelle linee manifest:

  1. addClasspath, classpathPrefix erano assenti (cancellati)
  2. mainClass mancava il “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 usato:

   mypackage.MyClass  

Ho trovato una nuova soluzione per la ctriggers 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 manifesta: 1.0
        • Main-Class: package.ex.com.views.mainClassName
      • Salva il file e aggiungilo allo zip

    • Modificare:

      • Trascina il file e modifica MANIFEST.MF per aggiungere la riga precedente
  4. Aprire cmd e digitare: java -jar c: /path/JarName.jar

Dovrebbe funzionare bene ora!

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

Passaggio 1: trova la class 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 class principale da eseguire. Non sono sicuro al 100% se puoi sempre presumere che la class di cui hai bisogno è la prima, ma era per me. Se non lo è, immagino che non sia troppo difficile usare grep per escludere i risultati relativi alle librerie per ridurre l’elenco delle classi a una dimensione gestibile.

Da lì è stato facile: utilizzo solo quel percorso (meno il suffisso “.class”):

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

Ho avuto questo problema e l’ho risolto di recente facendo ciò in Netbeans 8 (fare riferimento all’immagine seguente):

Proprietà del progetto Netbeans

  1. vai alle proprietà del tuo progetto.
  2. clicca su Esegui .
  3. specifica la class principale del tuo progetto usando browse .
  4. costruisci ed esegui il file Jar.

Potresti avere lo stesso problema di me. Dopo aver creato il tuo file .jar, scrivi jar xf app.jar META-INF/MANIFEST.MF . Questo creerà una copia del file nella directory corrente in modo che tu possa leggerlo. Se dice solo qualcosa del tipo:

Versione manifesta: 1.0

Creato da: 1.8.0_51 (Oracle Corporation)

e non contiene la dichiarazione “Main-Class”, quindi penso che tu abbia trovato il tuo problema.

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

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

Anche se non so perché c’è bisogno di creare un file manifest. Ma suppongo che vada bene finché funziona.

Controlla la tua directory locale .m2 per una sottodirectory di questo artefatto. Se exixts: cancellalo ed esegui di nuovo l’aggiornamento di Maven

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

 jar cfve app.jar TheNameOfClassWithMainMethod *.class 

(param “e” fa questo: TheNameOfClassWithMainMethod è un nome della class con il metodo main () e app.jar – nome di executable .jar e * .class – solo tutti i file di classi da assemblare)

controlla il tuo file jar all’interno di MANIFEST.MF Main-Class è disponibile o meno

first.java

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

Prima :

 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 

Dopo:

 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