Maven

随着我们使用越来越多的框架，项目中使用的 jar 包越来越多，项目中，一个模块有上百个 jar 包都是很正常的。而 Maven 能够帮助我们管理这些 jar 包。Maven 使用一个名为pom.xml的文件来描述项目的结构和内容。在 POM 文件中，你可以定义项目的依赖、构建配置、插件、目标项目信息等。总的来说，Maven 是一个用于自动化构建项目的工具，广泛应用于 Java 项目的管理和构建。

通过查询这个网站，来查询常用的 jar 包依赖。

Maven 软件结构

bin：含有 Maven 的运行脚本。
boot：含有 plexus-classworlds 类加载器框架。
conf：含有 Maven 的核心配置文件。
lib：含有 Maven 运行时所需要的 Java 类库。
LICENSE、NOTICE、README.txt：针对 Maven 版本，第三方软件的简要介绍。

Maven 配置

在conf/setting.xml文件中配置本地仓库地址（53行左右）：

<settings xmlns="http://maven.apache.org/SETTINGS/1.2.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.2.0 https://maven.apache.org/xsd/settings-1.2.0.xsd">
  <!-- localRepository
   | The path to the local repository maven will use to store artifacts.
   |
   | Default: ${user.home}/.m2/repository
  <localRepository>/path/to/local/repo</localRepository>
  -->
  <localRepository>D:\Maven\repository</localRepository>

配置国内阿里镜像（160行左右）：

 <mirrors>
   <!-- mirror
    | Specifies a repository mirror site to use instead of a given repository. The repository that
    | this mirror serves has an ID that matches the mirrorOf element of this mirror. IDs are used
    | for inheritance and direct lookup purposes, and must be unique across the set of mirrors.
    |
   <mirror>
     <id>mirrorId</id>
     <mirrorOf>repositoryId</mirrorOf>
     <name>Human Readable Name for this Mirror.</name>
     <url>http://my.repository.com/repo/path</url>
   </mirror>
    -->
<mirror>
	<id>alimaven</id>
	<name>aliyun maven</name>
	<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
	<mirrorOf>central</mirrorOf>
</mirror>

 </mirrors>

配置 JDK 项目构建（268行左右）：

<profile>
<id>jdk-20</id>
<activation>
    <activeByDefault>true</activeByDefault>
    <jdk>20</jdk>
</activation>
<properties>
    <maven.compiler.source>20</maven.compiler.source>
    <maven.compiler.target>20</maven.compiler.target>
    <maven.compiler.compilerVersion>20</maven.compiler.compilerVersion>
</properties>
</profile>

Maven 的 GAVP

Maven 中的 GAVP 是指 Groupld、Artifactld、Version、Packaging 等四个属性的缩写，其中前三个是必要的，而 Packaging 属性为可选项。这四个属性主要为每个项目在 maven 仓库中做一个标识，类似人的姓 - 名！有了具体标识，方便后期项目之间相互引用依赖等。

GAV 遵循的规则：

GroupID 格式：com.{公司 / BU}.业务线.[子业务线]，最多4级。正例：com.taobao.tddl或com.alibaba.sourcing.multilang。
ArtifactID 格式：产品线名 - 模块名。语义不重复不遗漏，先到仓库中心去查证一下。正例：tc-client / ulc-api / tair-tool / bookstore。
Version 版本号格式推荐：主版本号.次版本号.修订号。主版本号：当做了不兼容的 API 修改，或者增加了能改变产品方向的新功能。次版本号：当做了向下兼容的功能性新增（新增类、接口等）。修订号：修复 bug，没有修改方法签名的功能加强，保持 API 兼容性。例如：初始->1.0.0 修改bug -> 1.0.1 功能调整->1.1.1。
Package 定义规则：指示将项目打包为什么类型的文件，idea 根据 packaging 值，识别 maven 项目类型。packaging 属性为 jar（默认值），代表普通的 java 工程，打包以后是 jar 结尾的文件；属性为 war，代表 java 的 web 工程，打包以后是 war 结尾的文件；属性为 pom，代表不会打包，用来做继承的父工程。

