No se puede ejecutar el archivo jar: "sin atributo de manifiesto principal"

He instalado una aplicación, cuando intento ejecutarla (es un archivo ejecutable) no pasa nada. Cuando lo ejecuto desde la línea de comandos con:

java -jar "app.jar"

Me sale el siguiente mensaje:

sin atributo manifiesto principal, en "app.jar"

Normalmente, si hubiera creado el programa yo mismo, habría agregado un atributo de clase principal al archivo de manifiesto. Pero en este caso, dado que el archivo es de una aplicación, no puedo hacer eso. También intenté extraer el frasco para ver si podía encontrar la clase principal, pero hay muchas clases y ninguna de ellas tiene la palabra "principal" en su nombre. Debe haber una manera de arreglar esto porque el programa funciona bien en otros sistemas.

Primero, es un poco extraño verte correr java -jar "app"y nojava -jar app.jar

En segundo lugar, para hacer que un jar sea ejecutable ... necesita jar un archivo llamado META-INF / MANIFEST.MF

el archivo en sí debería tener (al menos) este revestimiento:

Main-Class: com.mypackage.MyClass

¿Dónde com.mypackage.MyClassestá la clase que contiene el punto de entrada public static void main (String [] args) ?

Tenga en cuenta que hay varias formas de hacerlo, ya sea con la CLI, Maven, Ant o Gradle:

Para CLI , el siguiente comando servirá: ( tks @ dvvrt ) jar cmvf META-INF/MANIFEST.MF <new-jar-filename>.jar <files to include>

Para Maven , algo como el siguiente fragmento debería hacer el truco. Tenga en cuenta que esta es solo la definición del complemento, no el 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>

(Elija un <version>apropiado para su proyecto).

Para Ant , el fragmento a continuación debería ayudar:

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

Créditos Michael Niemand -

Para Gradle :

plugins {
    id 'java'
}

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

Eso debería haber sido en java -jar app.jarlugar de java -jar "app".

La -jaropción solo funciona si el archivo JAR es un archivo JAR ejecutable, lo que significa que debe tener un archivo de manifiesto con un Main-Classatributo. Consulte Programas de empaquetado en archivos JAR para aprender a crear un JAR ejecutable.

Si no es un JAR ejecutable, deberá ejecutar el programa con algo como:

java -cp app.jar com.somepackage.SomeClass

donde com.somepackage.SomeClasses la clase que contiene el mainmétodo para ejecutar el programa. (Lo que es esa clase depende del programa, es imposible saber de la información que ha proporcionado).

Alternativamente, puede usar maven-assembly-plugin, como se muestra en el siguiente ejemplo:

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

En este ejemplo, todos los archivos jar de dependencia como se especifica en la sección se incluirán automáticamente en su archivo jar individual. Tenga en cuenta que jar-with-dependencies se debe poner literalmente como, no se debe reemplazar con los nombres de archivo jar que desea incluir.

Esto se debe a que Java no puede encontrar el atributo Main en el archivo MANIFEST.MF. El atributo Main es necesario para indicarle a Java qué clase debe usar como punto de entrada de la aplicación. Dentro del archivo jar, el archivo MANIFEST.MF se encuentra en la carpeta META-INF. ¿Te preguntas cómo puedes ver lo que hay dentro de un archivo jar? Abra el archivo jar con WinRAR.

El atributo principal dentro del MANIFEST.MF se ve así:

Main-Class: <packagename>.<classname>

Obtiene este error "sin atributo de manifiesto principal" cuando falta esta línea en el archivo MANIFEST.MF.

Es realmente un gran desastre especificar este atributo dentro del archivo MANIFEST.MF.

Actualización: acabo de encontrar una manera muy clara de especificar el punto de entrada de la aplicación en eclipse. Cuando dices Exportar,

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.

Tuve el mismo problema. agregando las siguientes líneas al archivo pom lo hizo funcionar. El complemento se asegurará del proceso de compilación de su aplicación con todos los pasos necesarios.

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

La respuesta de Gradle es agregar una configuración jar / manifest / atributos como esta:

apply plugin: 'java'

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

Tuve este problema al crear un jar usando IntelliJ IDEA. Ver esta discusión .

Lo que me resolvió fue volver a crear el artefacto jar, eligiendo JAR> De los módulos con dependencias, pero sin aceptar el Directorio predeterminado para META-INF / MANIFEST.MF. Cámbielo de - / src / main / java a - / src / main / resources.

