仅一篇精通Maven

一 介绍

Maven是一個項目管理工具，將項目开发和管理过程抽象成一个对象模型(POM)

Maven的作用

• 项目构建：提供标准的、跨平台的自动化项目构建方式

• 依赖管理：方便快捷的管理项目依赖的资源（jar包），避免资源间的版本冲突问题

• 统一开发结构：提供标准的、统一的项目结构

二 安装和配置

Maven安装和配置-CSDN博客

三 基础概念

1. 仓库

1. 仓库：用于存储资源，包含各种jar包

2. 仓库分类：

• 本地仓库：自己电脑上存储资源的仓库，连接远程仓库获取资源
• 远程仓库：非本机电脑上的仓库，为本地仓库提供资源
• 中央仓库：Maven团队维护，存储所有资源的仓库
• 私服：部门/公司范围内存储资源的仓库，从中央仓库获取资源
• 私服的作用：

1. 存放私有资源
2. 一定范围内共享资源

2. 坐标

1. 坐标：Maven中的坐标用于描述仓库中资源的位置
   仓库存储目录
2. Maven坐标主要组成

• groupld：定义当前Maven项目隶属组织名称（通常是域名反写，例如：org.mybatis）
• artifactld：定义当前Maven项目名称（通常是模块名称，例如CRM、SMS）
• version：定义当前项目版本号
• packaging：定义该项目的打包方式
• scope: 定义依赖的作用范围

3. 坐标作用
   使用唯一标识，唯一性定位资源位置，通过该标识可以将资源的识别与下载工作交由机器完成
4. 坐标示例

    <dependencies>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>3.0.3</version>
        </dependency>
    </dependencies>

三 资源获取

1. 资源搜索（中央仓库）
2. 获取资源坐标
3. 转移坐标到pom.xml文件

四 文件配置

1. 文件头部定义项目

<?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>
    <groupId>qzer</groupId>
    <artifactId>mbs1</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mbs1</name>
    <description>mbs1</description>
</project>

2. 引入依赖

<dependencies>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>3.0.3</version>
        </dependency>
</dependencies>

3. 引入插件

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

4. 自定义变量

    <properties>
        <var1>17</var1>
    </properties>

5. 多环境开发

    <profiles>
        <profile>
<!--            id:环境名称-->
            <id>dev</id>
<!--            properties:环境中的变量-->
            <properties>
                <jdbc.name>name</jdbc.name>
            </properties>
<!--            设置为默认环境-->
            <activation>
                <activeByDefault>true</activeByDefault>
            </activation>
        </profile>
    </profiles>

6. 其他配置文件使用pom.xml定义的变量

• 第一步

    <build>
        <resources>
            <resource>
            <!-- directory 配置文件所在位置-->
                <directory>src/main/resources</directory>  
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

• 第二步
  其他配置文件(以properties.yml为例)引用变量
  引用方法${var}

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/db01
    username: ${jdbc.name}   #这里使用了pom定义的变量jdbc.name
    password: 1111
    driver-class-name: com.mysql.cj.jdbc.Driver

五 依赖

依赖具有传递性

• 直接依赖：在当前项目中通过依赖配置建立的依赖关系
• 间接依赖：被资源的资源如果依赖其他资源，当前项目间接依赖其他资源

依赖传递冲突问题

• 路径优先：当依赖中出现相同的资源时，层级越深，优先级越低，层级越浅，优先级越高
• 声明优先：当资源在相同层级被依赖时，配置顺序靠前的覆盖配置顺序靠后的
• 特殊优先：当同级配置了相同资源的不同版本，后配置的覆盖先配置的

排除依赖

• 排除依赖指主动断开依赖的资源，被排除的资源无需指定版本

  <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <exclusions>
          <exclusion>
              <groupid>org.hanorest</groupid>
              <artifactId>hamorest-core</artifactId>
          </exclusion>
      </exclusions>
  </dependency>
  

依赖范围

依赖的jar默认情况可以在任何地方使用，可以通过scope标签设定其作用范围

其属性值有compile provided runtime system test

作用范围

• 主程序范围有效（main文件夹范围内）
• 测试程序范围有效（test文件夹范国内）
• 是否参与打包（package指令范围内）

依赖范围传递性

• 带有依赖范围的资源在进行传递时，作用范围将受到影响

六 聚合

聚合功能允许你通过一个父pom（Project Object Model）来管理多个子模块。

聚合项目的父pom不会包含实际的源代码，它主要用于声明和管理其子模块。

以下是如何使用Maven聚合的步骤：

1. 创建父pom

• 首先，你需要创建一个maven项目作为聚合项目的父pom。这个pom应该位于你的所有子模块的顶层目录中。

• 在pom.xml文件中，你需要添加<packaging>pom</packaging>来指定这是一个聚合项目。

• 同时，你需要定义<modules>标签来列出所有的子模块。

• 示例

  <project>  
    <modelVersion>4.0.0</modelVersion>  
    <groupId>com.example</groupId>  
    <artifactId>parent-project</artifactId>  
    <version>1.0-SNAPSHOT</version>  
    <packaging>pom</packaging>  
    
    <modules>  
      <module>module1</module>  
      <module>module2</module>  
      <!-- 其他子模块 -->  
    </modules>  
    
    <!-- 其他配置，如依赖管理、插件管理等 -->  
  </project>
  

2. 创建子模块

• 在父pom的同级目录下，为每个子模块创建一个目录，并在每个目录中创建一个新的maven项目。

• 每个子模块都应该有自己的pom.xml文件，并且它们的groupId和version应该与父pom中的相同。

