Question

我已经安装了一个应用程序，当我尝试运行它时（它是一个可执行的jar）没有任何反应。当我从命令行运行它时：

java -jar“app.jar”

我收到以下消息：

在“app.jar”
中没有主要的清单属性

通常情况下，如果我自己创建了程序，我会在清单文件中添加一个主类属性。但在这种情况下，由于文件来自应用程序，我不能这样做。我也尝试提取jar以查看是否可以找到主类，但是有许多类，并且它们中没有一个在其名称中包含“main”一词。必须有办法解决这个问题，因为程序在其他系统上运行良好。

Answer 1

首先，看到你运行java -jar "app"而不是java -jar app.jar

，这有点奇怪

其次，要使jar可执行...你需要jar一个名为META-INF / MANIFEST.MF的文件

文件本身应该（至少）有一个班轮：

Main-Class: com.mypackage.MyClass

其中com.mypackage.MyClass是持有 public static void main（String [] args）入口点的类。

请注意，有几种方法可以使用CLI，Maven，Ant或Gradle完成此操作：

对于 CLI ，以下命令将执行：（tks @ dvvrt） jar cmvf META-INF/MANIFEST.MF <new-jar-filename>.jar <files to include>

对于 Maven ，类似以下代码段的内容应该可以解决问题。请注意，这只是插件定义，而不是完整的 pom.xml ：

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

（选择适合您项目的<version>。）

对于 Ant ，下面的代码段应该有所帮助：

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

致谢Michael Niemand -

Gradle ：

plugins {
    id 'java'
}

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

Answer 2

应该是java -jar app.jar而不是java -jar "app"。

-jar选项仅在JAR文件是可执行JAR文件时有效，这意味着它必须具有包含Main-Class属性的清单文件。请参阅Packaging Programs in JAR Files以了解如何创建可执行JAR。

如果它不是可执行的JAR，那么你需要运行程序，例如：

java -cp app.jar com.somepackage.SomeClass

其中com.somepackage.SomeClass是包含运行程序的main方法的类。（该课程取决于课程，不可能从您提供的信息中得知）。

Answer 3

或者，您可以使用maven-assembly-plugin，如下例所示：

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

在此示例中，部分中指定的所有依赖项jar将自动包含在您的单个jar中。请注意，jar-with-dependencies应该按字面意思放置，而不是替换为要包含的jar文件名。

Answer 4

这是因为Java无法在MANIFEST.MF文件中找到Main属性。 Main属性是告诉java应该使用哪个类作为应用程序的入口点所必需的。在jar文件中，MANIFEST.MF文件位于META-INF文件夹中。想知道如何看待jar文件中的内容？使用WinRAR打开jar文件。

MANIFEST.MF中的主要属性如下所示：

Main-Class: <packagename>.<classname>

你得到这个＆＃34;没有主要的清单属性＆＃34; MANIFEST.MF文件中缺少此行时出错。

~~在MANIFEST.MF文件中指定此属性真是一团糟。~~

更新：我刚刚找到了一个非常简洁的方法来指定Eclipse中应用程序的入口点。当你说出口，

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.

enter image description here

Answer 5

Gradle的答案是添加一个jar / manifest / attributes设置，如下所示：

apply plugin: 'java'

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

Answer 6

对于maven，这就解决了它（对我来说，对于GitHub上的Veetle代码库）：

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

干杯...

Answer 7

尝试此命令以包含jar：

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

Answer 8

我有同样的问题。通过向pom文件添加以下行使其工作。该插件将确保您的应用程序的构建过程包含所有必要的步骤。

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

Answer 9

使用IntelliJ IDEA创建jar时出现此问题。请参阅this discussion。

为我解决的是重新创建jar工件，选择JAR＆gt;来自具有依赖关系的模块，但不接受META-INF / MANIFEST.MF的默认目录。将它从 - / src / main / java更改为 - / src / main / resources。

否则它在jar中包含一个清单文件，但不包括它应该包含在 - / src / main / java中的文件。

Answer 10

对我来说，没有一个答案真正有用 - 我将清单文件放在正确的位置，包含Main-Class和所有内容。让我绊倒的是：

