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

最新推荐文章于 2024-08-21 17:30:36 发布
最新推荐文章于 2024-08-21 17:30:36 发布
阅读量1k 收藏 2
点赞数 1
分类专栏： # 编程之路 文章标签： 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
关注
专栏目录
maven将项目打成jar包默认启动指定类的main方法
猿小白的博客
05-24 895
在 Java 开发中，使用 Maven 进行项目管理和构建是非常常见的需求。本文将介绍如何使用 Maven 将项目打包为 JAR 文件，并指定一个默认的启动类，使得在运行 JAR 文件时能够自动执行该类的main方法。
Maven 生成打包可执行jar包的方法步骤
09-07
本文将详细讲解如何使用Maven生成可执行的JAR包，以满足特定的需求。 首先，我们来看一下生成可执行JAR包的需求： 1. 整个项目被打包成一个ZIP文件，包含应用程序、其依赖的JAR包和说明文档。 2. JAR包应可执行，...
使用Maven为一个项目生成多个Jar包
07-28 1971
http://agiledon.github.io/blog/2013/11/10/create-two-jars-from-one-project-using-maven/
Maven构建可运行jar包
最新发布
victor_zxl的博客
08-21 1436
Maven可以使用指令对项目进行打包生成jar文件，如果直接使用指令运行jar文件，会出现“no main manifest attribute, in xxx.jar”或“xxx.jar中没有主清单属性”（没有设置Main-Class）、ClassNotFoundException（找不到依赖包）等错误。要想jar包能直接通过使用Maven有以下几种方法可以生成满足以上两个条件能直接运行的jar包，可以根据需要选择一种合适的方法。
maven 生成可执行jar
野生C猿的专栏
02-27 728
默认的maven pom文件build出来的jar包是不能直接用java -jar 命令执行的 需要加入以下配置 [html] view plaincopy build>     plugins>          plugin>           groupId>org.apache.maven.pluginsgroupId> 
maven项目打jar包时指定主类，并将依赖也打进来
qq_41502445的博客
04-14 922
maven打jar包，指定主类并将依赖也打进来
maven指定主类
我的备忘录
05-10 1303
maven工程. 有时候一个jar包只有一种功能, 又懒得记住执行它的主类名称, 所以希望执行时能自动执行它的主类. 可以自己写MANIFEST.MF文件来配置主类. 在pom.xml中的project标签下添加 <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifa
详解如何使用maven生成可以执行的jar
08-27
"使用Maven生成可执行JAR包" Maven是一款流行的Java构建工具，它可以帮助开发者自动化编译、测试、打包和部署Java项目。今天，我们将讨论如何使用Maven生成可执行JAR包。 什么是可执行JAR包？ 可执行JAR包是一种...
maven生成可执行jar命令
08-17
本文将详细介绍如何利用Maven生成可执行的JAR文件，并部署至服务器直接运行。 #### Maven简介 Maven是由Apache软件基金会维护的一个软件项目管理工具，它通过一个中心信息来管理项目的构建、报告和文档的工具。...
使用maven生成可执行的jar包的方法
08-27
在执行mvn install命令时，Maven将根据POM文件的配置生成一个可执行的JAR包。在target目录中，我们可以找到生成的JAR包。 使用Java Decompiler工具，可以看到生成的JAR包中的manifest文件已经包含了MainClass元素：...
protoc-jar-maven-plugin:协议缓冲区protobuf maven插件-基于protoc-jar多平台可执行文件protoc JAR
04-29
协议缓冲区protobuf maven插件-使用多平台可执行协议protoc JAR执行protobuf代码生成。 在Maven Central上可用： : 简单的maven插件，可使用protoc 嵌入式protoc编译器来编译.proto文件，从而在主要平台（Linux，...
maven打可执行JAR包
04-23
maven打jar包方法 并且java -jar *.jar可执行
Maven打包设置主类
qq_42790479的博客
01-12 1831
Maven 打包设置主类 <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-shade-plugin</artifactId> <version>2...
Maven 打包 设置运行主类
不再更新，新博客 chgl16.space
05-10 7535
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...
java应用程序发布jar2的2种方式 1.assembly.xml(线上) 2.fat-jar(工具类的发布)
focus-unchanged-thing
03-31 738
nohup java -jar xxx.jar>log.txt &
Maven项目打包指定jar主类,jar包打包包含依赖jar文件
m0_47373281的博客
04-23 1078
Maven项目打包指定jar主类,jar包打包包含依赖jar文件
maven打jar包指定核心运行的main class的配置
douyunqian668的博客
07-02 5292
 &lt;build&gt;  &lt;plugins&gt;  &lt;plugin&gt;  &lt;groupId&gt;org.apache.maven.plugins&lt;/groupId&gt;  &lt;artifactId&gt;maven-shade-plugin&lt;/artifactId&gt;  &lt;version&gt;1.
Maven打可执行jar包
weixin_44129801的博客
03-23 1102
1. 需求 maven默认package打包, 只包含项目代码, 没有引入项目代码依赖的lib包, 执行时缺包 那么如何将依赖的lib文件打进jar包呢? 2. Assembly插件 assembly插件用于maven工程打包, 将项目代码与依赖lib包打进一个jar文件中 单词: assembly, 组装, the process of putting together the parts of sth such as a vehicle or piece of furniture The Ass
maven编译可执行jar包
狂奔的蜗牛
01-08 803
maven编译可执行jar包
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值