De lo contrario, incluía un archivo de manifiesto en el archivo jar, pero no el de - / src / main / java que debería tener.

Para Maven, esto es lo que lo resolvió (para mí, para una base de código Veetle en 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>

Salud...

Pruebe este comando para incluir el jar:

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

Para mí, ninguna de las respuestas realmente ayudó: tenía el archivo de manifiesto en el lugar correcto, que contenía la clase principal y todo. Lo que me hizo tropezar fue esto:

Advertencia: el archivo de texto desde el que está creando el manifiesto debe terminar con una nueva línea o retorno de carro. La última línea no se analizará correctamente si no termina con una nueva línea o retorno de carro.

( fuente ) Agregar una nueva línea al final del manifiesto lo arregló.

Si usa Maven, incluya lo siguiente en el 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>

Tuve el mismo problema hoy. Mi problema se resolvió al mover META-INF a la carpeta de recursos.

Tengo el mismo error en este momento. Si está utilizando gradle, simplemente agregue el siguiente en su ur gradle.build:

apply plugin: 'java'

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

Donde com.company.project.MainClasscamino a su clase con public static void main(String[] args)método.

¡El problema de MAVEN es que intenta incluir el primer archivo MANIFEST.MF de la primera biblioteca de dependencias en lugar de THE OWN DOWN MANIFEST.MF CUANDO UTILIZA ARTEFACTOS! .

1. Cambie el nombre de yourjar.jar a yourjar.zip
2. Abra el archivo MANIFEST.MF desde META-INF \ MANIFEST.MF

3. Copie el MANIFEST.MF real que ya genera MAVEN en su proyecto, que incluye algunos que:

   Versión de manifiesto: 1.0 Main-Class: yourpacket.yourmainclass (para exmaple info.data.MainClass)

4. Reemplace el contenido de MANIFEST.MF de youjar.zip con él.

5. Cambia el nombre de yourjar.zip a yourjar.jar.
6. Ahora java -jar yourjar.jar funciona perfectamente.

¡O!

Simple crea tu propio MANIFEST.MF y:

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

Pero si usa el panel maven (o la línea de comando maven) puede forzarlo a generar su propio manifiesto e incluirlo en el archivo JAR.

1. Agregue a la sección de compilación de you pom.xml este código:

   <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. Abra el panel MAVEN (en Intellij) y ejecute "Instalar". Generará el archivo MANIFEST y compilará la propiedad del archivo JAR con todas las dependencias en la carpeta "Target". También se instalará en el repositorio local de Maven.

Si el jar no sigue las reglas , no es un jar ejecutable.

Me enfrenté al mismo problema y ahora está solucionado :) Simplemente siga los pasos a continuación y el error podría ser cualquier cosa, pero los pasos a continuación hacen que el proceso sea más fluido. Paso mucho tiempo para encontrar la solución.

1. Intente reiniciar Eclipse (si está utilizando Eclipse para construir un archivo JAR) -> En realidad, esto ayudó a mi problema al exportar el archivo JAR correctamente.

2.Después de reiniciar el eclipse, intente ver si su eclipse puede reconocer la clase / método principal por su proyecto Java -> haga clic con el botón derecho -> Ejecutar como -> Ejecutar configuraciones -> Principal -> haga clic en el botón Buscar para ver si su eclipse puede buscar su clase principal en el archivo JAR. -> Esto es para la validación de que el archivo JAR tendrá el punto de entrada a la clase principal.

4. Después de esto, exporte su proyecto dinámico de Java como archivo "JAR ejecutable" y no como archivo JAR.

5. En la configuración de inicio de Java, elija su clase principal.

6. Una vez que exporte el archivo jar, utilice el siguiente comando para ejecutar. java -cp [Your JAR] .jar [paquete completo] .MainClass por ejemplo: java -cp AppleTCRuleAudit.jar com.apple.tcruleaudit.classes.TCRuleAudit

7. Puede enfrentar el error de versión de Java no compatible. la solución es cambiar java_home en su perfil bash de shell para que coincida con la versión de java utilizada para compilar el proyecto en eclipse.

¡Espero que esto ayude! Por favor, avíseme si todavía tiene algún problema.

