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

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
2

请注意以下几点：

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.pluginsgroupId>
            <artifactId>maven-jar-pluginartifactId>
            <version>3.2.0version> 

            <configuration>
                <archive>
                    <manifest>
                        
                        <mainClass>com.example.YourMainClassmainClass>
                    manifest>
                archive>
            configuration>
        plugin>
    plugins>
build>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

上述配置中，我们使用了maven-jar-plugin插件，并在其配置中指定了主清单属性。请将com.example.YourMainClass替换为您的应用程序的实际入口类的完全限定类名。

当您运行mvn clean package或mvn install等Maven构建命令时，该插件将会生成包含指定主清单属性的JAR文件。

确保在pom.xml文件的元素下的中添加了上述的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 插件的 元素来指定自定义的 MANIFEST.MF 条目，其中包括作者信息。

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.pluginsgroupId>
            <artifactId>maven-jar-pluginartifactId>
            <version>3.2.0version> 

            <configuration>
                <archive>
                    <manifest>
                        <addDefaultImplementationEntries>trueaddDefaultImplementationEntries>
                        <addDefaultSpecificationEntries>trueaddDefaultSpecificationEntries>
                        <manifestEntries>
                            
                            <Created-By>Your NameCreated-By>
                        manifestEntries>
                    manifest>
                archive>
            configuration>
        plugin>
    plugins>
build>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

上述配置中，我们在 maven-jar-plugin 的 元素下添加了 条目，用于指定作者信息。请将 "Your Name" 替换为实际的作者名字或信息。

然后，运行 Maven 构建命令（如 mvn clean package 或 mvn install）以重新构建您的项目。生成的 JAR 文件中的 MANIFEST.MF 文件应该包含您指定的作者信息。

请注意， 和 元素分别用于添加默认的实现和规范条目，具体取决于您的需求是否需要它们。如果不需要这些默认条目，可以将它们设置为 false。

最后生成的 MANIFEST.MF 文件可能如下所示：

Manifest-Version: 1.0
Created-By: Your Name
1
2

这样就成功在 MANIFEST.MF 文件中添加了作者信息。

---

为什么打包的时候依赖没有打包进来

ChatGPT：

如果在打包时依赖没有正确打包进来，可能有以下几个常见的原因：

1. 依赖范围问题：Maven 依赖可以有不同的范围，如 compile、runtime、test 等。默认情况下，只有 compile 范围的依赖会被打包进 JAR 文件。确保您的依赖的范围正确，如果需要在运行时和编译时都使用它们，应将它们放在 compile 范围中。

   <dependencies>
       <dependency>
           <groupId>com.examplegroupId>
           <artifactId>dependency-artifactartifactId>
           <version>1.0.0version>
           
           <scope>compilescope>
       dependency>
   dependencies>
   1
   2
   3
   4
   5
   6
   7
   8
   9

2. 构建配置问题：确保 Maven 构建配置文件 pom.xml 中没有排除依赖的配置。在 部分内，确保没有使用 标签排除依赖。

   <dependencies>
       <dependency>
           <groupId>com.examplegroupId>
           <artifactId>your-dependencyartifactId>
           <version>1.0.0version>
           
       dependency>
   dependencies>
   1
   2
   3
   4
   5
   6
   7
   8

3. Clean 构建：在执行 Maven 构建之前，可以尝试运行 mvn clean 命令，以清除旧的构建文件和依赖，然后再运行 mvn package 或其他构建命令。

4. 依赖不在 Maven 仓库中：确保您的依赖已经上传到 Maven 仓库或者在您的本地 Maven 仓库中存在。如果依赖没有正确发布到仓库，Maven 将无法找到它并将其打包到项目中。

5. 依赖版本问题：检查依赖的版本号是否正确。如果版本号不匹配，Maven 可能无法正确解析依赖并将其打包。

6. IDE 缓存问题：有时 IDE 可能会缓存依赖信息，如果缓存过期或损坏，可能导致依赖无法正确加载。尝试清除 IDE 缓存并重新构建项目。

如果您仍然遇到问题，建议检查 Maven 构建日志以查看详细的错误信息，以便更好地了解问题所在。此外，可以使用 Maven 命令行来构建项目，以排除 IDE 的因素。

---

这是我的pom文件：

<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.0modelVersion>

 <groupId>OthersgroupId>
 <artifactId>OthersartifactId>
 <version>1.0-SNAPSHOTversion>

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

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

 <dependencies>

     <dependency>
         <groupId>cn.hutoolgroupId>
         <artifactId>hutool-allartifactId>
         <version>5.8.16version>
     dependency>

     <dependency>
         <groupId>com.alibabagroupId>
         <artifactId>easyexcelartifactId>
         <version>3.0.5version>
         
         
         
         
         
         
     dependency>

     
     <dependency>
         <groupId>org.jsoupgroupId>
         <artifactId>jsoupartifactId>
         <version>1.10.2version>
     dependency>

     <dependency>
         <groupId>com.alibabagroupId>
         <artifactId>fastjsonartifactId>
         <version>1.2.41version>
     dependency>

     <dependency>
         <groupId>org.projectlombokgroupId>
         <artifactId>lombokartifactId>
         <version>1.18.22version>
     dependency>

 dependencies>

 <build>
     <plugins>
         <plugin>
             <groupId>org.apache.maven.pluginsgroupId>
             <artifactId>maven-jar-pluginartifactId>
             <version>3.2.0version> 

             <configuration>
                 <archive>
                     <manifest>
                         
                         <mainClass>HtmlParseUtilmainClass>
                     manifest>
                 archive>
             configuration>
         plugin>
     plugins>
 build>

