Maven 中的 pom.xml 文件

sco5282

已于 2025-05-17 16:43:30 修改

阅读量1.1k

点赞数 24

分类专栏： Maven 文章标签： maven xml java

于 2025-05-11 18:37:13 首次发布

本文链接：https://blog.csdn.net/sco5282/article/details/147716319

版权

Maven 专栏收录该内容

1 篇文章

订阅专栏

目录标题

1、根标签 `<project>` 的直接子标签顺序
2、常见子标签内部顺序
- 2.1、`<build>` 标签内部顺序
- 2.2、`<dependencies>` 标签内部顺序
3、modelVersion 为什么是 4.0.0 ？
4、`<parent>` 标签？
5、`packaging` 标签
6、dependencyManagement 标签 & dependencies 标签
7、build 标签
- 7.1、子模块打包成可依赖
- - 7.1.1、子模块只提供可依赖 JAR
  - 7.1.2、子模块同时提供可执行 JAR 和可依赖 JAR
8、profiles 标签
9、resources 标签
10、创建一个聚合工程

1、根标签 `<project>` 的直接子标签顺序

pom 标签格式：Maven POM XSD Schema

<project>
    <!-- 必填标签 -->
    <modelVersion>4.0.0</modelVersion>       <!-- 必须为 4.0.0 -->
    <parent></parent>                       <!-- 可选 -->
    <groupId>com.example</groupId>          <!-- 项目组标识 -->
    <artifactId>my-project</artifactId>      <!-- 项目唯一标识 -->
    <version>1.0.0</version>                 <!-- 版本号 -->
    <packaging>jar</packaging>               <!-- 打包类型，默认为 jar -->

    <!-- 可选标签 -->
    <name>My Project</name>                 <!-- 项目显示名称 -->
    <description>...</description>          <!-- 项目描述 -->
    <url>http://example.com</url>           <!-- 项目主页 -->
    <inceptionYear>2023</inceptionYear>     <!-- 项目创建年份 -->
    <organization>...</organization>        <!-- 组织信息 -->
    <licenses>...</licenses>                <!-- 许可证 -->
    <developers>...</developers>            <!-- 开发者列表 -->
    <contributors>...</contributors>       <!-- 贡献者列表 -->
    <mailingLists>...</mailingLists>        <!-- 邮件列表 -->
    <prerequisites>...</prerequisites>      <!-- Maven 版本要求 -->
    <modules>...</modules>                  <!-- 多模块项目子模块 -->
    <scm>...</scm>                          <!-- 版本控制信息 -->
    <issueManagement>...</issueManagement>  <!-- 问题跟踪系统 -->
    <ciManagement>...</ciManagement>        <!-- 持续集成配置 -->
    <distributionManagement>...</distributionManagement>  <!-- 部署配置 -->
    <properties>...</properties>            <!-- 自定义属性 -->
    <dependencyManagement>...</dependencyManagement>  <!-- 依赖管理 -->
    <dependencies>...</dependencies>        <!-- 项目依赖 -->
    <repositories>...</repositories>        <!-- 远程仓库 -->
    <pluginRepositories>...</pluginRepositories>  <!-- 插件仓库 -->
    <build>...</build>                      <!-- 构建配置 -->
    <reporting>...</reporting>              <!-- 报告插件配置 -->
    <profiles>...</profiles>                <!-- 多环境配置 -->
</project>

2、常见子标签内部顺序

2.1、`<build>` 标签内部顺序

<build>
    <sourceDirectory>...</sourceDirectory>
    <scriptSourceDirectory>...</scriptSourceDirectory>
    <testSourceDirectory>...</testSourceDirectory>
    <outputDirectory>...</outputDirectory>
    <testOutputDirectory>...</testOutputDirectory>
    <extensions>...</extensions>
    <defaultGoal>...</defaultGoal>
    <resources>...</resources>
    <testResources>...</testResources>
    <directory>...</directory>
    <finalName>...</finalName>
    <filters>...</filters>
    <pluginManagement>...</pluginManagement>
    <plugins>...</plugins>
