Ошибка no main manifest attribute

First, it’s kind of weird, to see you run java -jar "app" and not java -jar app.jar

Second, to make a jar executable… you need to jar a file called META-INF/MANIFEST.MF

the file itself should have (at least) this one liner:

Main-Class: com.mypackage.MyClass

Where com.mypackage.MyClass is the class holding the public static void main(String[] args) entry point.

Note that there are several ways to get this done either with the CLI, Maven, Ant or Gradle:

For CLI, the following command will do: (tks @dvvrt)

jar cmvf META-INF/MANIFEST.MF <new-jar-filename>.jar  <files to include>

For Maven, something like the following snippet should do the trick. Note that this is only the plugin definition, not the full pom.xml:

Latest doc on this plugin: see https://maven.apache.org/plugins/maven-jar-plugin/

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

(Pick a <version> appropriate to your project.)

For Ant, the snippet below should help:

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

For Gradle:

plugins {
    id 'java'
}

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

Every executable jar file in a Java application should contain a main method. It is usually placed at the beginning of the application. Manifest files must be included with self-executing jars, as well as being wrapped in the project at the appropriate location, to run a main method. Manifest files have a main attribute that specifies the class having the main method.

“no main manifest attribute” is a common error which happens when we try to run an executable jar file. The full error output may look like what’s shown below

Unable to execute jar- file: "no main manifest attribute." Code language: JavaScript (javascript)

Or

no main manifest attribute, in target/exec.jar

In this article, we will show you a few possible fix that you can apply to your Java project to avoid getting “no main manifest attribute” error.

“no main manifest attribute” error message is thrown because of various reasons, but most of the time, it fall under one of the following category.

• Missing entry point of Main-Class in MANIFEST.MF file.
• Missing Maven dependency in pom.xml
• Missing entry point in build.gradle

The Main, or Main-Class is an essential attribute to make your jar executable. It tells Java which class would be used as the entry point of the application.

Without a Main, or Main-Class attribute, Java have no way to know which class it should run when you execute the jar.

Inside the jar file, the MANIFEST.MF file is located in META-INF folder. Opening the jar file with WinRAR, you would see the contents of it, along with MANIFEST.MF.

A typical MANIFEST.MF file should contain the following lines

Manifest-Version: the version of the Manifest file.
Built-By: your PC name.
Build-Jdk: the JDK version installed in your machine.
Created-By: the plugin name used in IDE.Code language: HTTP (http)

Below is an example of a MANIFEST.MF file.

Putting maven-jar-plugin in pom.xml

The “no main manifest attribute” error message may occur in a Maven project due to the absence of the Main-Class entry in MANIFEST.MF.

This issue can be resolved by adding maven-jar-plugin to our pom.xml file.

<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>  
                        <mainClass>com.linuxpip.AppMain</mainClass>  
                    </manifest>  
                </archive>  
            </configuration>  
        </plugin>  
    </plugins>  
</build>  Code language: HTML, XML (xml)

In the code snippet above, com.linuxpip.AppMain is our fully-qualified name of the Main-Class. You have to change this according to your specific project.

If you need more information, dig deep into maven-jar-plugin documentation: see https://maven.apache.org/plugins/maven-jar-plugin/

Specify Main-Class in Gradle

The following entries can be put into your build.gradle file if you receive this error in your Gradle project:

plugins {
    id 'java'
}

jar {
    manifest {
        attributes(
                'Main-Class': 'com.linuxpip.MyClass'
        )
    }
}Code language: JavaScript (javascript)

In the code snippet above, com.linuxpip.MyClass is our fully-qualified name of the Main-Class. You have to change this according to your specific project.

Change default MANIFEST.MF folder in IntelliJ IDEA

People have been reporting that IntelliJ IDEA keeps putting the JAR artifact into the wrong folder.

In order to fix “no main manifest attribute” in IntelliJ IDEA, choose JAR > From modules with dependencies

In the Create JAR from Modules window, change the default Directory for META-INF/MANIFEST.MF path from <project folder>srcmainjava to <project folder>srcmainresources.

Otherwise it would generate the manifest and including it in the jar, but not the one in <project folder>srcmainjava that Java expects.

After that, just continue to Build Artifacts as you usually do.

Specify entry point in Eclipse

If you’re exporting the JAR file in Eclipse, it has a built-in option that allows you to specify the Application’s entry point, avoiding “no main manifest attribute” error message.

In Eclipse’s JAR Export window, you would see “Select the class of the application entry point” near the end of the Export process. Now you can pick a class and Eclipse will automatically generate the proper MANIFEST.MF file with the settings you’ve set.

In a Java project, every executable jar file contains a main method. Usually, it is placed at starting point of the application. To execute a main method by a self-executing jar file, we must have a proper manifest file and wrap it with our project at the proper location. These files have a main manifest attribute that is used to define the path to class having the main method.

Sometimes, we have a self-executable jar, and when we try to execute the project, it will throw the following error message:

The above error message is thrown because of a missing entry of Main-Class in MANIFEST.MF file.

You may encounter this problem in any configuration-based Java project. Let’s discuss its solutions:

Solution:

Let’s understand its solutions in different projects:

Maven

In Maven Project, this problem may encounter because of the missing entry of Main-Class in MANIFEST.MF file. To overcome this issue, we may define it in our pom.xml file by manually putting a maven-jar-plugin in pom.xml.

In the above code, com.javatpoint.AppMain is our fully qualified name of the Main-Class. You have to replace the fully qualified name according to your classpath. To copy the fully qualified name, right-click on the package that contains the main class and select Copy Fully Qualified Name.

Gradle

If you are getting this error in your Gradle project, you can solve this by putting the following entries in your build.gradle file:

Spring Boot Application

Sometimes this error may be encountered in your Spring Boot project. It is easy to resolve this error in the Spring Boot project. To fix this error in the SB project, put the maven-plugin dependency under the <plugins> tag in the pom.xml file.

Root Cause of the No Main Manifest Attribute Error

The «no main manifest error» is usually caused if you messed in MANIFEST.MF file located under META-INF folder. By default, it has the following entry:

Where,

Manifest-Version is the version of the Manifest file.

Built-By is your PC name.

Build-Jdk is the JDK version installed in your machine.

Created-By is the plugin name used in IDE.

When we run the project, it will look for the Main-Class in MANIFEST.MF file. It will throw the error message «Unable to execute jar-file» if it does not find the entry. When we run the above solutions, the class entry will automatically be updated in the project’s Manifest file as follows:

---