警告：您要从中创建清单的文本文件以新线或回车结束。最后一行不会如果它没有以新行或回车结束，则正确解析。

（source）。在清单末尾添加换行符修复了它。

Answer 11

我今天遇到了同样的问题。我的问题解决了我将META-INF移动到资源文件夹。

Answer 12

我刚才遇到了同样的错误。如果你正在使用gradle，只需在gradle.build中添加下一个：

apply plugin: 'java'

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

使用com.company.project.MainClass方法的public static void main(String[] args)路径到哪个类。

Answer 13

如果使用Maven，请在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>

Answer 14

我遇到了同样的问题，现在已经解决了:) 只需按照以下步骤操作即可，错误可能适用于任何操作，但以下步骤可使过程更加顺畅。我花了很多时间来寻找解决方案。

1.尝试重启Eclipse（如果您使用Eclipse构建JAR文件） - ＆GT;实际上这有助于我正确导出JAR文件的问题。

2.在eclipse重新启动后，尝试查看您的eclipse是否能够通过Java项目识别主类/方法 - ＆gt;右键单击 - ＆gt;以 - ＆gt;运行运行配置 - ＆gt;主要 - ＆gt;单击“搜索”按钮以查看您的eclipse是否能够在JAR文件中查找主类。 - ＆GT;这是为了验证JAR文件将具有主类的入口点。

在此之后，将Java Dynamic项目导出为“Runnable JAR”文件，而不是JAR文件。
在Java启动配置中，选择您的主类。
导出jar文件后，使用以下命令执行。 java -cp [Your JAR] .jar [完整包] .MainClass 例如：java -cp AppleTCRuleAudit.jar com.apple.tcruleaudit.classes.TCRuleAudit
您可能会遇到不受支持的java版本错误。修复是更改shell bash配置文件中的java_home以匹配用于在eclipse中编译项目的java版本。

希望这有帮助！如果您还有任何问题，请告诉我。

Answer 15

主要问题是，它尝试从依赖项中包含第一个库中的第一个MANIFEST.MF文件，而不是我们自己的MANIFEST.MF中的使用人工制品时！。

将yourjar.jar重命名为yourjar.zip
从META-INF \ MANIFEST.MF中打开MANIFEST.MF文件
通过MAVEN复制项目中已经生成的真实MANIFEST.MF 其中包括：清单版本：1.0 主类：youpacket.youmainclass
用它替换youjar.zip中MANIFEST.MF的内容。
将yourjar.zip重命名为yourjar.jar。
现在，java -jar yourjar.jar可以正常工作。

或！

简单创建您自己的MANIFEST.MF和：

        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>3.1.2</version>
            <configuration>
                <archive>
                    <manifestFile>/src/main/resources/META-INF/MANIFEST.MF</manifestFile>
                    <index>true</index>
                    <manifest>
                        <addClasspath>true</addClasspath>
                    </manifest>
                </archive>
            </configuration>
        </plugin>

但是，如果您使用maven面板（或maven命令行），则可以强制其生成自己的清单并将其包含到JAR文件中。

将以下代码添加到pom.xml：

<build>
<plugins>
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-jar-plugin</artifactId>
        <version>3.1.2</version>
        <configuration>
            <archive>
                <index>true</index>
                <manifest>
                    <addClasspath>true</addClasspath>
                </manifest>
                <manifestEntries>
                    <mode>development</mode>
                    <url>${project.url}</url>
                    <key>value</key>
                </manifestEntries>
            </archive>
        </configuration>
    </plugin>

    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-assembly-plugin</artifactId>
        <version>3.1.1</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>
                </manifest>
                <manifestEntries>
                    <mode>development</mode>
                    <url>${project.url}</url>
                    <key>value</key>
                </manifestEntries>
            </archive>
        </configuration>
    </plugin>
</plugins>

打开MAVEN面板（在Intellij中）并执行“安装”。它将生成MANIFEST文件，并将具有所有依赖项的JAR文件的属性编译到“ Target”文件夹中。还将安装到本地Maven存储库。

Answer 16