project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

ChatGPT：

根据您提供的 pom.xml 文件，依赖看起来是正确配置的，而且也没有排除任何依赖。这通常意味着依赖应该被正确地打包进您的 JAR 文件中。

如果在构建过程中仍然遇到依赖未正确打包的问题，您可以尝试以下步骤来排除问题：

1. 清理并重新构建：首先尝试运行以下命令清理项目并重新构建：

   mvn clean package
   1

   这将会清理之前生成的构建文件，并重新生成 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

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>
           
   
           
           <plugin>
               <groupId>org.apache.maven.pluginsgroupId>
               <artifactId>maven-shade-pluginartifactId>
               <version>3.2.4version> 
               <executions>
                   <execution>
                       <phase>packagephase>
                       <goals>
                           <goal>shadegoal>
                       goals>
                       <configuration>
                           
                           <transformers>
                               <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                   <mainClass>您的主类mainClass>
                               transformer>
                           transformers>
                       configuration>
                   execution>
               executions>
           plugin>
       plugins>
   build>
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28

   确保将 您的主类 替换为您的主类的完整路径。

2. 执行 Maven 构建：

   mvn clean package
   1

   这将使用 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>
           
   
           
           <plugin>
               <groupId>org.apache.maven.pluginsgroupId>
               <artifactId>maven-assembly-pluginartifactId>
               <version>3.3.0version> 
               <executions>
                   <execution>
                       <phase>packagephase>
                       <goals>
                           <goal>singlegoal>
                       goals>
                       <configuration>
                           <descriptorRefs>
                               <descriptorRef>jar-with-dependenciesdescriptorRef>
                           descriptorRefs>
                       configuration>
                   execution>
               executions>
           plugin>
       plugins>
   build>
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25

   这将创建一个包含所有依赖项的 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 插件配置中的 部分添加 mainClass 元素，显式指定主类的完整类名。以下是手动设置主类的示例配置：

<build>
    <plugins>
        

        
        <plugin>
            <groupId>org.apache.maven.pluginsgroupId>
            <artifactId>maven-assembly-pluginartifactId>
            <version>3.3.0version> 
            <executions>
                <execution>
                    <phase>packagephase>
                    <goals>
                        <goal>singlegoal>
                    goals>
                    <configuration>
                        <descriptorRefs>
                            <descriptorRef>jar-with-dependenciesdescriptorRef>
                        descriptorRefs>
                        
                        <archive>
                            <manifest>
                                <mainClass>com.example.MainClassmainClass>
                            manifest>
                        archive>
                    configuration>
                execution>
            executions>
        plugin>
    plugins>
build>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

请将 元素中的 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 文件的内容，以便我更详细地检查并提供帮助。

---

<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.0modelVersion>

 <groupId>OthersgroupId>
 <artifactId>OthersartifactId>
 <version>1.0-SNAPSHOTversion>

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

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

 <dependencies>

     <dependency>
         <groupId>cn.hutoolgroupId>
         <artifactId>hutool-allartifactId>
         <version>5.8.16version>
     dependency>

     <dependency>
         <groupId>com.alibabagroupId>
         <artifactId>easyexcelartifactId>
         <version>3.0.5version>
         
         
         
         
         
         
     dependency>

     
     <dependency>
         <groupId>org.jsoupgroupId>
         <artifactId>jsoupartifactId>
         <version>1.10.2version>
     dependency>

     <dependency>
         <groupId>com.alibabagroupId>
         <artifactId>fastjsonartifactId>
         <version>1.2.41version>
     dependency>

     <dependency>
         <groupId>org.projectlombokgroupId>
         <artifactId>lombokartifactId>
         <version>1.18.22version>
     dependency>

 dependencies>

 <build>
     <plugins>
         
         <plugin>
             <groupId>org.apache.maven.pluginsgroupId>
             <artifactId>maven-assembly-pluginartifactId>
             <version>3.3.0version> 
             <executions>
                 <execution>
                     <phase>packagephase>
                     <goals>
                         <goal>singlegoal>
                     goals>
                     <configuration>
                         <descriptorRefs>
                             <descriptorRef>jar-with-dependenciesdescriptorRef>
                         descriptorRefs>
                         
                         <archive>
                             <manifest>
                                 <mainClass>HtmlParseUtilmainClass>
                             manifest>
                         archive>
                     configuration>
                 execution>
             executions>
         plugin>
     plugins>
 build>

project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

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>
        
        <plugin>
            <groupId>org.apache.maven.pluginsgroupId>
            <artifactId>maven-assembly-pluginartifactId>
            <version>3.3.0version>
            <executions>
                <execution>
                    <phase>packagephase>
                    <goals>
                        <goal>singlegoal>
                    goals>
                    <configuration>
                        <finalName>${project.build.finalName}finalName>
                        <descriptorRefs>
                            <descriptorRef>jar-with-dependenciesdescriptorRef>
                        descriptorRefs>
                        
                        <archive>
                            <manifest>
                                <mainClass>HtmlParseUtilmainClass>
                            manifest>
                        archive>
                    configuration>
                execution>
            executions>
        plugin>
    plugins>
build>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

这将确保只生成附加的 JAR 文件，并且其名称将与项目的最终名称相匹配。

请尝试修改配置并重新运行 Maven 构建，查看是否只生成一个包含依赖的 JAR 文件。

---