Maven讲解从基础到高级配置与实践

一、基础认知

1.1 Maven 的主要作用

Maven 主要是用来管理 Java 项目构建流程的工具，包括以下几个方面：

1. 依赖管理：通过 POM.xml 文件管理项目的外部依赖库，不同版本的依赖包可以通过 Maven 中央仓库自动下载，减少了手动添加依赖包的复杂性。
2. 标准化项目结构：Maven 提供了一种约定的目录结构和构建流程，简化了项目的结构管理。
3. 自动化构建：通过指定构建生命周期中的不同阶段，Maven 可在项目构建、测试、打包时实现自动化。
4. 插件扩展：Maven 的插件体系支持各种任务的定制和扩展，如编译、测试、报告生成等。

1.2 Maven 项目的目录结构

Maven 约定的项目目录结构如下：

my-app
├── src
│   ├── main
│   │   ├── java            # 源代码
│   │   ├── resources       # 资源文件（如配置文件）
│   └── test
│       ├── java            # 测试代码
│       ├── resources       # 测试资源
├── target                  # 编译后的文件
└── pom.xml                 # 项目对象模型文件

这种标准化的目录布局有助于统一管理项目结构。

1.3 Maven 常用命令

Maven 提供了多种命令以便在项目的各个阶段进行操作，这些命令大多以 mvn 开头并附带相应的参数和选项。下面列举并解释了常见的 Maven 命令，帮助理解和管理 Maven 项目的不同阶段。

1.3.1 构建命令

• mvn clean：清理目标目录（target/），删除所有生成的文件和文件夹。这是重建项目的第一步，确保构建过程干净、不会使用旧的编译文件。

  mvn clean
  

• mvn compile：编译主源码，输出文件到 target/classes/。该命令只会编译主代码，不包括测试代码。

  mvn compile
  

• mvn test-compile：编译测试代码，将测试类编译到 target/test-classes/，为单元测试准备编译好的测试类。

  mvn test-compile
  

• mvn test：运行项目中的测试代码。它会首先执行 mvn compile 和 mvn test-compile，然后运行测试类，生成测试报告。

  mvn test
  

1.3.2 打包与安装命令

• mvn package：将项目打包成 JAR 或 WAR 文件，具体打包形式由 POM.xml 中的配置决定。通常用于生成发布版本的可执行包。

  mvn package
  

• mvn install：将打包好的文件安装到本地仓库（~/.m2/repository），以便其他项目可以引用。此命令适合本地开发时共享包之间的依赖。

  mvn install
  

• mvn deploy：将打包文件发布到远程仓库，适用于项目构建并需要在共享仓库中共享的场景，常用于持续集成环境。

  mvn deploy
  

1.3.3 依赖管理命令

• mvn dependency：解析并下载所有项目依赖，将它们下载到本地仓库并在项目中链接依赖包。可以快速检查项目的依赖是否正确安装。

  mvn dependency:resolve
  

• mvn dependency：生成依赖树，显示项目所有的直接和间接依赖关系。该命令有助于分析依赖冲突。

  mvn dependency:tree
  

1.3.4 验证与调试命令

• mvn validate：验证项目的结构和必要的信息（如 POM.xml），确保项目配置正确。

  mvn validate
  

• mvn verify：运行任何集成测试以验证项目包的完整性。这个命令在 package 之后运行，适用于执行额外的检查。

  mvn verify
  

1.3.5 生成与清理命令

• mvn site：生成项目的站点文档，其中包括项目报告、代码质量报告、测试报告等。生成文件存储在 target/site 文件夹中。

  mvn site
  

• mvn clean：清理项目构建的输出目录 target/，适合需要重构、重构代码或在新的构建环境中重新开始构建时使用。

  mvn clean
  

1.3.6 组合命令

Maven 允许将多个命令组合在一起运行，例如：

• mvn clean install：组合了清理和安装命令，先删除旧的构建文件，再重新安装新的构建。

  mvn clean install
  

• mvn clean package -DskipTests：跳过测试阶段进行打包，适合在开发过程中进行快速测试（仅用于确认功能，不推荐在生产环境中跳过测试）。

  mvn clean package -DskipTests
  

1.4 如何排查某个 Jar 的依赖项和依赖树

在大型 Maven 项目中，随着依赖项的增加，容易出现依赖冲突、版本不兼容等问题。Maven 提供了多种命令可以帮助我们分析某个 Jar 包的依赖关系，并排查依赖树中的问题。