如果jar没有跟随the rules，那它就不是可执行的jar。

Answer 17

您可以简单地按照此步骤操作使用

创建一个jar文件

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

运行jar文件时，运行就像这样

 java -cp jarfile-name main-classname

Answer 18

您可能没有正确创建jar文件：

ex：在jar创建中缺少选项m

以下作品：

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

Answer 19

我个人认为这里的所有答案都是误解了这个问题。答案就在于spring-boot如何构建.jar。每个人都知道Spring Boot设置了这样一个清单，它与每个人 asssumption 不同，这是一个标准的.jar启动，它可能是也可能不是：

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

也许它需要在类路径上用org.springframework.boot.loader.JarLauncher执行？

Answer 20

任何可执行jar文件应该通过使用命令提示符（如java -jar app.jar）单击或运行来运行（使用“如果jar的路径包含空格” - 即java -jar“C：\ folder name \ app.jar” ）。如果你的可执行jar没有运行，这意味着它没有正确创建。

为了更好地理解，提取jar文件（或使用任何工具查看，对于Windows 7-Zip很好）并检查/META-INF/MANIFEST.MF下的文件。如果您找到任何条目，如

Main-Class：your.package.name.ClaaswithMain - 然后没关系，否则你必须提供它。

请注意在MANIFEST.MF文件中附加Main-Class条目，检查保存位置！

Answer 21

对我来说，这个错误只是因为我忘了告诉Eclipse我想要一个可运行的jar文件而不是一个简单的库jar文件。因此，当您在Eclipse中创建jar文件时，请确保单击右侧的单选按钮

Answer 22

就我而言，问题是 <pluginManagement> 下的 <build> 使事情无法正常工作。

我原来的 pom.xml：

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

删除 <pluginManagement> 后，错误消失了。

Answer 23

我找到了一个新的错误清单生成解决方案！

使用像WinRAR
点击META-INF
添加或修改
- 添加：
  - 在名为META-INF的文件夹中创建名为MANIFEST.MF的文本文件并添加以下行：
    - Manifest-Version：1.0
    - Main-Class：package.ex.com.views.mainClassName
  - 保存文件并将其添加到zip
- 编辑：
  - 拖出文件修改MANIFEST.MF以添加上一行
打开cmd并输入：java -jar c：/path/JarName.jar

现在应该可以正常使用了！

Answer 24

（第一篇文章 - 所以它可能不干净）

这是我对基于Maven的Netbeans 8.2程序OS X 11.6的修复。到目前为止，我的应用程序是100％Netbeans - 没有调整（只有几个shell逃脱不可能！）。

在这里和其他地方尝试了大部分答案都没有用，我回到了＆＃34;使用什么有效的＆＃34;的艺术。

这里的最佳答案（olivier-refalo thanx）看起来是正确的起点，但没有帮助。

看看其他有效的项目，我注意到清单行中有一些细微差别：

addClasspath，classpathPrefix缺席（删除它们）
mainClass缺少＆＃34; com。＆＃34; （使用NB - ＆gt;项目属性 - ＆gt;运行 - >主类 - ＆gt;浏览以指定）

不确定为什么（我只有3个月进入java）或如何，但只能说这有效。

以下是使用的修改后的清单块：

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

Answer 25

我遇到了同样的问题。这里提到的很多解决方案并没有给我全面的了解，所以我将尝试给你一个如何从命令行打包jar文件的摘要。

如果您希望将.class个文件放入包中，请在.java的开头添加该包。

<强> Test.java
```
package testpackage;

public class Test
{
    ...
}
```
使用您的.class文件编译代码，最后使用包名称给出的结构：
```
javac -d . Test.java
```
-d .使编译器创建所需的目录结构。
打包.jar文件时，需要指示jar例程如何打包它。这里我们使用选项集cvfeP。这是保持包结构（选项P），指定入口点，以便清单文件包含有意义的信息（选项e）。选项f允许您指定文件名，选项c创建存档，选项v将输出设置为详细。这里需要注意的重要事项是P和e。

然后是我们想要的jar的名称test.jar。

然后是切入点。

