java - deployments - No se puede ejecutar el archivo jar: "no hay atributo de manifiesto principal"

no main manifest attribute in deployments root jar

Question

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

java -jar "app.jar"

Recibo el siguiente mensaje:

ningún atributo manifiesto principal, en "app.jar"

Normalmente, si yo mismo hubiera creado el programa, 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 solucionar esto porque el programa se ejecuta bien en otros sistemas.

Answer 1

(primer post - para 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 cuantos escapes de shell por lo imposible!).

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

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

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

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

No estoy seguro de por qué (solo tengo 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>

Answer 2

Alternativamente, puede usar el complemento de ensamblaje de maven, 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 especifican en la sección se incluirán automáticamente en su solo archivo jar. Tenga en cuenta que jar-with-dependencies se debe poner literalmente como, no para ser reemplazado con los nombres de archivos jar que desea incluir.

Answer 3

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

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

Clase principal: your.package.name.ClaaswithMain - entonces está bien, de lo contrario tiene que proporcionarlo.

Esté al tanto de añadir una entrada de clase principal en el archivo MANIFEST.MF, ¡compruebe dónde la está guardando!

Answer 4

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

y mi MANIFEST.MF como aqui

// 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 se describe a continuación

Manifest-Version: 1.0
Main-Class: HelloWorldSwing
Created-By: 1.8.0_91 (Oracle Corporation)
//this run swing normally

Answer 5

Es posible que no hayas creado el archivo jar correctamente:

ej: falta la opción m en la creación del tarro

Los siguientes trabajos:

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

Answer 6

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

La opción -jar solo funciona si el archivo JAR es un archivo JAR ejecutable, lo que significa que debe tener un archivo de manifiesto con un atributo de Main-Class . Consulte Empaquetar programas 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.SomeClass es la clase que contiene el método main para ejecutar el programa. (Lo que esa clase es depende del programa, es imposible decirlo a partir de la información que ha proporcionado).

Answer 7

Esto se debe a que Java no puede encontrar el atributo principal en el archivo MANIFEST.MF. El atributo Main es necesario para indicar 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. ¿Se pregunta cómo podría ver lo que hay dentro de un archivo jar? Abra el archivo jar con WinRAR.

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

Main-Class: <packagename>.<classname>

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

Es realmente un gran lío especificar este atributo dentro del archivo MANIFEST.MF.

Actualización: acabo de encontrar una manera realmente 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.

Answer 8

La respuesta de Gradle es agregar una configuración de jarra / manifiesto / atributos como esta:

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

Answer 9

Las respuestas anteriores solo me ayudaron en parte. java -cp fue 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: encuentra la clase que necesito para correr

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

Las primeras líneas 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.

Desde allí fue fácil: solo uso esa ruta (menos el sufijo ".class"):

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

Answer 10

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

1.Trate de reiniciar Eclipse (si está usando Eclipse para compilar el archivo JAR) -> En realidad, esto ayudó a mi problema al exportar el archivo JAR correctamente.

2. Después de reiniciar eclipse, intente ver si su eclipse puede reconocer la clase / método principal por su proyecto Java -> haga clic 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 Java Dynamic como archivo "Runnable JAR" y no como archivo JAR.

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

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

7. Es posible que se enfrente al error de la versión de Java no compatible. la solución es cambiar java_home en tu perfil de shell bash para que coincida con la versión java utilizada para compilar el proyecto en eclipse.

¡Espero que esto ayude! Por favor, déjame saber si todavía tienes problemas.

Answer 11

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

Answer 12

Para mí, ninguna de las respuestas realmente me ayudó, tenía el archivo de manifiesto en el lugar correcto, conteniendo la Clase Principal y todo. Lo que me tropezó fue esto:

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

( source ). La adición de una nueva línea al final del manifiesto lo solucionó.

Answer 13

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

Aclamaciones...

Answer 14

Personalmente creo que todas las respuestas aquí son una comprensión errónea 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 configura un manifiesto como este, que varía según el supuesto de todos : que se trata de un lanzamiento .jar estándar, que puede ser o no:

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

Tal vez necesita ejecutarse con org.springframework.boot.loader.JarLauncher en el classpath?

Answer 15

Primero, es un poco extraño ver que ejecutas java -jar "app" y no java -jar app.jar

Segundo, para hacer un ejecutable jar ... necesitas crear un archivo llamado META-INF / MANIFEST.MF

el archivo en sí debe tener (al menos) este forro:

Main-Class: com.mypackage.MyClass

Donde com.mypackage.MyClass es la clase que contiene el punto de entrada main (ns [] args) vacío público estático .

Tenga en cuenta que hay varias formas de hacer esto con CLI, Maven, Ant o Gradle:

Para CLI , el siguiente comando lo hará: ( dvvrt @ 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 una <version> apropiada para su proyecto.)

Para Ant , el siguiente fragmento de código 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''
)
}
}

