ChatGPT：Maven构建问题——配置Maven以生成可执行JAR文件并设置主类、解决Maven生成多个JAR文件的问题

于 2023-09-19 11:15:36 发布
阅读量841 收藏 2
点赞数 1
分类专栏： ChatGPT 文章标签： chatgpt maven jar
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XRT_knives/article/details/133019592
版权

ChatGPT：Maven构建问题——配置Maven以生成可执行JAR文件并设置主类、解决Maven生成多个JAR文件的问题

Others-1.0-SNAPSHOT.jar中没有主清单属性
ChatGPT：
"Others-1.0-SNAPSHOT.jar中没有主清单属性"错误通常发生在尝试运行一个Java JAR文件时，因为JAR文件缺少了主清单属性（Main-Class），这是JAR文件用于标识应用程序的入口点的元数据。
要解决这个问题，您需要在JAR文件的清单文件（META-INF/MANIFEST.MF）中添加一个主清单属性，以指定应用程序的入口类。
以下是一个示例清单文件的内容：
Manifest-Version: 1.0
Main-Class: com.example.YourMainClass
请注意以下几点：
  1. Manifest-Version 行指定了清单文件的版本，通常设置为 “1.0”。
  2. Main-Class 行指定了应用程序的入口类的完全限定类名（包括包名），例如 com.example.YourMainClass。这个类必须包含一个public static void main(String[] args) 方法，作为应用程序的入口点。
您需要将这个清单文件添加到JAR文件的META-INF 目录下，并确保清单文件的名称为 MANIFEST.MF（全部大写）。
如果您使用构建工具（如Maven或Gradle）来构建JAR文件，通常可以在构建配置中指定主清单属性。例如，使用Maven的插件可以在pom.xml文件中配置主清单属性。
一旦添加了主清单属性并保存了清单文件，您的JAR文件就应该能够正确运行了。
我使用的是maven，怎样在pom里面设置
ChatGPT：
在Maven项目中，您可以使用maven-jar-plugin插件来配置JAR文件的主清单属性。下面是如何在pom.xml文件中设置主清单属性的示例：
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>3.2.0</version> <!-- 使用最新版本的 maven-jar-plugin -->

            <configuration>
                <archive>
                    <manifest>
                        <!-- 指定主清单属性 -->
                        <mainClass>com.example.YourMainClass</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>
    </plugins>
</build>
上述配置中，我们使用了maven-jar-plugin插件，并在其配置中指定了主清单属性<mainClass>。请将com.example.YourMainClass替换为您的应用程序的实际入口类的完全限定类名。
当您运行mvn clean package或mvn install等Maven构建命令时，该插件将会生成包含指定主清单属性的JAR文件。
确保在pom.xml文件的<build>元素下的<plugins>中添加了上述的maven-jar-plugin配置，并替换主清单属性的值为您的应用程序的入口类。然后运行Maven构建命令以重新构建您的项目，生成包含主清单属性的JAR文件。
如果想在MANIFEST.MF加上作者怎么办
ChatGPT：
如果您想在JAR文件的 MANIFEST.MF 文件中添加作者信息，您可以使用 Maven 插件来实现。以下是如何在 Maven 项目中配置 JAR 文件的 MANIFEST.MF 文件以包含作者信息的示例：
首先，在您的 pom.xml 文件中添加 maven-jar-plugin 插件的配置，指定 MANIFEST.MF 中的作者信息。您可以使用 maven-jar-plugin 插件的 <manifestEntries> 元素来指定自定义的 MANIFEST.MF 条目，其中包括作者信息。
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>3.2.0</version> <!-- 使用最新版本的 maven-jar-plugin -->

            <configuration>
                <archive>
                    <manifest>
                        <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
                        <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
                        <manifestEntries>
                            <!-- 添加作者信息 -->
                            <Created-By>Your Name</Created-By>
                        </manifestEntries>
                    </manifest>
                </archive>
            </configuration>
        </plugin>
    </plugins>