</build>

2.2、`<dependencies>` 标签内部顺序

每个的标签顺序：

<dependency>
    <groupId>...</groupId>
    <artifactId>...</artifactId>
    <version>...</version>
    <type>...</type>
    <classifier>...</classifier>
    <scope>...</scope>
    <systemPath>...</systemPath>
    <exclusions>...</exclusions>
    <optional>...</optional>
</dependency>

3、modelVersion 为什么是 4.0.0 ？

Maven 项目对象模型（POM）使用 XML 文件来描述项目配置。modelVersion 元素指定了 POM 模型使用的版本。Maven 2 和 3 都使用 4.0.0 作为 modelVersion，因为 POM 模型的结构在 Maven 2 发布时已经稳定，之后没有重大变更，所以版本号保持不变

Maven 官方文档中提到，从 Maven 2.0 开始，modelVersion一直是 4.0.0。即使 Maven 升级到 3.x，POM 模型的结构没有大的改变，所以不需要更新 modelVersion。这可能是因为向后兼容性考虑，或者模型本身已经足够成熟，不需要修改

历史背景：

Maven 1.x 使用的 POM 模型版本是 3.0.0，但该版本已废弃\
Maven 2.x 在 2006 年发布时，引入了全新的 POM 模型版本 4.0.0（简化了依赖管理、插件机制等），并沿用至今
Maven 3.x 完全兼容 4.0.0 模型，仅优化了内部实现（如性能、错误处理），未改动 POM 结构

4、`<parent>` 标签？

4.1、为什么需要 `<parent>` 标签？

<parent> 标签可选但常见的配置【重要】

继承统一配置：父 POM 可以定义子模块共用的依赖、插件、属性、仓库等信息，避免重复配置。
依赖管理：通过 <dependencyManagement> 统一管理依赖版本。
插件管理：通过 <pluginManagement> 统一管理插件版本和配置。
多模块项目：在聚合项目（<modules>）中，父 POM 通常用于组织子模块。

4.2、实践：

显式声明父 POM 的 <relativePath>：若父 POM 未发布到仓库，需通过相对路径定位
避免过度继承：仅继承必要的配置，保持 POM 简洁
优先使用 BOM（Bill of Materials）：对于依赖版本管理，可结合 <dependencyManagement> 导入 BOM，而非强制继承父 POM

<parent>
    <groupId> org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.6</version>
    <!-- 可选：若父 POM 不在本地仓库或远程仓库中，需指定相对路径 -->
    <relativePath>../parent/pom.xml</relativePath>
</parent>

<!-- 子模块的坐标（如果父 POM 已定义，此处可省略 groupId/version） -->
<artifactId>child-module</artifactId>

4.3、`relativePath` 标签

<relativePath> 标签用于指定父项目 POM 文件的相对路径

4.3.1、默认行为

Maven在构建时，默认会先检查本地路径（如 ../pom.xml）尝试从本地文件系统找到父项目的 POM 文件。如果找不到，才会从远程仓库（Repository）下载。

Maven会依次尝试：

本地路径：…/pom.xml（即上一级目录）
本地仓库（~/.m2/repository）
远程仓库

4.3.2、设置 `<relativePath/>`

当显式配置 <relativePath/> 为空标签时，表示跳过本地路径查找，直接强制从配置的仓库（如Maven Central、私有 Nexus 等）下载父项目的 POM 文件

Maven会跳过本地路径查找，直接：

本地仓库
远程仓库

<relativePath/> 的作用是强制 Maven 从仓库解析父项目，而非本地文件系统，适用于父项目独立管理的场景

5、`packaging` 标签

<packaging> 标签用于定义项目的输出类型（即构建产物的格式）

5.1、作用

定义构建产物类型：决定 Maven 构建后生成的最终文件格式（如 JAR、WAR、POM 等）。
控制构建生命周期：不同打包类型会触发不同的默认生命周期阶段和插件配置。
默认值：如果未显式声明 <packaging>，默认值为 jar