Answer 16

Pruebe este comando para incluir el frasco:

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

Answer 17

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 a su directorio actual para que pueda leerlo. Si solo dice algo como:

Versión de manifiesto: 1.0

Creado por: 1.8.0_51 (Oracle Corporation)

y no contiene la declaración "Clase principal", entonces creo que encontró su problema.

Aunque no sé cómo resolverlo. Revisé a otras personas con problemas iguales o similares en 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).

Edición: había intentado con un archivo de manifiesto pero no conseguí que funcionara, pero mi error fue nombrar solo una de las clases al crear el archivo jar. Escribí * .class en su lugar y ahora funciona.

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

Answer 18

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

Answer 19

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

jar cfve app.jar TheNameOfClassWithMainMethod *.class

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

Answer 20

Si usa Maven, incluya los siguientes en el pom.

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

Answer 21

Simplemente puede seguir este paso Crear un archivo jar usando

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

Mientras se ejecuta el archivo jar, simplemente ejecute así

 java -cp jarfile-name main-classname

Answer 22

Tengo el mismo error justo ahora. Si está usando gradle , simplemente agregue el siguiente en ur gradle.build :

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

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

Answer 23

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

Answer 24

Tuve el mismo problema. añadiendo las siguientes líneas al archivo pom lo hizo funcionar. El complemento asegurará el 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>

Answer 25

Tuve este problema al crear un frasco utilizando IntelliJ IDEA. Vea esta discusión .

Lo que lo resolvió fue recrear 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 que está en - / src / main / java que debería tener.

Answer 26

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

1. Ve a las propiedades de tu proyecto.
2. haga clic en Ejecutar .
3. Especifique la clase principal de su proyecto usando Browse .
4. construir y ejecutar el archivo Jar.

Answer 27

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

1. Si desea tener sus archivos .class en paquetes, agregue el paquete al principio de .java .

   Prueba.java

   package testpackage;
   public class Test
   {
   ...
   }

2. Para compilar su código con sus archivos .class que terminan con la estructura dada por el uso del nombre del paquete:

   javac -d . Test.java

   El -d . Hace que el compilador cree la estructura de directorios que desee.

3. Al empaquetar el archivo .jar , debe indicar a la rutina jar cómo empaquetarlo. Aquí usamos la opción set cvfeP . Esto es para mantener la estructura del paquete (opción P ), especifique el punto de entrada para que el archivo de manifiesto contenga información significativa (opción e ). La opción f permite especificar el nombre del archivo, la opción c crea un archivo y la opción v establece el resultado en detallado. Las cosas importantes a tener en cuenta aquí son P y e .

   Luego viene el nombre del jar que queremos test.jar .

   Luego viene el punto de entrada.

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

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

4. Revise su archivo .jar 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 lo reconocerá.

5. Ejecuta tu archivo .jar con

   java -jar test.jar

Answer 28

revise su archivo jar dentro de MANIFEST.MF Main-Class está disponible o no

primero.java

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

Antes de

Manifest-Version: 1.0
Created-By: 1.7.0_80 (Oracle Corporation)
sony@sony-VPCEH25EN:~/Documents$ java -jar first.jar
no main manifest attribute, in first.jar

Después:

Manifest-Version: 1.0
Created-By: 1.7.0_80 (Oracle Corporation)
Main-Class: first
sony@sony-VPCEH25EN:~/Documents$ java -jar first.jar
Welcome to the world of Java

Answer 29

Tuve un problema similar al tuyo, en la siguiente sintaxis para crear con éxito el archivo .war: -

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

manifiesto Al crear (c) o actualizar (u) un archivo JAR, el operando de manifiesto define los archivos de manifiesto preexistentes con nombres y valores de atributos que se incluirán en MANIFEST.MF en el archivo JAR. El operando de manifiesto debe especificarse si la opción f está presente ''[ 1 ]''.

Para crear un archivo de manifiesto necesita definir un valor para algunos atributos, puede poner un asterisco después del nombre de archivo (.WAR) para evitar crear un archivo de manifiesto:

jar -cvf foo.war *

Para serte sincero, no sé si esa es una buena práctica, pero hace el trabajo por mí :).

Answer 30

¡Encontré una nueva solución para la mala generación manifiesta!

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

2. Haga clic en para META-INF

3. Añadir 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 de manifiesto: 1.0
       • Clase principal: package.ex.com.views.mainClassName

     • Guarda el archivo y agrégalo al zip.

   • Editar:

     • Arrastre el archivo hacia fuera, 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!