</build>
上述配置中，我们在 maven-jar-plugin 的 <manifestEntries> 元素下添加了 <Created-By> 条目，用于指定作者信息。请将 "Your Name" 替换为实际的作者名字或信息。
然后，运行 Maven 构建命令（如 mvn clean package 或 mvn install）以重新构建您的项目。生成的 JAR 文件中的 MANIFEST.MF 文件应该包含您指定的作者信息。
请注意，<addDefaultImplementationEntries> 和 <addDefaultSpecificationEntries> 元素分别用于添加默认的实现和规范条目，具体取决于您的需求是否需要它们。如果不需要这些默认条目，可以将它们设置为 false。
最后生成的 MANIFEST.MF 文件可能如下所示：
Manifest-Version: 1.0
Created-By: Your Name
这样就成功在 MANIFEST.MF 文件中添加了作者信息。
为什么打包的时候依赖没有打包进来
ChatGPT：
如果在打包时依赖没有正确打包进来，可能有以下几个常见的原因：
  1. 依赖范围问题：Maven 依赖可以有不同的范围，如 compile、runtime、test 等。默认情况下，只有 compile 范围的依赖会被打包进 JAR 文件。确保您的依赖的范围正确，如果需要在运行时和编译时都使用它们，应将它们放在 compile 范围中。
    <dependencies>
    <dependency>
        <groupId>com.example</groupId>
        <artifactId>dependency-artifact</artifactId>
        <version>1.0.0</version>
        <!-- 通常 compile 范围表示依赖会被打包 -->
        <scope>compile</scope>
    </dependency>
</dependencies>
  2. 构建配置问题：确保 Maven 构建配置文件 pom.xml 中没有排除依赖的配置。在 <dependencies> 部分内，确保没有使用 <exclusions> 标签排除依赖。
    <dependencies>
    <dependency>
        <groupId>com.example</groupId>
        <artifactId>your-dependency</artifactId>
        <version>1.0.0</version>
        <!-- 不要使用 <exclusions> 排除依赖 -->
    </dependency>
</dependencies>
  3. Clean 构建：在执行 Maven 构建之前，可以尝试运行 mvn clean 命令，以清除旧的构建文件和依赖，然后再运行 mvn package 或其他构建命令。
  4. 依赖不在 Maven 仓库中：确保您的依赖已经上传到 Maven 仓库或者在您的本地 Maven 仓库中存在。如果依赖没有正确发布到仓库，Maven 将无法找到它并将其打包到项目中。
  5. 依赖版本问题：检查依赖的版本号是否正确。如果版本号不匹配，Maven 可能无法正确解析依赖并将其打包。
  6. IDE 缓存问题：有时 IDE 可能会缓存依赖信息，如果缓存过期或损坏，可能导致依赖无法正确加载。尝试清除 IDE 缓存并重新构建项目。
如果您仍然遇到问题，建议检查 Maven 构建日志以查看详细的错误信息，以便更好地了解问题所在。此外，可以使用 Maven 命令行来构建项目，以排除 IDE 的因素。
这是我的pom文件：
<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>

 <groupId>Others</groupId>
 <artifactId>Others</artifactId>
 <version>1.0-SNAPSHOT</version>

 <properties>
     <java.version>1.8</java.version>

     <maven.compiler.source>8</maven.compiler.source>
     <maven.compiler.target>8</maven.compiler.target>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 </properties>

 <dependencies>

     <dependency>
         <groupId>cn.hutool</groupId>
         <artifactId>hutool-all</artifactId>
         <version>5.8.16</version>
     </dependency>

     <dependency>
         <groupId>com.alibaba</groupId>
         <artifactId>easyexcel</artifactId>
         <version>3.0.5</version>
         <!--            <exclusions>-->
         <!--                <exclusion>-->
         <!--                    <groupId>org.slf4j</groupId>-->
         <!--                    <artifactId>slf4j-api</artifactId>-->
         <!--                </exclusion>-->
         <!--            </exclusions>-->
     </dependency>

     <!--Jsoup解析网页-->
     <dependency>
         <groupId>org.jsoup</groupId>
         <artifactId>jsoup</artifactId>
         <version>1.10.2</version>
     </dependency>

     <dependency>
         <groupId>com.alibaba</groupId>
         <artifactId>fastjson</artifactId>
         <version>1.2.41</version>
     </dependency>

     <dependency>
         <groupId>org.projectlombok</groupId>
         <artifactId>lombok</artifactId>
         <version>1.18.22</version>
     </dependency>

 </dependencies>

 <build>
     <plugins>
         <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-jar-plugin</artifactId>
             <version>3.2.0</version> <!-- 使用最新版本的 maven-jar-plugin -->

             <configuration>
                 <archive>
                     <manifest>
                         <!-- 指定主清单属性 -->
                         <mainClass>HtmlParseUtil</mainClass>
                     </manifest>
                 </archive>
             </configuration>
         </plugin>
     </plugins>
 </build>