常见打包类型：

打包类型	描述	典型应用场景	输出文件示例
jar	Java 库或可执行 JAR	普通 Java 项目、工具类库	myapp-1.0.0.jar
war	Web 应用归档文件	Servlet/JSP Web 应用	mywebapp-1.0.0.war
pom	聚合或父项目	多模块项目的父 POM 或聚合项目	无实际构建产物
maven-plugin	Maven 插件	自定义 Maven 插件开发	myplugin-1.0.0.jar

5.2、详细说明

5.2.1、jar【默认值】

用途：普通 Java 项目或库
生命周期：使用 default 生命周期（compile → test → package → install）
场景：生成可执行 JAR（需配置 maven-jar-plugin）：

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-jar-plugin</artifactId>
      <configuration>
        <archive>
          <manifest>
            <mainClass>com.example.Main</mainClass>
          </manifest>
        </archive>
      </configuration>
    </plugin>
  </plugins>
</build>

5.2.2、war

用途：Web 应用程序（Servlet/JSP）
生命周期：使用 war 生命周期（自动绑定 war:war 目标）
依赖处理：依赖 JAR 文件会被打包到 WEB-INF/lib 目录
场景：maven-war-plugin（默认已绑定）

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-war-plugin</artifactId>
      <version>3.3.2</version>
      <configuration>
        <warSourceDirectory>src/main/webapp</warSourceDirectory>
      </configuration>
    </plugin>
  </plugins>
</build>

5.2.3、pom

用途：
- 多模块项目的父 POM（继承配置）
- 聚合项目（通过 <modules> 管理子模块）
生命周期：执行构建，仅传递配置
场景

<packaging>pom</packaging>
<modules>
  <module>module1</module>
  <module>module2</module>
</modules>

5.2.4、自定义打包

通过插件支持扩展其他打包格式（如 zip、tar.gz 等），例如：

5.2.4.1、Spring Boot 可执行 JAR

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

5.2.4.2、生成 ZIP 包

使用 maven-assembly-plugin：

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-assembly-plugin</artifactId>
      <version>3.3.0</version>
      <configuration>
        <descriptor>src/main/assembly/zip.xml</descriptor>
      </configuration>
      <executions>
        <execution>
          <phase>package</phase>
          <goals>
            <goal>single</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

6、dependencyManagement 标签 & dependencies 标签

6.1、dependencyManagement 标签

dependencyManagement 用于集中管理依赖的版本和配置，但不实际引入依赖到当前项目。它通常出现在父 POM 中，目的是为子模块提供统一的依赖版本控制，避免重复定义

作用：

版本统一管理：在父 POM 中定义依赖的版本号、作用域（scope）、排除项（exclusions）等配置，子模块只需声明 groupId 和 artifactId，无需重复指定版本
依赖配置模板：子模块可以继承父 POM 中的依赖配置，但是否实际使用该依赖由子模块自行决定
多模块项目标准化：确保所有子模块使用相同版本的依赖，避免版本冲突

示例：

<!-- 父 POM 中定义 -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.8</version> <!-- 统一版本 -->
            <scope>compile</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

子模块中只需声明：

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId> <!-- 无需写版本 -->
    </dependency>
</dependencies>

6.2、dependencies 标签

dependencies 用于直接声明项目所需的依赖，这些依赖会被实际引入到项目中。如果依赖未在 dependencyManagement 中定义，必须显式指定版本号

作用：

实际引入依赖 ：所有在 dependencies 中声明的依赖会默认被项目使用（除非指定了特殊作用域，如 test）。
显式依赖声明 ：每个依赖需要明确指定 groupId、artifactId 和 version（除非通过 dependencyManagement 继承/父 POM 继承）

6.3、区别