1.4.1 使用 dependency:tree 查看完整依赖树

Maven 提供的 dependency:tree 插件可以生成项目的完整依赖树，列出所有的直接和传递依赖，帮助我们了解依赖的来源和层次结构，快速定位并解决依赖冲突。

命令用法

1. 查看完整依赖树 使用以下命令查看项目的完整依赖树：

   mvn dependency:tree
   

   该命令会输出项目中的所有依赖项，包括其各自的依赖层次结构。

2. 查看特定依赖项 若只想查找某个特定的 Jar 包（如 spring-core）的依赖关系，可以结合 grep 命令进行过滤：

   mvn dependency:tree | grep spring-core
   

3. 保存依赖树 可以将依赖树保存到文件中便于后续分析，使用以下命令：

   mvn dependency:tree -DoutputFile=dependency-tree.txt
   

示例输出

运行 mvn dependency:tree 命令时，生成的依赖树如下：

[INFO] com.example:my-app:jar:1.0
[INFO] +- org.springframework.boot:spring-boot-starter-web:jar:2.5.0:compile
[INFO] |  +- org.springframework.boot:spring-boot-starter:jar:2.5.0:compile
[INFO] |  |  +- org.springframework:spring-core:jar:5.3.6:compile
...

1.4.2 使用 dependency:resolve 查看项目直接依赖

dependency:resolve 插件可以列出项目中的直接依赖关系，并提供版本和作用域的信息，便于分析当前的直接依赖项及其版本。

命令用法

mvn dependency:resolve

示例输出

[INFO] com.example:my-app:jar:1.0
[INFO]   org.springframework.boot:spring-boot-starter-web:jar:2.5.0:compile
[INFO]   org.springframework.boot:spring-boot-starter-test:jar:2.5.0:test
...

1.4.3 使用 dependency:analyze 分析未使用的依赖

dependency:analyze 插件可以分析项目中未被直接使用的依赖项，帮助简化依赖树、减少冗余依赖。

命令用法

mvn dependency:analyze

示例输出

[INFO] Used declared dependencies found:
[INFO]    org.springframework.boot:spring-boot-starter-web:jar:2.5.0:compile
[INFO] Unused declared dependencies found:
[INFO]    com.fasterxml.jackson.core:jackson-databind:jar:2.11.4:compile
...

1.4.4 使用 dependency:tree 分析依赖冲突

当出现版本冲突时，可以使用 dependency:tree 查看冲突的依赖项来源并进行排除处理。例如，当项目依赖两个不同版本的 spring-core 时，可以在输出中查找并定位该冲突。

解决冲突

在 pom.xml 中，通过 `` 标签排除特定版本的依赖：

<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId><exclusions><exclusion><groupId>org.springframework</groupId><artifactId>spring-core</artifactId></exclusion></exclusions>
</dependency>

此配置将排除指定依赖项，从而避免版本冲突。

二、POM 文件

POM（Project Object Model） 文件是 Maven 项目的核心配置文件，存放了项目的基本信息、依赖管理、插件配置等。

2.1 POM 文件中的基本元素

以下是 POM 文件的主要元素：

<project><modelVersion>4.0.0</modelVersion> <!-- POM模型版本号 --><groupId>com.example</groupId>     <!-- 项目组织ID --><artifactId>my-app</artifactId>    <!-- 项目名 --><version>1.0.0</version>           <!-- 项目版本 -->
</project>

• groupId：项目组织的唯一标识，如公司或项目组名。
• artifactId：项目名称，通常是项目或模块的名称。
• version：项目版本号，用于版本控制和发布。

2.2 在 POM 文件中添加项目依赖

在 dependencies 节点中添加项目所需的依赖库：

<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>5.3.10</version></dependency>
</dependencies>

2.3 依赖范围（scope）

依赖范围用于指定依赖的使用场景，常见的范围包括：

• compile：默认范围，编译和运行时都可用。
• test：仅在测试阶段可用。
• provided：编译期可用，但在运行时由容器（如 Tomcat）提供。

例如：

<dependency><groupId>javax.servlet</groupId><artifactId>javax.servlet-api</artifactId><version>4.0.1</version><scope>provided</scope>
</dependency>

---

三、仓库管理

在 Maven 中，仓库用于存储和管理项目的依赖项和构建结果。Maven 仓库分为本地仓库和远程仓库，本地仓库通常位于开发者的机器上，而远程仓库则可以是公共仓库或私有仓库。以下是仓库配置的细节，包括如何设置仓库密码以及代理的配置。