然后来-C . <packagename>/从该文件夹中获取类文件，保留文件夹结构。
```
jar cvfeP test.jar testpackage.Test -C . testpackage/
```
检查zip程序中的.jar文件。它应该具有以下结构

<强> Test.jar的
```
META-INF
| MANIFEST.MF
testpackage
| Test.class
```
MANIFEST.MF应包含以下内容
```
Manifest-Version: 1.0
Created-By: <JDK Version> (Oracle Corporation)
Main-Class: testpackage.Test
```
如果您手动编辑清单请务必将换行符保留在最后，否则java无法识别。
使用
执行.jar文件
```
java -jar test.jar
```

Answer 26

以上答案对我来说只是部分有用。 java -cp是答案的一部分，但我需要有关如何识别要运行的类的更具体的信息。这对我有用：

第1步：找到我需要运行的课程

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

结果的第一行是：

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

App.class包含要运行的主类。我不是百分百肯定你能不能总是假设你需要的课程是第一个，但这对我来说。如果不是，我认为使用grep排除与库相关的结果以将类列表削减到可管理的大小并不太难。

从那里很简单：我只使用那条路径（减去“.class”后缀）：

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

Answer 27

由于您已添加MANIFEST.MF，我认为您应该考虑此文件中Field的顺序。我的环境是java version "1.8.0_91"

和我的MANIFEST.MF一样

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

但是，如下所示贯穿

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

//this run swing normally

Answer 28

只是要明确一点

Main-Class: <packagename>.<classname>

如果你没有包裹，你必须忽略那部分，如下所示：

Main-Class: <classname>

Answer 29

我遇到了这个问题，最近我在Netbeans 8中解决了这个问题（参见下图）：

Netbeans project properties

转到项目的属性。
点击运行。
使用浏览。
构建并运行 Jar文件。

Answer 30

大多数解决方案都不适合我，但我的老师帮助了我我想在这里分享他的解决方案我使用了kali linux终端，但在所有debian中都可以使用

javac *.java
nano MANIFEST.MF

在文件类型中

主要类别：主要或您的主文件名是什么（如果存在，请确保添加软件包名称）

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

现在要运行文件使用

java -jar new.jar

或者您可以转到文件属性并检查

允许将文件作为程序执行

双击它

它对我有帮助，而上述大多数答案都没有

Answer 31

我尝试了这个，对我有用。 mvn全新安装软件包应该可以正常工作。

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <executions>
            <execution>
                <goals>
                    <goal>repackage</goal>
                </goals>
            </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Answer 32

就我而言 - 我从事一个多模块项目 - 我可以通过以下方式介绍该问题：

我将此添加到父 pom.xml 中，这导致了问题。即，值为 skip 的 true：

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <!--
                besides hindering the packaging, this also skips running the app after build when calling spring-boot:run. You have to enable it in the
                corresponding module by setting skip to false, there.
                -->
                <skip>true</skip>
            </configuration>
        </plugin>
    </plugins>
</build>

我通过向要打包为 jar 的模块添加相同的配置来解决该问题，但将 skip 的值更改为 false：

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <version>${spring-boot.version}</version>
    <configuration>
        <mainClass>${project.mainClass}</mainClass>
        <layout>ZIP</layout>
        <skip>false</skip>
    </configuration>
    <executions>
        <execution>
            <goals>
                <goal>repackage</goal>
            </goals>
        </execution>
        <execution>
            <id>build-info</id>
            <goals>
                <goal>build-info</goal>
            </goals>
        </execution>
    </executions>
</plugin>

Answer 33

我和你有类似的问题，在下面的语法中成功创建.war文件： -

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

清单在创建（c）或更新（u）JAR文件时，清单操作数定义预先存在的清单文件，其中包含要包含在JAR文件中的MANIFEST.MF中的属性的名称和值。如果f选项存在，则必须指定清单操作数＆＃39; [1]＆＃39;。

要创建清单文件，您需要为某些属性定义一个值，您可以在（.WAR）文件名后面加上星号，以避免创建清单文件： -

jar -cvf foo.war *