Yo tuve el mismo problema. Muchas de las soluciones mencionadas aquí no me dieron la imagen completa, así que intentaré darle un resumen de cómo empaquetar archivos jar desde la línea de comandos .

1. Si desea tener sus .classarchivos en paquetes, agregue el paquete al comienzo de.java .

   Test.java

   package testpackage;
   
   public class Test
   {
       ...
   }

2. Para compilar su código con sus .classarchivos que terminan con la estructura dada por el nombre del paquete, use:

   javac -d . Test.java

   los -d . hace que el compilador cree la estructura de directorios que desea.

3. Al empaquetar el .jararchivo, debe instruir a la rutina jar sobre cómo empacarlo. Aquí usamos el conjunto de opciones cvfeP. Esto es para mantener la estructura del paquete (opción P), especificar el punto de entrada para que el archivo de manifiesto contenga información significativa (opción e). La opción le fpermite especificar el nombre del archivo, la opción ccrea un archivo comprimido y la opción vestablece el resultado en detallado. Las cosas importantes a tener en cuenta aquí son Pye .

   Luego viene el nombre de la jarra que queremos test.jar .

   Luego viene el punto de entrada.

   Y luego viene -C . <packagename>/a obtener los archivos de clase de esa carpeta, preservando la estructura de la carpeta.

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

4. Verifique su .jararchivo en un programa zip. Debe tener la siguiente estructura

   test.jar

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

   El MANIFEST.MF debe contener lo siguiente

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

   Si edita su manifiesto a mano, asegúrese de mantener la nueva línea al final; de lo contrario, Java no la reconocerá.

5. Ejecute su .jararchivo con

   java -jar test.jar

Personalmente, creo que todas las respuestas aquí son una mala comprensión de la pregunta. La respuesta a esto radica en la diferencia de cómo spring-boot construye el .jar. Todo el mundo sabe que Spring Boot establece un manifiesto como este, que varía de la suposición de todos de que se trata de un lanzamiento .jar estándar, que puede o no ser:

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

Quizás necesita ejecutarse con org.springframework.boot.loader.JarLauncheren el classpath?

Cualquier archivo jar ejecutable debe ejecutarse haciendo clic o ejecutando mediante el símbolo del sistema como java -jar app.jar (use "si la ruta del jar contiene espacio", es decir, java -jar "C: \ nombre de carpeta \ app.jar"). Si su jar ejecutable no se está ejecutando, lo que significa que no se creó correctamente.

Para una mejor comprensión, extraiga el archivo jar (o visualice con cualquier herramienta, para Windows 7-Zip es bueno) y verifique el archivo en /META-INF/MANIFEST.MF. Si encuentras alguna entrada como

Main-Class: your.package.name.ClaaswithMain, entonces está bien, de lo contrario, debe proporcionarlo.

Tenga en cuenta la entrada de clase principal adjunta en el archivo MANIFEST.MF, compruebe dónde la está guardando.

Simplemente puede seguir este paso Crear un archivo jar usando

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

Mientras ejecuta el archivo jar, simplemente ejecute así

 java -cp jarfile-name main-classname

Es posible que no haya creado el archivo jar correctamente:

Ej: falta la opción m en la creación de jarras

Los siguientes trabajos:

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

Si está utilizando la línea de comando para ensamblar .jar, es posible apuntar a main sin agregar el archivo Manifiesto. Ejemplo:

jar cfve app.jar TheNameOfClassWithMainMethod *.class

(el parámetro "e" hace eso: TheNameOfClassWithMainMethod es un nombre de la clase con el método main () y app.jar - nombre del ejecutable .jar y * .class - solo todos los archivos de clases para ensamblar)

Para mí, este error ocurrió simplemente porque olvidé decirle a Eclipse que quería un archivo jar ejecutable y no un simple archivo jar de biblioteca. Entonces, cuando cree el archivo jar en Eclipse, asegúrese de hacer clic en el botón de opción derecho

Las respuestas anteriores fueron solo parcialmente útiles para mí. java -cpera parte de la respuesta, pero necesitaba información más específica sobre cómo identificar la clase a ejecutar. Esto es lo que funcionó para mí:

Paso 1: encuentre la clase que necesito ejecutar

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

Las líneas superiores del resultado fueron:

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