3.1 本地仓库与远程仓库

1. 本地仓库：在 Maven 下载依赖时会将其存储在本地仓库中，默认路径为 ~/.m2/repository。
2. 远程仓库：若本地仓库中没有找到依赖，Maven 会尝试从配置的远程仓库（如 Maven Central、企业私有仓库等）获取依赖。

3.2 配置私有仓库及设置仓库密码

在企业环境中，为了避免重复下载公共仓库的依赖，通常会搭建私有仓库，并使用认证保护。Maven 的 settings.xml 文件可以配置私有仓库和认证信息。

1. 在 settings.xml 中配置私有仓库

   在 settings.xml 文件（位于 ~/.m2/）中配置私有仓库的 URL：

   <mirrors><mirror><id>my-private-repo</id><url>https://repo.mycompany.com/maven2</url><mirrorOf>*</mirrorOf></mirror>
   </mirrors>

   上述配置将所有 Maven 下载请求重定向到 https://repo.mycompany.com/maven2，并指定 mirrorOf 为 "*"。

2. 设置仓库密码

   如果私有仓库需要认证，Maven 提供了安全的密码存储方式：

   • 在 settings.xml 中配置凭据：

     <servers><server><id>my-private-repo</id><username>your-username</username><password>your-password</password></server>
     </servers>

   • 对密码进行加密：

     1. 首先生成加密密钥：mvn --encrypt-master-password your-master-password
     2. 使用生成的密钥加密仓库密码：mvn --encrypt-password your-password
     3. 将加密后的密码粘贴到 settings.xml 中的 `` 节点。

3.3 设置代理提升下载速度

当 Maven 访问远程仓库的网络受限时，可以通过配置代理来提升下载速度：

1. 在 settings.xml 中配置代理

   <proxies><proxy><id>example-proxy</id><active>true</active><protocol>http</protocol><host>proxy.example.com</host><port>8080</port><username>proxy-user</username><password>proxy-password</password></proxy>
   </proxies>

   通过该代理配置，Maven 的网络请求将通过代理服务器访问远程仓库，从而提高下载速度。

四、构建生命周期

Maven 的构建生命周期定义了一系列构建阶段，常见的生命周期阶段包括：

1. clean：清理生成的文件。
2. compile：编译源代码。
3. test：运行测试代码。
4. package：将项目打包为可发布的格式，如 JAR。
5. install：安装到本地仓库中。
6. deploy：发布到远程仓库。

运行 mvn package 会执行清理、编译、测试和打包等阶段。

---

五、依赖管理策略

Maven 的依赖管理策略主要用于避免依赖冲突、管理版本控制。dependencyManagement 是其中的重要机制，适用于管理复杂项目中的依赖版本和冲突。

5.1 依赖冲突的解决机制

当项目中多个依赖项包含相同的依赖时，Maven 使用“最短路径优先”与“声明顺序优先”规则来解决冲突。

• 最短路径优先：Maven 会选择依赖树中路径最短的依赖。
• 声明顺序优先：如果路径长度相同，则优先使用依赖树中最先声明的依赖版本。

5.2 使用 dependencyManagement 管理依赖版本

在多模块项目中，dependencyManagement 用于在父 POM 中集中管理依赖版本，避免子模块重复声明版本信息。子模块只需引入依赖而不需要指定版本，Maven 会自动采用父 POM 中指定的版本。

示例：

1. 父 POM 的 dependencyManagement 配置

   <project><groupId>com.example</groupId><artifactId>parent-project</artifactId><version>1.0</version><packaging>pom</packaging><dependencyManagement><dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>5.3.8</version></dependency></dependencies></dependencyManagement>
   </project>

2. 子模块引用依赖

   子模块的 pom.xml 中不需要指定版本信息，Maven 会自动从父 POM 中获取版本：

   <project><parent><groupId>com.example</groupId><artifactId>parent-project</artifactId><version>1.0</version></parent><dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId></dependency></dependencies>
   </project>

   在此配置下，spring-core 的版本由父 POM 的 dependencyManagement 统一管理，有效避免了版本冲突和冗余声明。

5.3 使用 exclusions 排除冲突的依赖

在某些情况下，直接依赖会引入不兼容的传递依赖项，可以使用 exclusions 标签排除这些依赖，确保项目中无冲突依赖。

示例：

<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId><exclusions><exclusion><groupId>org.springframework</groupId><artifactId>spring-core</artifactId></exclusion></exclusions>
</dependency>