特性	dependencyManagement	dependencies
是否引入依赖	否（仅管理配置）	是（实际引入依赖）
版本必须性	父 POM 中必须指定版本，子模块可省略	必须显式指定版本（除非继承自父 POM）
适用场景	多模块项目的父 POM，统一管理依赖	单模块项目或子模块的实际依赖声明
依赖作用域控制	可定义作用域，子模块可继承或覆盖	直接指定作用域
依赖传递性	无实际依赖传递	依赖会传递到子模块

6.4、使用场景

6.4.1、场景 1：多模块项目

父 POM：使用 dependencyManagement 统一管理所有子模块的依赖版本
子模块：在 dependencies 中声明实际需要的依赖，无需写版本号

6.4.2、场景 2：单模块项目

直接使用 dependencies 声明依赖并指定版本

6.4.3、场景 3：BOM（Bill of Materials）导入

通过 dependencyManagement 的 import 作用域，从其他 POM 导入依赖管理配置：

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.5.4</version>
            <!--表示引入的是一个 POM 文件（而非默认的 JAR 包），因为 BOM 本身是一个依赖管理文件-->
            <type>pom</type>
            <!--将 spring-boot-dependencies 中定义的 <dependencyManagement> 内容合并到当前项目的依赖管理配置中-->
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

核心作用是：导入 Spring Boot 的 BOM（Bill of Materials），统一管理所有 Spring Boot 相关依赖的版本

无需手动指定版本：项目中声明 Spring Boot 依赖时，只需提供 groupId 和 artifactId，例如：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <!-- 版本号由 BOM 自动提供 -->
    </dependency>
</dependencies>

6.5、父模块使用场景

父模块的主要职责是统一管理子模块的配置（如依赖版本、插件版本等），而不是实际参与代码构建。因此，大多数情况下：

优先使用 dependencyManagement ：在父模块中定义依赖的版本、作用域、排除规则等，子模块只需声明 groupId 和 artifactId，无需重复指定版本。这是 Maven 多模块项目的核心设计。
避免滥用 dependencies：如果父模块的 dependencies 中声明了依赖，这些依赖会隐式传递给所有子模块（除非子模块主动排除），可能导致子模块引入不需要的依赖，增加依赖冗余和冲突风险。

父模块使用 dependencies 的合理场景：

父模块本身是一个可执行模块
所有子模块都需要的公共依赖【需确保依赖的传递性合理，避免污染子模块】
父模块需要插件依赖：如果父模块需要为子模块统一配置插件，直接在父模块的 <build> 中声明插件依赖即可，无需使用 dependencies

7、build 标签

<!--构建配置-->
<build>
    <plugins>
        <!--编译源代码-->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>
            <configuration>
                <!--指定源代码兼容的 JDK 版本-->
                <source>${java.version}</source>
                <!--指定生成的字节码目标 JDK 版本-->
                <target>${java.version}</target>
                <!--设置编译时的字符编码-->
                <encoding>${project.build.sourceEncoding}</encoding>
            </configuration>
        </plugin>

        <!--生成 SpringBoot 可执行的 jar-->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>${spring-boot.version}</version>
            <configuration>
                <mainClass>com.zzc.ParentApplication</mainClass>
                <!--跳过当前插件所有操作【父工程无需打包】-->
                <skip>true</skip>
            </configuration>
            <executions>
                <execution>
                    <id>repackage</id>
                    <goals>
                        <goal>repackage</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

配置了 2 个插件：

编译代码：maven-compiler-plugin 根据 JDK 1.8 和 UTF-8 编码编译源码
代码应用：spring-boot-maven-plugin 在 package 阶段生成可执行 JAR
跳过条件：若 <skip>true</skip>，则跳过生成可执行 JAR 的步骤

7.1、子模块打包成可依赖

7.1.1、子模块只提供可依赖 JAR

①：确保子模块的 packaging 类型为 jar

<!-- 子模块 pom.xml -->
<artifactId>child-module</artifactId>
<packaging>jar</packaging> <!-- 默认即为 jar，无需显式声明 -->