</project>
ChatGPT：
根据您提供的 pom.xml 文件，依赖看起来是正确配置的，而且也没有排除任何依赖。这通常意味着依赖应该被正确地打包进您的 JAR 文件中。
如果在构建过程中仍然遇到依赖未正确打包的问题，您可以尝试以下步骤来排除问题：
  1. 清理并重新构建：首先尝试运行以下命令清理项目并重新构建：
    mvn clean package
    这将会清理之前生成的构建文件，并重新生成 JAR 文件。确保没有构建错误或警告信息。
  2. 检查生成的 JAR 文件：确保在正确的目录下找到了生成的 JAR 文件，并且该 JAR 文件的大小与您期望的相符。可以使用压缩工具（如 WinRAR 或 7-Zip）来打开 JAR 文件并查看其内容，以确认依赖是否已包含在 JAR 文件中。
  3. 依赖版本问题：如果您在代码中使用了某个依赖的特定版本，而且该依赖的版本与 pom.xml 中的版本不一致，可能会导致问题。确保代码中使用的版本与 pom.xml 中声明的版本一致。
  4. 重新导入项目：如果您使用的是集成开发环境（IDE），尝试重新导入项目或清除 IDE 缓存以确保依赖正确地加载。
如果您在执行上述步骤后仍然遇到问题，请提供详细的构建错误信息或日志，以便更进一步的帮助。
这是打包的日志：
C:\Users\23991\.jdks\corretto-1.8.0_382\bin\java.exe -Dmaven.multiModuleProjectDirectory=D:\IDEA\Others -Djansi.passthrough=true -Dmaven.home=D:\Maven\apache-maven-3.8.1 -Dclassworlds.conf=D:\Maven\apache-maven-3.8.1\bin\m2.conf "-Dmaven.ext.class.path=D:\IDEA\IntelliJ IDEA 2020.3.1\plugins\maven\lib\maven-event-listener.jar" "-javaagent:D:\IDEA\IntelliJ IDEA 2020.3.1\lib\idea_rt.jar=58345:D:\IDEA\IntelliJ IDEA 2020.3.1\bin" -Dfile.encoding=UTF-8 -classpath D:\Maven\apache-maven-3.8.1\boot\plexus-classworlds-2.6.0.jar;D:\Maven\apache-maven-3.8.1\boot\plexus-classworlds.license org.codehaus.classworlds.Launcher -Didea.version=2023.1.1 package
[INFO] Scanning for projects...
[INFO] 
[INFO] ---------------------------< Others:Others >----------------------------
[INFO] Building Others 1.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO] 
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ Others ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] Copying 0 resource
[INFO] 
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ Others ---
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 9 source files to D:\IDEA\Others\target\classes
[INFO] 
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ Others ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] skip non existing resourceDirectory D:\IDEA\Others\src\test\resources
[INFO] 
[INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ Others ---
[INFO] Nothing to compile - all classes are up to date
[INFO] 
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ Others ---
[INFO] No tests to run.
[INFO] 
[INFO] --- maven-jar-plugin:3.2.0:jar (default-jar) @ Others ---
[INFO] Building jar: D:\IDEA\Others\target\Others-1.0-SNAPSHOT.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  3.358 s
[INFO] Finished at: 2023-09-16T01:49:31+08:00
[INFO] ------------------------------------------------------------------------

Process finished with exit code 0
ChatGPT：
根据您提供的构建日志，看起来构建是成功的，并且生成了 JAR 文件。因此，问题可能不在于依赖没有打包进来。
为了确认依赖是否正确打包进 JAR 文件，您可以执行以下步骤：
  1. 打开生成的 JAR 文件：您可以使用压缩工具（如 WinRAR 或 7-Zip）打开 D:\IDEA\Others\target\Others-1.0-SNAPSHOT.jar 文件，然后查看其中是否包含依赖 JAR 文件。如果依赖正确打包进来，您应该能够在 JAR 文件的根目录下看到 lib 文件夹，其中包含所有的依赖 JAR 文件。
  2. 验证 Classpath：确保 JAR 文件的 META-INF/MANIFEST.MF 文件中正确设置了 Classpath，以包含依赖 JAR 文件。在构建日志中没有看到关于 Classpath 的信息，因此需要手动验证。
    • 使用压缩工具打开 JAR 文件。
    • 找到 META-INF/MANIFEST.MF 文件。
    • 检查 Class-Path 部分，确保它包含了依赖 JAR 文件的路径。
如果 JAR 文件包含了依赖并且 Classpath 配置正确，那么依赖应该能够在运行时正确加载。如果问题仍然存在，请提供更多关于您的项目结构和代码的详细信息，以便我能够更深入地了解问题所在。
没有lib文件夹，也没有Classpath
ChatGPT：
如果您的 JAR 文件没有包含依赖的 JAR 文件或没有 Classpath 信息，那么问题可能是在打包配置中出现了问题。
在 Maven 中，您可以使用 Maven 插件来创建可运行的 JAR 文件，以确保依赖正确打包进来并配置了 Classpath。为此，您可以使用 maven-shade-plugin 插件。
请按照以下步骤配置 maven-shade-plugin：
  1. 在 pom.xml 中添加 maven-shade-plugin 插件的配置：
    <build>
    <plugins>
        <!-- 其他插件配置 -->

        <!-- 配置maven-shade-plugin -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <version>3.2.4</version> <!-- 使用最新版本的 maven-shade-plugin -->
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                    <configuration>
                        <!-- 设置主类 -->
                        <transformers>
                            <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                <mainClass>您的主类</mainClass>
                            </transformer>
                        </transformers>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>
    确保将 <mainClass>您的主类</mainClass> 替换为您的主类的完整路径。
  2. 执行 Maven 构建：
    mvn clean package
    这将使用 maven-shade-plugin 打包您的项目，并生成包含依赖和正确配置 Classpath 的可运行 JAR 文件。
  3. 验证生成的 JAR 文件：
    再次使用压缩工具打开生成的 JAR 文件，并检查是否包含依赖 JAR 文件以及是否配置了 Classpath。如果一切正常，您的 JAR 文件应该已经包含依赖并设置了 Classpath。
通过这种方式，您可以确保依赖正确地打包进 JAR 文件，以便在运行时能够正确加载。
有其他方法吗
ChatGPT：
除了使用 maven-shade-plugin 插件外，还有其他一些方法可以将依赖项打包到可运行的 JAR 文件中：
  1. 使用 Maven Assembly 插件：Maven 提供了 maven-assembly-plugin 插件，它允许您配置自定义的 JAR 打包组装。您可以定义一个包含依赖的组装描述文件，然后使用该插件来创建可运行的 JAR 文件。以下是一个示例 maven-assembly-plugin 的配置：
    <build>
    <plugins>
        <!-- 其他插件配置 -->

        <!-- 配置maven-assembly-plugin -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>3.3.0</version> <!-- 使用最新版本的 maven-assembly-plugin -->
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                    <configuration>
                        <descriptorRefs>
                            <descriptorRef>jar-with-dependencies</descriptorRef>
                        </descriptorRefs>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>
    这将创建一个包含所有依赖项的 JAR 文件。
  2. 使用 Spring Boot：如果您的项目是基于 Spring Boot 构建的，Spring Boot 提供了内置的方式来创建可执行的 JAR 文件，其中包括依赖项。Spring Boot 使用 spring-boot-maven-plugin 插件来完成这个任务。
    如果您的项目可以迁移到 Spring Boot，那么它会自动处理依赖项的打包和配置 Classpath。
  3. 手动构建可运行的 JAR 文件：您也可以手动创建可运行的 JAR 文件。这涉及到创建一个包含所有依赖项的目录结构，并编写一个启动脚本，以便在运行时将依赖项添加到 Classpath。这种方法相对复杂，但可以更精确地控制 JAR 文件的构建过程。
无论您选择哪种方法，确保在生成的 JAR 文件中包含了依赖项，并且配置了正确的 Classpath，以便在运行时能够正确加载依赖项。
这个不用设置主类吗
ChatGPT：
对于使用 maven-assembly-plugin 或 Spring Boot 的方法，不需要显式设置主类，因为这些插件会自动处理可执行 JAR 的配置。这些插件会在生成的 JAR 文件的清单（MANIFEST.MF）中添加必要的信息，包括主类的指定。
对于 maven-assembly-plugin，使用 descriptorRef 设置为 "jar-with-dependencies" 时，插件会自动查找项目的主类并将其添加到清单中。
对于 Spring Boot，Spring Boot 插件会自动检测项目的主类（通常是带有 public static void main 方法的类）并设置清单中的 Main-Class 属性。
如果您使用这些方法，只需确保项目的结构和配置正确，插件将自动处理主类和依赖项。这减少了手动配置的需要。
如果我想手动设置呢
ChatGPT：
如果您想手动设置主类，您可以在 Maven 插件配置中的 <configuration> 部分添加 mainClass 元素，显式指定主类的完整类名。以下是手动设置主类的示例配置：
<build>
    <plugins>
        <!-- 其他插件配置 -->

        <!-- 配置maven-assembly-plugin，手动设置主类 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>3.3.0</version> <!-- 使用最新版本的 maven-assembly-plugin -->
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                    <configuration>
                        <descriptorRefs>
                            <descriptorRef>jar-with-dependencies</descriptorRef>
                        </descriptorRefs>
                        <!-- 手动设置主类 -->
                        <archive>
                            <manifest>
                                <mainClass>com.example.MainClass</mainClass>
                            </manifest>
                        </archive>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>
请将 <mainClass> 元素中的 com.example.MainClass 替换为您的主类的完整类名。这样配置后，插件将在生成的 JAR 文件的清单中设置指定的主类。
请注意，手动设置主类时，确保指定的类包含 public static void main(String[] args) 方法，否则 JAR 文件将无法正常运行。
为什么会生成两个jar包
ChatGPT：
在 Maven 项目中生成两个 JAR 包通常是由于配置文件中存在多个 Maven 插件引发的。请检查您的 Maven 项目配置文件（通常是 pom.xml 文件）以查看是否存在重复的插件配置。
常见的原因之一是在 pom.xml 文件中同时配置了 maven-jar-plugin 和 maven-assembly-plugin，这两个插件都用于生成 JAR 文件。如果您不小心同时配置了这两个插件，它们可能都会生成 JAR 文件，从而导致生成两个 JAR 包。
请检查您的 pom.xml 文件，确保只配置了一个用于生成 JAR 文件的插件。如果需要，删除或注释掉不需要的插件配置。然后重新运行 Maven 构建命令，以确保只生成一个正确的 JAR 文件。
如果仍然存在问题，请提供您的 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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>

 <groupId>Others</groupId>
 <artifactId>Others</artifactId>
 <version>1.0-SNAPSHOT</version>

 <properties>
     <java.version>1.8</java.version>

     <maven.compiler.source>8</maven.compiler.source>
     <maven.compiler.target>8</maven.compiler.target>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 </properties>

 <dependencies>

     <dependency>
         <groupId>cn.hutool</groupId>
         <artifactId>hutool-all</artifactId>
         <version>5.8.16</version>
     </dependency>

     <dependency>
         <groupId>com.alibaba</groupId>
         <artifactId>easyexcel</artifactId>
         <version>3.0.5</version>
         <!--            <exclusions>-->
         <!--                <exclusion>-->
         <!--                    <groupId>org.slf4j</groupId>-->
         <!--                    <artifactId>slf4j-api</artifactId>-->
         <!--                </exclusion>-->
         <!--            </exclusions>-->
     </dependency>

     <!--Jsoup解析网页-->
     <dependency>
         <groupId>org.jsoup</groupId>
         <artifactId>jsoup</artifactId>
         <version>1.10.2</version>
     </dependency>

     <dependency>
         <groupId>com.alibaba</groupId>
         <artifactId>fastjson</artifactId>
         <version>1.2.41</version>
     </dependency>

     <dependency>
         <groupId>org.projectlombok</groupId>
         <artifactId>lombok</artifactId>
         <version>1.18.22</version>
     </dependency>

 </dependencies>

 <build>
     <plugins>
         <!-- 配置maven-assembly-plugin，手动设置主类 -->
         <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-assembly-plugin</artifactId>
             <version>3.3.0</version> <!-- 使用最新版本的 maven-assembly-plugin -->
             <executions>
                 <execution>
                     <phase>package</phase>
                     <goals>
                         <goal>single</goal>
                     </goals>
                     <configuration>
                         <descriptorRefs>
                             <descriptorRef>jar-with-dependencies</descriptorRef>
                         </descriptorRefs>
                         <!-- 手动设置主类 -->
                         <archive>
                             <manifest>
                                 <mainClass>HtmlParseUtil</mainClass>
                             </manifest>
                         </archive>
                     </configuration>
                 </execution>
             </executions>
         </plugin>
     </plugins>
 </build>

</project>
ChatGPT：
根据您的 pom.xml 文件，您配置了 maven-assembly-plugin 插件来生成一个包含依赖的可执行 JAR 文件，并设置了主类为 HtmlParseUtil。这个配置是正确的，它应该生成一个包含依赖的 JAR 文件，其中包含了您的主类。
但是，如果您看到生成了两个 JAR 文件，一个是原始的 JAR 文件，另一个是包含依赖的 JAR 文件，那么可能是因为 Maven 默认情况下会同时生成原始 JAR 文件和附加的 JAR 文件。原始 JAR 文件没有依赖项，而附加的 JAR 文件包含依赖项。
您可以尝试在 maven-assembly-plugin 插件的配置中指定生成的 JAR 文件名称，以避免生成原始 JAR 文件。例如，将 finalName 设置为与附加的 JAR 文件相同的名称：
<build>
    <plugins>
        <!-- 配置maven-assembly-plugin，手动设置主类 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>3.3.0</version>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                    <configuration>
                        <finalName>${project.build.finalName}</finalName>
                        <descriptorRefs>
                            <descriptorRef>jar-with-dependencies</descriptorRef>
                        </descriptorRefs>
                        <!-- 手动设置主类 -->
                        <archive>
                            <manifest>
                                <mainClass>HtmlParseUtil</mainClass>
                            </manifest>
                        </archive>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>
这将确保只生成附加的 JAR 文件，并且其名称将与项目的最终名称相匹配。
请尝试修改配置并重新运行 Maven 构建，查看是否只生成一个包含依赖的 JAR 文件。
XRT_knives
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Maven 生成打包可执行jar包的方法步骤
09-07
主要介绍了Maven 生成打包可执行jar包的方法步骤，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
使用maven生成可执行的jar包的方法
08-27
主要介绍了使用maven生成可执行的jar包的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
spring-boot-maven-plugin：打包时排除provided依赖
lyterrific的博客
11-30 7922
spring-boot-maven-plugin 插件提供spring boot的maven打包支持。项目中scope为provided的依赖，比如 lombok、mybatis-plus 等，只作用于编译阶段，编译完成就可以功成身退了。在spring maven打包时，provided依赖会排除在包外，但springboot maven打包时，还会将这些依赖打进 war 包的 lib-provided 文件夹里或 jar 包的 lib 文件夹里。 springboot项目构建jar包或war包的命令为re
Maven 打包 设置运行主类
不再更新，新博客 chgl16.space
05-10 7441
Maven 运行 mvn clean package 命令打包在target目录下生成jar包，如何没有配置指定主类，运行jar会报错，如下lin@lin-laptop:~/测试项目/mvnstudy1/mvnstudy1$ java target/mvnstudy1-1.0-SNAPSHOT.jar 错误: 找不到或无法加载主类 target.mvnstudy1-1.0-SNAPSHOT.jar...
Maven打包设置主类
qq_42790479的博客
01-12 1744
Maven 打包设置主类 <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-shade-plugin</artifactId> <version>2...
maven 打jar包指定主类Main Class插件配置
学亮编程手记
03-05 5504
<plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-shade-plugin</artifactId> <version>1.2.1</version> <executions> ...
Maven 打包可运行jar包
热门推荐
【设计改变世界】github地址：https://github.com/guochunyang2004
09-28 1万+
Maven可以使用mvn package指令对项目进行打包，如果使用Java -jar xxx.jar执行运行jar文件，会出现"no main manifest attribute, in xxx.jar"（没有设置Main-Class）、ClassNotFoundException（找不到依赖包）等错误。要想jar包能直接通过java -jar xxx.jar运行，需要满足：1、在jar包中的META-INF/MANIFEST.MF中指定Main-Class，这样才能确定程序的入口在哪里；
maven项目打jar包时指定主类，并将依赖也打进来
最新发布
qq_41502445的博客
04-14 824
maven打jar包，指定主类并将依赖也打进来
maven对java项目打包，如何通过maven打包依赖jar，打包主类，在pom.xml中设置
巨魔战将
11-04 4018
设置位置 &lt;build&gt; &lt;plugins&gt; 在此处添加 &lt;/plugins&gt; &lt;/build&gt; maven编译时即打包main class主类，有打包依赖jar &lt;!-- maven jar in main class and dependencies start --&gt; ...
【Java】快速接入ChatGPT API实现聊天、生成图像
提笔忘字的帝国
03-28 9583
快速接入ChatGPT API实现聊天、生成图像
Springboot使用maven打包指定mainClass
wuweiforever的博客
03-13 2230
在 springboot 项目中，除了启动类的主函数 mainclass，如果还出现其他的 main 方法，本地运行是没有任何问题，但是在打包 package 时，就会报错，说 repackage 时，在项目中有多个候选的主方法。
详解如何使用maven生成可以执行的jar
08-27
主要介绍了详解如何使用maven生成可以执行的jar，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Maven项目打包成可执行Jar文件步骤解析
08-19
主要介绍了Maven项目如何打包成可执行Jar文件,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Maven如何构建可执行的jar包(包含依赖jar包)
08-26
主要介绍了Maven如何构建可执行的jar包(包含依赖jar包) ，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
maven插件打包jar设定主类
菜鸟零号 kungfu~peng
04-16 4309
maven插件打包jar设定主类 <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-sh...
java应用程序发布jar2的2种方式 1.assembly.xml(线上) 2.fat-jar(工具类的发布)
focus-unchanged-thing
03-31 676
nohup java -jar xxx.jar>log.txt &
maven封装jar,得到所有依赖,及设置主类
bfqiwbifj的专栏
06-21 3497
maven打包jar,得到所有依赖,及设置主类 　　pom中加入 　　 　 　 　 　 org.apache.maven.plugins 　 　 　 　 maven-jar-plugin 　 　 　 　 　 　 　 　 　 　 　 　 　 　 　 　 　 　 　 　 　 　 true 　 　 　 　 　 　 　 youmainclasspath 　 　 　 　 　
springboot 打包(maven) 指定唯一主类
Rain___Blue的博客
05-14 1332
springboot 程序打包时会扫描包找到被 SpringBootApplication 注解标识的类作为主类. 如果存在多个这样的类会报不能找到唯一主类异常(通常只会有一个，偶尔骚操作会建多个 【手动滑稽】)，这时可以通过springboot maven 打包插件指定打包使用的主类(写进pom.xml里)。 <plugin> <groupId>org.springframework.boot</groupId> <artifactId>sp
【基于ChatGPT+SpringBoot】打造智能聊天AI机器人接口并上线至服务器
大数据小禅的博客
01-02 9050
ChatGPT是一款基于自然语言处理技术的聊天机器人。它使用受控语料库，并使用最先进的深度学习技术来学习用户的输入，以便以最相似的方式回应。ChatGPT可以模拟真实的人类对话，并能够更贴近用户的需求，提供更有价值的服务。Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。
maven生成可执行jar包
03-21
可以使用maven-assembly-plugin插件来生成可执行的jar包。在pom.xml文件中添加以下配置： ``` <build> <plugins> <plugin> <artifactId>maven-assembly-plugin</artifactId> <version>3.1.1</version> <configuration> <archive> <manifest> <mainClass>com.example.MainClass</mainClass> </manifest> </archive> <descriptorRefs> <descriptorRef>jar-with-dependencies</descriptorRef> </descriptorRefs> </configuration> <executions> <execution> <id>make-assembly</id> <phase>package</phase> <goals> <goal>single</goal> </goals> </execution> </executions> </plugin> </plugins> </build> ``` 其中，`com.example.MainClass`是你的主类名，`jar-with-dependencies`表示将所有依赖打包到生成的jar包中。 执行`mvn clean package`命令即可生成可执行的jar包。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值