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

一、基础认知

1.1 Maven 的主要作用

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

依赖管理：通过 POM.xml 文件管理项目的外部依赖库，不同版本的依赖包可以通过 Maven 中央仓库自动下载，减少了手动添加依赖包的复杂性。
标准化项目结构：Maven 提供了一种约定的目录结构和构建流程，简化了项目的结构管理。
自动化构建：通过指定构建生命周期中的不同阶段，Maven 可在项目构建、测试、打包时实现自动化。
插件扩展：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 插件可以生成项目的完整依赖树，列出所有的直接和传递依赖，帮助我们了解依赖的来源和层次结构，快速定位并解决依赖冲突。

命令用法

查看完整依赖树 使用以下命令查看项目的完整依赖树：
```
mvn dependency:tree
```
该命令会输出项目中的所有依赖项，包括其各自的依赖层次结构。
查看特定依赖项 若只想查找某个特定的 Jar 包（如 spring-core）的依赖关系，可以结合 grep 命令进行过滤：
```
mvn dependency:tree | grep spring-core
```
保存依赖树 可以将依赖树保存到文件中便于后续分析，使用以下命令：
```
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 本地仓库与远程仓库

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

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

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

在 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 为 "*"。
设置仓库密码

如果私有仓库需要认证，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 访问远程仓库的网络受限时，可以通过配置代理来提升下载速度：

在 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 的构建生命周期定义了一系列构建阶段，常见的生命周期阶段包括：

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

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

五、依赖管理策略

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

5.1 依赖冲突的解决机制

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

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

5.2 使用 `dependencyManagement` 管理依赖版本

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

示例：

父 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>

子模块引用依赖

子模块的 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>

标签：依赖,项目,仓库,实践,Maven,模块,讲解,mvn
From： https://blog.csdn.net/weixin_39996520/article/details/143392233

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

一、基础认知

1.1 Maven 的主要作用

1.2 Maven 项目的目录结构

1.3 Maven 常用命令

1.3.1 构建命令

1.3.2 打包与安装命令

1.3.3 依赖管理命令

1.3.4 验证与调试命令

1.3.5 生成与清理命令

1.3.6 组合命令

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

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

命令用法

示例输出

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

命令用法

示例输出

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

命令用法

示例输出

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

解决冲突

二、POM 文件

2.1 POM 文件中的基本元素

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

2.3 依赖范围（scope）

三、仓库管理

3.1 本地仓库与远程仓库

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

3.3 设置代理提升下载速度

四、构建生命周期

五、依赖管理策略

5.1 依赖冲突的解决机制

5.2 使用 dependencyManagement 管理依赖版本

5.3 使用 exclusions 排除冲突的依赖

六、插件使用

6.1 常用的 Maven 插件

6.2 配置自定义插件

七、与其他工具集成

7.1 Maven 与 Jenkins 集成

7.2 Maven 与 IDE 的集成体验

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

8.1 案例背景

8.2 项目结构

8.3 父 POM 文件配置

8.4 公共模块 common-utils 配置

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

8.6 构建项目

8.7 使用公共模块

相关文章

赞助商

阅读排行

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

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

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

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

5.2 使用 `dependencyManagement` 管理依赖版本

5.3 使用 `exclusions` 排除冲突的依赖

8.4 公共模块 `common-utils` 配置

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