②：禁用 Spring Boot 插件（若存在）
如果父模块或子模块中引入了 spring-boot-maven-plugin，需在子模块中跳过该插件：

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <!-- 跳过可执行 JAR 的生成 -->
                <skip>true</skip>
            </configuration>
        </plugin>
    </plugins>
</build>

③：验证生成的 JAR

执行 mvn clean install 后，检查子模块的 target 目录：

生成文件应为标准 JAR（如 child-module-1.0.0.jar），内容仅包含子模块自身的代码和资源
无嵌入依赖（Fat JAR 特征为包含 BOOT-INF 目录）

7.1.2、子模块同时提供可执行 JAR 和可依赖 JAR

适用于子模块既需要独立运行，又要作为依赖被其他模块引用

①：配置 Spring Boot 插件生成分类器 JAR

在子模块中保留 spring-boot-maven-plugin，但通过 <classifier> 生成两个 JAR：

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <!-- 可执行 JAR 添加分类器（如 "exec"） -->
                <classifier>exec</classifier>
            </configuration>
            <executions>
                <execution>
                    <id>repackage</id>
                    <goals>
                        <goal>repackage</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

②：验证生成的两个 JAR

执行 mvn clean install 后，检查 target 目录：

标准依赖 JAR：child-module-1.0.0.jar（无嵌入依赖）。
可执行 JAR：child-module-1.0.0-exec.jar（含所有依赖）

8、profiles 标签

<!--多环境配置-->
<profiles>
    <profile>
        <id>dev</id>
        <activation>
            <!-- 默认激活 -->
            <activeByDefault>true</activeByDefault>
        </activation>
        <properties>
            <env>dev</env>
        </properties>
    </profile>

    <profile>
        <id>prod</id>
        <properties>
            <env>prod</env>
        </properties>
        <build>
            <resources>
                <!-- 启用资源过滤 -->
                <resource>
                    <directory>src/main/resources</directory>
                    <filtering>true</filtering>
                    <includes>
                        <include>application-${env}.yml</include>
                        <!-- 所有yml配置文件-->
                        <!--<include>**/*.yml</include>-->
                    </includes>
                </resource>
            </resources>
        </build>
    </profile>
</profiles>

定义了两个 Profile：dev（开发环境）和 prod（生产环境），通过 <env> 属性动态控制资源文件的加载和过滤

9、resources 标签

9.1、resources 标签作用

build 标签里面通常包含构建项目时需要的一些配置，比如插件、资源目录等。而 resources 标签和资源文件有关。

资源文件通常指的是项目中的非代码文件：配置文件、属性文件、XML文件、图片等等。这些文件在构建过程中可能需要被处理或包含到最终的包中【jar/war 包】

默认情况下【不添加 resources 标签】：Maven 会把 src/main/resources 目录下的文件复制到target/classes 目录中，然后在打包时包含进去。同样，src/test/resources 用于测试资源，会复制到 target/test-classes 【如果用户显式地添加了 resource 标签，Maven 会覆盖默认行为，只处理显式定义的资源】

默认已经处理了资源文件，为什么还需要配置resources标签？

因为当项目有特殊的资源处理需求时：

资源文件不在默认目录下：资源文件不在 src/main/resources，而是在另一个目录 src/config，这时候就需要在 resources 里指定这个目录，让 Maven 知道需要处理这些文件
需要过滤（替换变量）：在资源文件中使用 Maven 的属性（如 ${project.version}），就需要启用过滤，这样在构建时这些占位符会被替换成实际的值
需要包含/排除某些文件：不希望某些配置文件被打包进去，这时候可以用 excludes 标签

总结：资源文件（如配置文件、属性文件、XML、图片等）默认位于 src/main/resources 目录中，Maven 在构建时会自动将其复制到 target/classes 目录，并打包到最终的 JAR/WAR文件中。<resources> 标签允许你：

自定义资源目录：指定其他位置的资源文件
过滤（Filtering）：替换资源文件中的 Maven 属性占位符（如 ${project.version}）
包含/排除文件：精确控制哪些文件需要处理或忽略

9.2、示例

<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory> <!-- 指定资源目录 -->
            <filtering>true</filtering>               <!-- 启用变量替换 -->
            <includes>                               <!-- 指定包含的文件类型 -->
                <include>**/*.xml</include>
                <include>**/*.yml</include>
            </includes>
        </resource>
    </resources>
</build>

作用：

资源过滤（Variable Filtering）：启用 <filtering>true</filtering> 后，Maven 会解析资源文件中的占位符（如 ${project.version}、${custom.property}），并将其替换为实际值
选择性包含文件：通过 <includes> 指定仅处理 XML 和 YML 文件，其它类型文件（如 .properties、.txt）会被忽略

9.2.1、资源过滤与包含规则

假设 application-dev.yml 中有以下内容：

database:
  url: ${db.url}
  username: ${db.user}
  password: ${db.password}

在构建时，Maven 会替换 ${db.url} 等占位符。需要在 pom.xml 或 settings.xml 中定义这些属性：

<properties>
    <db.url>jdbc:mysql://prod-server:3306/mydb</db.url>
    <db.user>admin</db.user>
    <db.password>securepass</db.password>
</properties>

9.3、改进

风险：若资源目录中包含其他需复制的文件（如 .properties 或静态文件），因未被 <includes> 覆盖，将不会被打包
改进：显式包含所有文件，但仅对需要过滤的文件启用过滤

<resources>
    <!-- 包含所有文件但不启用过滤 -->
    <resource>
        <directory>src/main/resources</directory>
        <filtering>false</filtering>
        <includes>
            <include>**/*</include>
        </includes>
    </resource>
    <!-- 对特定文件启用过滤 -->
    <resource>
        <directory>src/main/resources</directory>
        <filtering>true</filtering>
        <includes>
            <include>**/*.xml</include>
            <include>**/*.yml</include>
            <!--特定文件-->
            <!--<include>application-${env}.yml</include>-->
        </includes>
    </resource>