• 例如，对于module1，其pom.xml可能如下所示：

<modelVersion>4.0.0</modelVersion>  
<artifactId>module1</artifactId>  

<!-- 其他配置，如依赖、插件等 -->  

3. 构建聚合项目

• 在父POM的目录中运行Maven命令（如mvn clean install）将构建所有的子模块。

• Maven将首先构建列在<modules>标签中的第一个子模块，然后依次构建其他子模块。

  如果模块间存在依赖关系，某子模块构造前会先构造其依赖模块。

4. 注意

• 确保父POM和所有子模块的groupId和version都是相同的。
• 子模块的artifactId应该是唯一的，并且应该与它们的目录名匹配。
• 在子模块的pom.xml中，通过<parent>标签引用父POM。
• 使用<dependencyManagement>在父POM中管理依赖项的版本。
• 父pom中<modules>标签内确保每个<module>属性值唯一，不出现重复引入相同子模块。

七 模块继承

在 Maven 中使用继承通常涉及到一个父 POM（Parent POM）和多个子模块（Child Modules）。

父POM通常包含所有子模块共有的配置，如依赖管理（<dependencyManagement>）、插件管理（<pluginManagement>）、属性（<properties>）等。

子模块则通过 <parent> 元素引用父 POM，从而继承这些配置。

以下是使用 Maven 继承的基本步骤：

1. 创建父 POM

首先，你需要创建一个父 POM 文件（例如 pom-parent.xml）。

在这个文件中，你可以定义共有的配置，如 <dependencyManagement> <properties>。

注意 <packaging> 设置为 pom，表示这是一个父 POM，它不包含可执行的代码。

<!-- pom-parent.xml -->  
<project>  
    <modelVersion>4.0.0</modelVersion>  
    <groupId>com.example</groupId>  
    <artifactId>pom-parent</artifactId>  
    <version>1.0.0</version>  
    <packaging>pom</packaging>  

    <name>Parent POM</name>  

    <properties>  
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
        <maven.compiler.source>1.8</maven.compiler.source>  
        <maven.compiler.target>1.8</maven.compiler.target>  
        <my.custom.version>1.0.0</my.custom.version>  
        <!-- 定义其他自定义变量 -->  
    </properties>  

    <dependencyManagement>  
        <dependencies>  
            <dependency>  
                <groupId>org.springframework.boot</groupId>  
                <artifactId>spring-boot-starter-web</artifactId>  
                <version>2.5.0</version>  
            </dependency>  
            <!-- 其他依赖项管理 -->  
        </dependencies>  
    </dependencyManagement>  

    <!-- 其他共有配置，如插件管理、属性等 -->  
   
    <build>  
        <pluginManagement>  
            <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>  
        </pluginManagement>  
    </build>  
</project>

2. 创建子模块 POM

对于每个子模块，你需要创建一个 POM文件（例如 pom-child.xml），并在其中通过 <parent> 元素引用父 POM。

在子模块的 <dependencies> 中，你可以直接引用在父 POM 的 <dependencyManagement> 中定义的依赖项，而无需指定版本。

<!-- pom-child.xml -->  
<project>  
    <modelVersion>4.0.0</modelVersion>  
    <parent>  
        <groupId>com.example</groupId>  
        <artifactId>pom-parent</artifactId>  
        <version>1.0.0</version>  
        <!-- 如果父 POM 和子模块在同一个 Maven 仓库中，则不需要指定 <relativePath> -->  
        <!-- <relativePath/>  如果父 POM 不在默认位置，可以通过这个元素指定父 POM 的路径 填写的是父pom.xml的路径 -->  
    </parent>  

    <artifactId>child-module</artifactId>  

    <dependencies>  
        <dependency>  
            <groupId>org.springframework.boot</groupId>  
            <artifactId>spring-boot-starter-web</artifactId>  
            <!-- 无需指定版本，因为版本已在父 POM 的 <dependencyManagement> 中定义 -->  
        </dependency>  
        <!-- 其他依赖项 -->  
        <dependency>  
            <groupId>com.example</groupId>  
            <artifactId>some-dependency</artifactId>  
            <version>${my.custom.version}</version>  <!-- 使用了父模块定义的变量 -->
        </dependency>  
        <!-- 其他依赖项 -->  
    </dependencies>  

    <build>  
        <plugins>  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-compiler-plugin</artifactId>  
                <!-- 这里不需要指定 <version>，因为它已经在父 POM 中定义 -->  
                <!-- 可以覆盖或添加额外的配置 -->  
                <configuration>  
                    <source>${maven.compiler.source}</source>  
                    <target>${maven.compiler.target}</target>  
                </configuration>  
            </plugin>  
            <!-- 其他插件 -->  
        </plugins>  
    </build>  
    <!-- 其他子模块特有的配置 -->  
</project>

3，构建项目

在命令行中，你可以使用 Maven 命令来构建项目。

由于你使用了继承，因此你需要在包含所有子模块的根目录下执行 Maven 命令，或者分别进入每个子模块的目录并执行 Maven 命令。

例如，在根目录下执行以下命令来构建所有子模块：

mvn clean install

或者，进入子模块的目录并执行相同的命令来单独构建子模块。

这样，你就成功地使用了 Maven 的继承特性来管理多模块项目的配置和依赖项。

八 模块拆分

分模块开发要点:

• 模块中仅包含当前模块对应的功能类与配置文件

• spring核心配置根据模块功能不同进行独立制作

• 当前模块所依赖的模块通过导入坐标的形式加入当前模块后才可以使用

  web.xml需要加载所有的spring核心配置文件