新手入门之高级maven

前言

提示：本文章主要分享关于maven的一些进阶的知识与用法，需要对maven有一定基础。

通过这篇文章《新手入门之初识maven》可以带你对maven有个基本认识和使用，更好的阅读理解本文章。

一、分模块设计与开发

在 Maven 中，分模块设计（Multi-module Project）是一种常用的设计模式，可以将大型项目分解成多个小的、可管理的模块，每个模块可以独立编译、构建和部署。

Maven 分模块设计的优势

模块化： 将大项目拆分成小的、可管理的模块，便于团队协作和代码维护。
依赖管理： 模块之间可以定义依赖关系，方便依赖的管理和版本控制。
构建灵活性： 可以单独构建某个模块，也可以构建整个项目。
可重用性： 模块可以被多个项目共享和重用。
构建速度： 通过增量构建和缓存机制，加快构建速度。

Maven 分模块设计的基本结构

一个典型的 Maven 多模块项目通常包含一个父模块（Parent Module）和一个或多个子模块（Child Modules）。父模块通常包含整个项目的构建配置，如依赖管理、插件配置等，而子模块则包含具体的代码和资源文件。
目录结构示例

my-parent-project/
├── pom.xml  # 父模块的 POM 文件
├── module-a/  # 子模块 A
│   └── pom.xml  # 子模块 A 的 POM 文件
├── module-b/  # 子模块 B
│   └── pom.xml  # 子模块 B 的 POM 文件
└── module-c/  # 子模块 C
    └── pom.xml  # 子模块 C 的 POM 文件

Maven 分模块项目的构建

构建单个模块：
使用 mvn clean install 命令构建单个模块。
构建整个项目：
进入父模块目录，使用 mvn clean install 命令构建整个项目。

二、继承与聚合

视频推荐：黑马maven高级
Maven 继承允许一个项目（子项目）继承另一个项目（父项目）的配置。这意味着子项目可以继承父项目的 POM 文件中的许多配置项，包括依赖管理、构建插件配置以及其他元数据。这样可以避免重复配置，使得配置更加一致和易于维护。
一个项目只能继承一个父工程。

三种打包方式：

jar:普通模块打包，springboot项目基本都是jar包(内嵌tomcat运行)
war:普通web程序打包，需要部署在外部的tomcat服务器中运行
pom:父工程或聚合工程，该模块不写代码，仅进行依赖管理
注意： 父工程中设置的打包方式为pom，因为默认是jar.

Maven 父模块和子模块的关系

继承关系：
子模块可以继承父模块的配置，如依赖、插件配置等。
子模块的 POM 文件中通过 标签指定父模块的位置。
依赖关系：
子模块之间可以相互依赖，通过 标签指定依赖关系。

父模块的 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.example</groupId>
    <artifactId>my-parent-project</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <modules>
        <module>module-a</module>
        <module>module-b</module>
        <module>module-c</module>
    </modules>

    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <version>2.7.4</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

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

子模块的 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.example</groupId>
        <artifactId>my-parent-project</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <artifactId>module-a</artifactId>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

Maven 中的版本锁定

版本锁定是指在软件项目中明确指定依赖项的版本，以确保在构建和运行过程中使用的依赖项版本是一致的。这有助于：

避免依赖冲突： 确保项目中的所有依赖项都是兼容的，避免不同版本的依赖项之间的冲突。
确保可重现性： 确保每次构建的结果都是一样的，不受外部环境变化的影响。
提高稳定性： 通过固定版本号，可以减少因依赖项更新带来的潜在风险。

在 Maven 中，dependencies 和 dependencyManagement 是两个不同的元素，它们各自承担着不同的职责。
dependencies 元素用于声明项目直接依赖的库。这些依赖会被实际添加到项目的类路径中，并在构建过程中被下载和使用。
dependencyManagement 元素用于集中管理依赖项的版本。它通常出现在父项目的 POM 文件中，用于统一管理子项目中使用的依赖项版本。

1. 标签

在 Maven 中，可以使用 dependencyManagement 标签来集中管理依赖项的版本号。这样，在子模块或其他依赖声明中，只需要指定依赖项的坐标，而不需要指定版本号，版本号将从 dependencyManagement 中继承。

主要特点：

版本管理： 用于集中管理依赖项的版本，子项目可以引用而不必指定版本号。
非直接依赖： 声明的依赖不会被直接添加到类路径中，而是作为版本管理的参考。
子项目引用： 子项目可以在 dependencies>中引用 dependencyManagement中声明的依赖项，而不必指定版本号。
可选性： 不是必须的，但用于统一管理版本非常有用。

2.使用 标签

在 Maven 中，还可以使用 标签来自定义属性存储版本号，然后在依赖声明中引用这些属性。这种方式使得版本号的管理更加灵活和集中。

Maven 的聚合

在 Maven 中，聚合指的是在一个父项目（Parent Project）中定义多个子项目（Child Projects）。父项目本身不包含任何实际的源代码，它的主要作用是作为一个管理入口，用于统一管理和构建多个子项目。
它允许将多个相关的子项目（模块）组织在一起，并通过一个父项目来统一管理和构建这些子项目。聚合可以显著简化大型项目的管理和构建流程。

聚合的特点

组织结构： 聚合项目本身没有实际的代码，但包含了子项目的列表。
构建管理： 通过父项目可以一次性构建所有的子项目。
依赖管理： 虽然聚合项目本身不包含源代码，但它可以定义依赖管理、构建插件等配置，这些配置可以被子项目继承。
可扩展性： 随着项目的发展，可以方便地添加或移除子项目。

父项目 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.example</groupId>
    <artifactId>parent-project</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <!-- 列出所有子项目的相对路径，也就是需要聚合的模块 -->
    <modules>
        <module>child-project-a</module>
        <module>child-project-b</module>
        <module>child-project-c</module>
    </modules>

    <!-- 集中管理依赖项的版本 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.7.4</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!-- 定义构建插件 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

子项目的 POM 文件通常会继承父项目的配置，并添加具体的依赖和插件配置。
子项目 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.example</groupId>
        <artifactId>parent-project</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <artifactId>child-project-a</artifactId>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

构建整个项目： 进入父项目的目录，执行 Maven 命令来构建整个项目。这样命令会递归地构建所有子项目，并执行相应的生命周期阶段。

聚合与继承的区别

虽然聚合和继承在 Maven 中经常一起使用，但它们的功能有所不同：

**聚合：**通过父项目的 元素来组织和管理多个子项目。
**继承：**子项目通过 元素继承父项目的配置。

聚合的应用场景

聚合特别适用于以下场景：

多模块项目： 将一个大型项目拆分成多个小的、可管理的模块。
微服务架构： 每个服务作为一个独立的子项目，通过父项目统一管理。
组件化开发： 将项目划分为不同的功能模块或组件，通过父项目管理这些组件。

总结

本文章对于maven的进阶用法做了一些简单的介绍，可以帮助新手在学习时maven和springboot时，对于项目的构建管理部署有一定的基础。