</resources>

        第一个 resource 标签的作用是包含 src/main/resources 目录下的所有文件，但不过滤（filtering 为false）。这意味着这些文件会被复制到 target/classes 目录中，但不进行任何变量替换。第二个resource 标签则专门针对 application-${env}.yml 文件，启用了过滤，这样在构建时，Maven 会替换这些文件中的变量。
        默认情况下【不添加 resources 标签】：Maven 会处理 src/main/resources 目录下的所有资源文件，使用默认的过滤设置（通常是关闭的）。但是如果用户显式地添加了 resource标签，Maven 会覆盖默认行为，只处理显式定义的资源。
        当前配置中的第一个 resource 标签显式地包括了所有文件，但关闭了过滤。而第二个 resource 标签针对特定文件启用了过滤。如果删除第一个 resource 标签，Maven 将不再处理所有文件，而是只处理第二个 resource 标签中定义的文件，即所有 xml 和所有的 yml 。这将导致其他资源文件（如静态文件、其他配置文件）没有被包含到构建结果中，从而可能导致应用程序运行时缺少必要的资源。

10、创建一个聚合工程

工程结构图如下：

在这里插入图片描述

10.1、创建一个 SpringBoot 工程 parent

parent 模块：不做任何业务逻辑处理，重点是 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">
    <!--必须是4.0.0-->
    <modelVersion>4.0.0</modelVersion>
    <!--继承父 POM 的配置-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.6</version>
        <relativePath/>
    </parent>

    <groupId>com.zzc</groupId>
    <artifactId>parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <!--打包方式, 默认为 jar-->
    <packaging>pom</packaging>
    <!--项目名称&描述-->
    <name>parent</name>
    <description>parent</description>

    <!--子模块-->
    <modules>
        <module>entity</module>
        <module>dao</module>
        <module>web</module>
    </modules>

    <!--自定义属性配置-->
    <properties>
        <java.version>1.8</java.version>
        <entity.version>0.0.1-SNAPSHOT</entity.version>
        <dao.version>0.0.1-SNAPSHOT</dao.version>
        <web.version>0.0.1-SNAPSHOT</web.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.7.6</spring-boot.version>
        <mybatis.plus.boot.starter.version>3.4.3</mybatis.plus.boot.starter.version>
        <hutool.version>5.7.0</hutool.version>
        <fastjson.version>1.2.76</fastjson.version>
        <lombok.version>1.18.28</lombok.version>
    </properties>

    <!--依赖管理-->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>${mybatis.plus.boot.starter.version}</version>
            </dependency>
            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>${hutool.version}</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>${fastjson.version}</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
                <scope>provided</scope>
            </dependency>
            <!--模块版本-->
            <dependency>
                <groupId>com.zzc</groupId>
                <artifactId>entity</artifactId>
                <version>${entity.version}</version>
            </dependency>
            <dependency>
                <groupId>com.zzc</groupId>
                <artifactId>dao</artifactId>
                <version>${dao.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!--项目依赖-->
    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

    <!--构建配置-->
    <build>
        <plugins>
            <!--编译源代码【可依赖的jar包】-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <!--指定源代码兼容的 JDK 版本-->
                    <source>${java.version}</source>
                    <!--指定生成的字节码目标 JDK 版本-->
                    <target>${java.version}</target>
                    <!--设置编译时的字符编码-->
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>

            <!--生成 SpringBoot 可执行的 jar【默认不生效】-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring-boot.version}</version>
                <configuration>
                    <mainClass>com.zzc.ParentApplication</mainClass>
                    <!--跳过当前插件所有操作【父工程无需打包】-->
                    <skip>true</skip>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