Maven 工程

java 工程

idea 中创建 maven 工程之后，会自动生成一个pom.xml文件，每当我们需要下载依赖进行使用的时候，我们只需要打开这个网站，然后搜索相对应的 jar 包，找到对应版本，下滑复制连接，然后在pom.xml文件中创建dependencies标签，把复制的内容粘贴进去即可。

Maven 的 java 工程是 Maven 工程的默认形式，可以选择设置packaging为 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>

    <!-- maven工程的坐标(gavp) -->
    <groupId>cn.hnu.maven</groupId>
    <artifactId>maven_java</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!-- maven工程的打包方式，默认为jar -->
    <packaging>jar</packaging>

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

    <!-- 下载依赖 -->
    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.9.2</version>
            <scope>test</scope>
        </dependency>

    </dependencies>

</project>

web 工程

web 工程相较于普通 java 工程，需要引入 web 依赖，我们可以设置packaging为 war，以 war 的形式打包工程，就可以形成 web 工程了。

值得注意的是，在设置web.xml文件的时候，我们要按照正确的路径来设置，参考设置路径为：...\src\main\webapp\WEB-INF\web.xml，注意其中的src\main\webapp\。

或者，下载JBLJavaToWeb这个插件，然后对着项目右键，选择JBLJavaToWeb，可以一键创建 web 工程。

或者，在创建工程的时候使用Maven Archetype生成 Maven 骨架，不过版本比较低。

Maven 构建

项目构建是指将源代码、依赖库和资源文件等转换成可执行或可部署的应用程序的过程，在这个过程中包括编译源代码、链接依赖库、打包和部署等多个步骤。

项目构建是软件开发过程中至关重要的一部分，它能够大大提高软件开发效率，使得开发人员能够更加专注于应用程序的开发和维护，而不必关心应用程序的构建细节。

同时，项目构建还能够将多个开发人员的代码汇合到一起，并能够自动化项目的构建和部署，大大降低了项目的出错风险和提高开发效率。常见的构建工具包括 Maven、Gradle、Ant 等。

构建过程有：清理（clean）、编译（compile）、测试（test）、（报告）、打包（package）、部署（deploy）。

构建命令：

命令	描述
`mvn compile`	编译项目，生成 target 文件
`mvn package`	打包项目，生成 jar 或 war 文件（编译 + 测试编译 + 打包）
`mvn clean`	清理编译或打包后的项目结构
`mvn install`	打包后上传到 maven 本地仓库
`mvn deploy`	只打包，上传到 maven 私服仓库
`mvn site`	生成站点
`mvn test`	执行测试源码
`mvn test-compile`	编译测试程序

注意：测试类需要以 “Test” 结尾，测试类中的测试方法需要以 “test” 开头。

Maven 构建配置

默认情况下，构建不需要额外配置，都有对应的缺省配置。当然了，我们也可以在pom.xml定制一些配置，来修改默认构建的行为和产物。

例如：

指定构建打包文件的名称，非默认名称。

<!-- 默认的打包名称:artifactid+version.打包方式 -->
<build>
	<finalName>自定义打包名称</finalName>
</build>

制定构建打包时，指定包含文件格式和排除文件。

应用场景：mybatis 中有时会将用于编写 SQL 语句的映射文件和 mapper 接口都写在src/main/java下的某个包中，此时映射文件就不会被打包，如何解决。