通过以上配置，可以有效避免不兼容的版本冲突

---

六、插件使用

6.1 常用的 Maven 插件

• maven-compiler-plugin：控制 Java 源码编译的插件。
• maven-surefire-plugin：执行单元测试。
• maven-jar-plugin：创建 JAR 包。

6.2 配置自定义插件

在 POM 文件中配置插件：

<build><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>3.8.1</version><configuration><source>1.8</source><target>1.8</target></configuration></plugin></plugins>
</build>

---

七、与其他工具集成

7.1 Maven 与 Jenkins 集成

Maven 项目与 Jenkins 集成时，可使用 mvn clean package 命令自动触发构建，并通过 Jenkins 中的 Maven 插件实现持续集成。

7.2 Maven 与 IDE 的集成体验

常用的 IDE（如 IntelliJ IDEA 和 Eclipse）都可以很好地集成 Maven。通过 Maven 插件，可以自动下载依赖、执行构建命令、运行测试等，使开发流程更加高效。

---

八、Maven 模块管理案例：实现一个公共模块

Maven 的模块管理功能非常强大，特别是在大型项目中，使用模块化管理可以有效提高代码的复用性和维护性。下面，我们将通过一个具体的案例，讲解如何使用 Maven 的父子项目结构来实现一个公共模块，以供其他模块复用。

8.1 案例背景

假设我们正在开发一个企业级的 Java 应用程序，其中有多个微服务模块。为了提高代码复用性，我们决定将一些通用的功能（如日志、配置管理、工具类等）抽取成一个公共模块，并通过 Maven 的模块管理来实现。

8.2 项目结构

我们将创建以下项目结构：

css复制代码my-company
│
├── pom.xml (父 POM)
│
├── common-utils
│   └── pom.xml (公共模块)
│
├── service-a
│   └── pom.xml (服务 A 模块)
│
└── service-b└── pom.xml (服务 B 模块)

8.3 父 POM 文件配置

在 my-company/pom.xml 中，定义父 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.0</modelVersion><groupId>com.mycompany</groupId><artifactId>my-company</artifactId><version>1.0-SNAPSHOT</version><packaging>pom</packaging><modules><module>common-utils</module><module>service-a</module><module>service-b</module></modules>
</project>

在这个 POM 中，我们定义了一个名为 my-company 的项目，并指定了三个子模块：common-utils、service-a 和 service-b。

8.4 公共模块 common-utils 配置

接下来，在 common-utils/pom.xml 中，我们定义公共模块的 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.0</modelVersion><parent><groupId>com.mycompany</groupId><artifactId>my-company</artifactId><version>1.0-SNAPSHOT</version></parent><artifactId>common-utils</artifactId><packaging>jar</packaging><dependencies><!-- 这里可以添加公共模块的依赖 --><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-api</artifactId><version>1.7.30</version></dependency></dependencies>
</project>

在此配置中，common-utils 模块依赖于 SLF4J 作为日志记录框架。

8.5 服务模块 service-a 和 service-b 配置

我们将让 service-a 和 service-b 模块使用 common-utils 模块。在 service-a/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.0</modelVersion><parent><groupId>com.mycompany</groupId><artifactId>my-company</artifactId><version>1.0-SNAPSHOT</version></parent><artifactId>service-a</artifactId><packaging>jar</packaging><dependencies><dependency><groupId>com.mycompany</groupId><artifactId>common-utils</artifactId><version>${project.version}</version></dependency></dependencies>
</project>

对于 service-b 的配置也是类似：

<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>com.mycompany</groupId><artifactId>my-company</artifactId><version>1.0-SNAPSHOT</version></parent><artifactId>service-b</artifactId><packaging>jar</packaging><dependencies><dependency><groupId>com.mycompany</groupId><artifactId>common-utils</artifactId><version>${project.version}</version></dependency></dependencies>
</project>

8.6 构建项目

完成以上配置后，我们可以在项目根目录下运行以下命令构建整个项目：

mvn clean install

这条命令会依次构建 common-utils、service-a 和 service-b 模块，将它们的 JAR 包安装到本地 Maven 仓库中，供其他项目使用。

8.7 使用公共模块

在其他项目中，如果需要使用 common-utils 模块，只需在相应的 POM 文件中添加如下依赖即可：

<dependency><groupId>com.mycompany</groupId><artifactId>common-utils</artifactId><version>1.0-SNAPSHOT</version>
</dependency>