parent 工程：

定义 parent 标签
打包方式修改为：pom
添加 modules 子模块标签：添加所有子模块
添加 dependencyManagement 标签：统一依赖版本
添加 dependencies：添加子模块共同的依赖
添加 build：添加了2个打包插件，分别为依赖 jar 包、SpringBoot 可执行 jar 包【默认不生效】，子模块默认也有这两个插件

10.2、子模块 —— entity

entity 子模块：实体类

@Data
public class User implements Serializable {
    private Long id;
    private String name;
}

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>com.zzc</groupId>
        <artifactId>parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <relativePath>../pom.xml</relativePath>
    </parent>

    <artifactId>entity</artifactId>
    <version>${entity.version}</version>
    <packaging>jar</packaging>
    <name>entity</name>
    <description>entity</description>

    <dependencies>
    </dependencies>

</project>

entity 子模块

添加父工程
打包方式修改为：jar

10.3、子模块 —— dao

<?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>com.zzc</groupId>
        <artifactId>parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <relativePath>../pom.xml</relativePath>
    </parent>
    <artifactId>dao</artifactId>
    <version>${dao.version}</version>
    <packaging>jar</packaging>
    <name>dao</name>
    <description>dao</description>

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.31</version>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>com.zzc</groupId>
            <artifactId>entity</artifactId>
        </dependency>
    </dependencies>

</project>

10.4、子模块 —— web

web 子模块：最终需要启动这个模块

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>com.zzc</groupId>
        <artifactId>parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <relativePath>../pom.xml</relativePath>
    </parent>
    <artifactId>web</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
    <name>web</name>
    <description>web</description>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--模块版本-->
        <dependency>
            <groupId>com.zzc</groupId>
            <artifactId>entity</artifactId>
        </dependency>
        <dependency>
            <groupId>com.zzc</groupId>
            <artifactId>dao</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring-boot.version}</version>
                <configuration>
                    <mainClass>com.zzc.WebApplication</mainClass>
                    <skip>false</skip>
                    <!--<classifier>exec</classifier>-->
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

web 子模块：

依赖的 entity & dao 模块，必须先执行 mvn clean install 打包
添加 build 标签，打包成 SpringBoot 可执行的 jar

添加一个 Controller：

@Slf4j
@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        User user = new User();
        log.info("hello~~~, user = {}", user);
        return "hello";
    }

}