<build>
	<!-- 设置要打包的资源位置 -->
    <resources>
    	<resource>
        	<!-- 设置资源所在目录 -->
            <directory>src/main/java</directory>
            <includes>
            	<!-- 设置包含的资源类型 -->
                <include>**/*.xml</include>
            </includes>
        </resource>
    </resources>
</build>

打包插件版本过低，配置更高版本插件。

常用的插件：修改 jdk 版本、tomcat 插件、mybatis 分页插件、mybatis 逆向工程插件等。

<build>
	<plugins>
    	<!-- java编译插件，配jdk的编译版本 -->
        <plugin>
        	<groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
            	<source>1.8</source>
                <target>1.8</target>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>
        <!-- tomcat插件 -->
        <plugin>
        	<groupId>org.apache.tomcat.maven</groupId>
            <artifactId>tomcat7-maven-plugin</artifactId>
            <version>2.2</version>
            <configuration>
            	<port>8080</port>
                <path>/</path>
                <uriEncoding>UTF-8</uriEncoding>
                <server>tomcat</server>
            </configuration>
        </plugin>
    </plugins>
</build>

构建配置是在pom.xml文件中的build标签指定。

Maven 依赖

Maven 依赖范围

通过设置坐标的依赖范围（scope），可以设置对应 jar 包的作用范围：编译环境、测试环境、运行环境。

compile：编译依赖范围，scope 元素的缺省值。使用此依赖范围的 Maven 依赖，对于三种 classpath 均有效，即该Maven 依赖在上述三种 classpath 均会被引入。例如，log4j 在编译、测试、运行过程都是必须的。
test：测试依赖范围。使用此依赖范围的 Maven 依赖，只对测试 classpath 有效。例如，Junit 依赖只有在测试阶段才需要。
provided：已提供依赖范围。使用此依赖范围的 Maven 依赖，只对编译 classpath 和测试 classpath 有效。例如，servlet-api 依赖对于编译、测试阶段而言是需要的，但是运行阶段，由于外部容器已经提供，故不需要 Maven 重复引入该依赖。
runtime：运行时依赖范围。使用此依赖范围的 Maven 依赖，只对测试 classpath、运行 classpath 有效。例如，JDBC 驱动实现依赖，其在编译时只需 JDK 提供的 JDBC 接口即可，只有测试、运行阶段才需要实现了JDBC 接口的驱动。
system：系统依赖范围，其效果与 provided 的依赖范围一致。其用于添加非 Maven 仓库的本地依赖，通过依赖元素 dependency 中的 systemPath 元素指定本地依赖的路径。鉴于使用其会导致项目的可移植性降低，一般不推荐使用。
import：导入依赖范围，该依赖范围只能与 dependencyManagement 元素配合使用，其功能是将目标 pom.xml 文件中 dependencyManagement 的配置导入合并到当前 pom.xml 的 dependencyManagement 中。

Maven 依赖下载失败

在使用 Maven 构建项目时，可能会发生依赖项下载错误的情况，主要原因有以下几种：

下载依赖时出现网络故障或仓库服务器岩机等原因，导致无法连接至 Maven 仓库，从而无法下载依赖。
依赖项的版本号或配置文件中的版本号错误，或者依赖项没有正确定义，导致 Maven 下载的依赖项与实际需要的不一致，从而引发错误。
本地 Maven 仓库或缓存被污染或损坏，导致 Maven 无法正确地使用现有的依赖项。

解决方案：

检查网络连接和 Maven 仓库服务器状态。
确保依赖项的版本号与项目对应的版本号匹配，并检查 POM 文件中的依赖项是否正确。
清除本地 Maven 仓库缓存（lastUpdated 文件），因为只要存在 lastupdated 缓存文件，刷新也不会重新下载。本地仓库中，根据依赖的 gav 属性依次向下查找文件夹，最终删除内部的文件，刷新重新下载即可！

Maven 依赖传递特性

依赖具有传递性，假设有一个项目 A，项目 B 依赖 A，项目 C 依赖 B，那么我们可以说项目 C 依赖 A。那么我们在执行项目 C 时，会自动把 B、A 都下载到 C 项目的 jar 包文件夹中，这就是依赖的传递性。

传递的原则：

在 A 依赖 B，B 依赖 C 的前提下，C 是否能够传递到 A，取决于 B 依赖 C 时使用的依赖范围以及配置。

B 依赖 C 时使用 compile 范围：可以传递。
依赖 C 时使用 test 或 provided 范围：不能传递，所以需要这样的 jar 包时，就必须在需要的地方明确配置依赖才可以。

B 依赖 C 时，若配置了optional标签，则不能传递。

<dependency>
	<groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.15</version>
    <optional>true</optional>
</dependency>

依赖传递的终止：

非 compile 范围进行依赖传递。
使用 optional 配置终止传递。
依赖冲突（传递的依赖已经存在）。

Maven 依赖冲突解决

Maven 自动解决依赖冲突问题能力，会按照自己的原则，进行重复依赖选择。同时也提供了手动解决的冲突的方式，不过不推荐.

解决依赖冲突（如何选择重复依赖）方式：

短路优先原则（第一原则）：A->B->C->D->X(version 0.0.1)和A->F->X(version 0.0.2)，最终是 A 依赖于 0.0.2 版本。
依赖路径长度相同情况下，则 “先声明优先”（第二原则）：在<depencies>中先声明的，路径相同，会优先选择。

手动排除：利用exclusions标签在依赖方进行依赖排除：

<dependencies>
    <dependency>
        <groupId>cn.hnu.maven</groupId>
        <artifactId>maven_B</artifactId>
        <version>1.0-SNAPSHOT</version>
        <!-- 排除依赖 -->
        <exclusions>
            <exclusion>
                <groupId>要排除的依赖的groupId</groupId>
                <artifactId>要排除的依赖的artifactId</artifactId>
            </exclusion>
        </exclusions>
        
    </dependency>
</dependencies>

值得注意的是：使用optional标签同样可以达到“排除依赖”的效果，不过作用的地方是不一样的，optional是作用在被依赖方，而exclusion是作用在依赖方。一般情况下，别人写好的被依赖方我们不能随便加optional，只能在自己的依赖方加上exclusion来排除依赖冲突。

Maven 工程关系

Maven 工程继承关系

Maven 继承是指在 Maven 的项目中，让一个项目从另一个项目中继承配置信息的机制。继承可以让我们在多个项目中共享同一配置信息，简化项目的管理和维护工作。

继承能够在父工程中统一管理项目中的依赖信息。它的背景是：

对一个比较大型的项目进行了模块拆分。
一个 project 下面，创建了很多 module。
每个 module 都需要配置自己的依赖信息。

它背后的需求是：

在每一个 module 中各自维护各自的依赖信息很容易发生出入，不易统一管理。
用同一个框架内的不同 jar 包，它们应该是同一个版本，所以整个项目中使用的框架版本需要统一。
使用框架时所需要的 jar 包组合（或者说依赖信息组合）需要经过长期摸索和反复调试，最终确定一个可用组合。这个耗费很大精力总结出来的方案不应该在新的项目中重新摸索。通过在父工程中为整个项目维护依赖信息的组合既保证了整个项目使用规范、准确的 jar 包；又能够将以往的经验沉淀下来，节约时间和精力。

父工程配置（可以把父工程的src文件夹删掉）：

<groupId>cn.hnu.maven</groupId>
<artifactId>maven_parent</artifactId>
<version>1.0-SNAPSHOT</version>
<!-- 父工程主要是用来进行配置管理，不需要进行打包，所以配置成pom -->
<packaging>pom</packaging>

在父工程下创建子工程：

<modelVersion>4.0.0</modelVersion>
<!-- 设置父工程的坐标 -->
<parent>
    <groupId>cn.hnu.maven</groupId>
    <artifactId>maven_parent</artifactId>
    <version>1.0-SNAPSHOT</version>
</parent>

<artifactId>maven_son</artifactId>

父工程利用dependencyManagement标签进行依赖管理，这样父工程的依赖就不会无脑继承给子工程了：

<dependencyManagement>
    <dependencies>
        <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.9.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

在子工程中，利用dependencies标签管理父工程的依赖，不需要写出version和scope标签：

<dependencies>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
    </dependency>
</dependencies>

Maven 工程的聚合关系

Maven 聚合是指将多个项目组织到一个父级项目中，以便一起构建和管理的机制。聚合可以帮助我们更好地管理一组相关的子项目，同时简化它们的构建和部署过程。当父工程做了什么操作，子工程也就相应做出什么操作。

聚合的作用：

管理多个子项目：通过聚合，可以将多个子项目组织在一起，方便管理和维护。
构建和发布一组相关的项目：通过聚合，可以在一个命令中构建和发布多个相关的项目，简化了部署和维护工作。
优化构建顺序：通过聚合，可以对多个项目进行顺序控制，避免出现构建依赖混乱导致构建失败的情况。
统一管理依赖项：通过聚合，可以在父项目中管理公共依赖项和插件，避免重复定义。

聚合语法：

<project>
	<groupId>cn.hnu.maven</groupId>
    <artifactId>maven_parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    
    <!-- 添加modules标签聚合子项目 -->
    <modules>
    	<module>child-project1-path</module>
        <module>child-project2-path</module>
    </modules>
</project>

Maven 私服

Maven 私服是一种特殊的 Maven 远程仓库，它是架设在局域网内的仓库服务，用来代理位于外部的远程仓库（中央仓库、其他远程公共仓库）。

建立了 Maven 私服后，当局域网内的用户需要某个构件时，会按照如下顺序进行请求和下载：

请求本地仓库，若本地仓库不存在所需构件，则跳转到第2步。
请求 Maven 私服，将所需构件下载到本地仓库，若私服中不存在所需构件，则跳转到第3步。
请求外部的远程仓库，将所需构件下载并缓存到 Maven 私服，若外部远程仓库不存在所需构件，则 Maven 直接报错。

此外，一些无法从外部仓库下载到的构件，也能从本地上传到私服供其他人使用。私服的优势如下：

节省外网带宽：消除对外部远程仓库的大量重复请求（会消耗很大量的带宽），降低外网带宽压力。
下载速度更快：Maven 私服位于局域网内，从私服下载构建更快更稳定。
便于部署第三方构件：有些构件无法从任何一个远程仓库中获得（如：公司或组织内部的私有构件、Oracle 的 JDBC 驱动等），建立私服之后，就可以将这些构件部署到私服中，供内部 Maven 项目使用。
提高项目的稳定性，增强对项目的控制：如果不建立私服，那么 Maven 项目的构件就高度依赖外部的远程仓库，若外部网络不稳定，则项目的构建过程也会变得不稳定。建立私服后，即使外部网络状况不佳甚至中断，只要私服中已经缓存了所需的构件，Maven 也能够正常运行。私服软件（如：Nexus）提供了很多控制功能（如：权限管理、RELEASE / SNAPSHOT 版本控制等），可以对仓库进行一些更加高级的控制。
降低中央仓库的负荷压力：由于私服会缓存中央仓库得构件，避免了很多对中央仓库的重复下载，降低了中央仓库的负荷。

Nexus 初始配置

右键“开始”，以管理员身份运行终端，cd到nexus所在的bin目录当中，然后运行./nexus /run启动 nexus，初次启动比较慢，需要耐心等待。

Nexus 是一个 web 工程，通过http://localhost:8081/进行访问。

右上角 Sign Up 进行登录，第一次登录的时候根据生成的后缀名为 password 的文件来输入密码。然后设置新的密码，并禁用匿名访问。

Nexus 上的各种仓库种类：

proxy：某个远程仓库的代理。
group：存放通过 Nexus 获取的第三方 jar 包。
hosted：本团队其他开发人员部署到 Nexus 的 jar 包。

Nexus jar 包相关

Nexus 下载 jar 包

修改本地 maven 的核心配置文件setting.xml，设置新的本地仓库地址：

<localRepository>D:/maven-repository-new</localRepository>

把原来的阿里云仓库地址的mirror标签修改成如下形式：

<mirror>
	<id>nexus-mine</id>
    <mirrorOf>central</mirrorOf>
    <name>Nexus mine</name>
    <url>http://localhost:8081/repository/maven-public/</url>
</mirror>

如果允许匿名访问，则到这一步就可以了，如果是禁用匿名访问，则需要继续往下操作，配置settings.xml：

<server>
	<id>nexus-mine</id>
    <username>admin</username>
    <password>自己设置密码</password>
</server>

这样就可以在本地进行私服的 jar 包下载了。如果嫌下载太慢，可以修改下载连接为阿里云镜像：http://maven.aliyun.com/nexus/content/groups/public/。

Nexus 部署 jar 包

maven 工程中配置：

<distributionManagement>
	<snapshotRepository>
    	<id>nexus-mine</id>
        <name>Nexus Snapshot</name>
        <url>http://localhost:8081/repository/maven-snapshots/</url>
    </snapshotRepository>
</distributionManagement>

完成上述配置之后，在对应的 maven 里点击 deploy（或者执行mvn deploy指令进行部署），就可以把项目部署到私服上去。

Nexus 引用别人的 jar 包

maven 工程中配置：

<repositories>
	<repository>
    	<id>nexus-mine</id>
        <name>nexus-mine</name>
        <url>http://localhost:8081/repository/maven-snapshots/</url>
        <snapshot>
        	<enabled>true</enabled>
        </snapshot>
        <releases>
        	<enabled>true</enabled>
        </releases>
    </repository>
</repositories>

Maven 案例

项目结构

flowchart LR
    id1(父工程\nmicro-shop\npom)
    id2(子工程1\nuser-service\nwar)
    id3(子工程2\norder-service\nwar)
    id4(通用子工程\ncommon-service\njar)
    
    id2 --继承--> id1
    id2 --依赖--> id4
    id3 --依赖--> id4
    
    id3 --继承--> id1
    id4 --继承--> id1

父工程

父工程进行依赖管理：

<?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>cn.hnu.maven</groupId>
    <artifactId>micro-shop</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!-- 父工程打包成pom -->
    <packaging>pom</packaging>

    <properties>
        <spring.version>6.0.6</spring.version>
        <jackson.version>2.15.0</jackson.version>
        <commons.version>2.11.0</commons.version>
        <junit.version>5.9.2</junit.version>

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

    <!-- 父工程依赖管理 -->
    <dependencyManagement>
        <dependencies>

            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>

            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>${jackson.version}</version>
            </dependency>

            <dependency>
                <groupId>commons-io</groupId>
                <artifactId>commons-io</artifactId>
                <version>${commons.version}</version>
            </dependency>

            <dependency>
                <groupId>org.junit.jupiter</groupId>
                <artifactId>junit-jupiter-api</artifactId>
                <version>${junit.version}</version>
                <scope>test</scope>
            </dependency>

        </dependencies>
    </dependencyManagement>

</project>

子工程

通用子工程：

<?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>
    <parent>
        <groupId>cn.hnu.maven</groupId>
        <artifactId>micro-shop</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>common-service</artifactId>

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

    <!-- 通用模块子工程使用依赖 -->
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>

        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
        </dependency>

        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

子工程配置：

<?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>
    <parent>
        <groupId>cn.hnu.maven</groupId>
        <artifactId>micro-shop</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>user-service</artifactId>
    <!-- 打包成war -->
    <packaging>war</packaging>

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

    <!-- 继承了父工程，还依赖了通用子工程 -->
    <dependencies>
        <dependency>
            <groupId>cn.hnu.maven</groupId>
            <artifactId>common-service</artifactId>
            <version>1.0-SNAPSHOT</version>
            <!-- 利用exclusion排除依赖 -->
		<!--            
		   <exclusions>
                <exclusion>
                    <groupId>commons-io</groupId>
                    <artifactId>commons-io</artifactId>
                </exclusion>
            </exclusions>
		-->
        </dependency>
    </dependencies>

</project>