App.class contenía la clase principal para ejecutar. No estoy 100% seguro de si siempre puedes asumir que la clase que necesitas es la primera, pero fue para mí. Si no es así, me imagino que no es demasiado difícil usar grep para excluir los resultados relacionados con la biblioteca para reducir la lista de clases a un tamaño manejable.

A partir de ahí fue fácil: solo uso esa ruta (menos el sufijo ".class"):

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

Como ha agregado MANIFEST.MF, creo que debería considerar el orden de Field en este archivo. Mi env es java version "1.8.0_91"

y mi MANIFEST.MF como aquí

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

Sin embargo, esto como a continuación se ejecuta a través de

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

//this run swing normally

(primer mensaje, por lo que puede que no esté limpio)

Esta es mi solución para OS X 11.6, el programa Netbeans 8.2 basado en Maven. Hasta ahora, mi aplicación es 100% Netbeans, sin ajustes (¡solo unos pocos escapes de shell para lo imposible!).

Después de haber probado la mayoría de las respuestas aquí y en otros lugares en vano, volví al arte de "usar lo que funciona".

La respuesta principal aquí ( olivier-refalo ) parecía el lugar correcto para comenzar, pero no ayudó.

Al observar otros proyectos que funcionaron, noté algunas diferencias menores en las líneas de manifiesto:

1. addClasspath, classpathPrefix estaban ausentes (los eliminó)
2. A mainClass le faltaba el "com". (utiliza el NB -> Propiedades del proyecto-> Ejecutar-> Clase principal-> Examinar para especificar)

No estoy seguro de por qué (solo llevo 3 meses en Java) o cómo, pero solo puedo decir que esto funcionó.

Aquí está solo el bloque de manifiesto modificado utilizado:

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

¡Encontré una nueva solución para la generación de manifiestos malos!

1. Abra el archivo jar con un editor zip como WinRAR

2. Haga clic para META-INF

3. Agregar o editar

   • Añadir:

     • Cree un archivo de texto llamado MANIFEST.MF en una carpeta llamada META-INF y agregue la siguiente línea:

       • Versión Manifiesto: 1.0
       • Clase principal: package.ex.com.views.mainClassName

     • Guarde el archivo y agréguelo al zip

   • Editar:

     • Arrastre el archivo, modifique MANIFEST.MF para agregar la línea anterior

4. Abra cmd y escriba: java -jar c: /path/JarName.jar

¡Debería funcionar bien ahora!

la mayoría de las soluciones no funcionaron para mí, pero mi instructor me ayudó, me gustaría compartir su solución aquí, utilicé el terminal kali linux pero debería estar bien en todos los debian

javac *.java
nano MANIFEST.MF

en el tipo de archivo

Main-Class: Main o cualquiera que sea su nombre de archivo principal (asegúrese de agregar el nombre del paquete si existe)

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

ahora para ejecutar el uso del archivo

java -jar new.jar

o puede ir a las propiedades del archivo y verificar

Permitir ejecución de archivo como programa

haga doble clic en él

me ayudó mientras que la mayoría de las respuestas anteriores no

Puede que tengas el mismo problema que yo. Después de crear su archivo .jar, escriba jar xf app.jar META-INF/MANIFEST.MF. Esto creará una copia del archivo en su directorio actual para que pueda leerlo. Si solo dice algo como:

Versión Manifiesto: 1.0

Creado por: 1.8.0_51 (Oracle Corporation)

y no contiene la declaración "Main-Class", entonces creo que encontró su problema.

Sin embargo, no sé cómo resolverlo. Verifiqué a otras personas con problemas iguales / similares en StackOverflow y no pude encontrar una respuesta. Sin embargo, con esta información quizás pueda obtener una mejor ayuda (dado el hecho de que tiene el mismo problema que yo).

Editar: había intentado con un archivo de manifiesto pero no lo hice funcionar, pero mi error fue nombrar solo una de las clases al crear el archivo jar. Escribí * .class en su lugar y funciona ahora.

Aunque no sé por qué es necesario crear un archivo de manifiesto. Pero supongo que está bien mientras funcione.

Tuve este problema y lo resolví recientemente haciendo esto en Netbeans 8 (Consulte la imagen a continuación):

1. ir a las propiedades de su proyecto.
2. haga clic en Ejecutar .
3. especifique la clase principal de su proyecto usando el buscador .
4. compila y ejecuta el archivo Jar.