老实说，我不知道这是不是最好的做法，但它能为我做好工作:)。

Answer 34

如果使用命令行汇编.jar，则可以指向main而不添加Manifest文件。例如：

jar cfve app.jar TheNameOfClassWithMainMethod *.class

（param＆＃34; e＆＃34;那样做：TheNameOfClassWithMainMethod是类的名称，方法是main（）和app.jar - 可执行文件的名称.jar和* .class - 只是要汇编的所有类文件）

Answer 35

找到了一个很好的解决方案，在任何情况下都可以提供帮助，因为您只需要一个可运行的jar，在大多数情况下都可以这样做。如果您的应用程序在Intellij Idea中运行，请按照下列步骤操作： 1）转到模块设置，然后转到工件，然后添加一个jar并定义主类 2）然后转到菜单中的“构建”，然后单击“构建工件”，您将获得jar。

即使我更改了源文件夹并使用scala而不是java，此方法仍然有效。

Answer 36

我在执行 mvn软件包时遇到了相同的错误。这就是我解决问题的方式。

我正在使用maven-multi-module。我正面临这个问题，因为我错误地在父pom中添加了以下部分。

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

然后将其添加到pom.xml子模块中并从父pom中删除后，解决了我的问题。

Answer 37

使用以下内容在该文件夹中创建文件夹META-INF和文件MANIFEST.MF：

Manifest-Version: 1.0
Class-Path: .
Main-Class: [YOUR_MAIN_CLASS]

然后进行编译，包括清单文件。

Answer 38

只需将其添加到Java模块的build.gradle中即可。它将创建可执行jar。它将在存档中包含依赖库。

jar {
  manifest { 
    attributes "Main-Class": "com.company.application.Main"
  }  

  from {
    configurations.compile.collect { it.isDirectory() ? it : zipTree(it) }
  }
}

这将导致[module_name] / build / libs / [module_name] .jar文件。我用外壳测试过了。

Answer 39

您可能遇到与我相同的问题。创建.jar文件后，写下jar xf app.jar META-INF/MANIFEST.MF。这将创建该文件的副本到您当前的目录，以便您可以阅读它。如果它只是说：

清单 - 版本：1.0

创建者：1.8.0_51（Oracle Corporation）

并且不包含＆＃34; Main-Class＆＃34;声明，然后我认为你找到了你的问题。

但是，我不知道如何解决它。我在StackOverflow上检查了其他有相同/类似问题的人，但无法找到答案。但是有了这些信息，您可以获得更好的帮助（假设您遇到与我相同的问题）。

编辑：我曾尝试使用清单文件，但没有让它工作，但我的错误是在创建jar文件时只命名其中一个类。我写了* .class而现在可以了。

虽然我不知道为什么需要创建清单文件。但我觉得只要它有效就行了。

Answer 40

如果你在 maven 和你的 pom.xml 是这样的

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.3</version>
        <relativePath/> <!-- lookup parent from repository -->
      </parent>
      <groupId>com.example</groupId>
      <artifactId>demo</artifactId>
      <version>0.0.1-SNAPSHOT</version>
      <name>demo</name>
      <properties>
        <java.version>11</java.version>
      </properties>
      <dependencies>
        <!-- dependencies -->
      </dependencies>
      <build>
        <pluginManagement>
          <plugins>
            <plugin>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
          </plugins>
        </pluginManagement>
      </build>
    </project>

只需评论 pluginManagement 即可得到以下 pom.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.3</version>
        <relativePath/> <!-- lookup parent from repository -->
      </parent>
      <groupId>com.example</groupId>
      <artifactId>demo</artifactId>
      <version>0.0.1-SNAPSHOT</version>
      <name>demo</name>
      <properties>
        <java.version>11</java.version>
      </properties>
      <dependencies>
        <!-- dependencies -->
      </dependencies>
      <build>
        <plugins>
          <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
          </plugin>
        </plugins>
      </build>
    </project>

Answer 41

检查本地.m2目录以查找此工件的子目录。如果exixts - 删除它，并再次执行Maven更新

无法执行jar文件：“没有主要清单属性”

41 个答案: