本文详细介绍Maven的聚合（Aggregation）、继承（Inheritance）机制以及私服（私库）的配置与使用
1. Maven核心概念回顾
1.1 什么是Maven？
Maven是一个项目管理和构建自动化工具，主要用于Java项目。它基于**项目对象模型（POM）**的概念，可以管理项目的构建、报告和文档。
1.2 Maven仓库类型
┌─────────────────────────────────────────────────────────────────────┐
│ Maven仓库体系 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────┐ │
│ │ 本地仓库 │ ~/.m2/repository │
│ │ (Local) │ 存储所有下载的依赖和构建的项目 │
│ └──────┬───────┘ │
│ │ │
│ │ 优先查找 │
│ ▼ │
│ ┌──────────────┐ │
│ │ 私服仓库 │ 企业内部搭建（Nexus/Artifactory） │
│ │ (Private) │ 缓存公共依赖 + 存储企业内部依赖 │
│ └──────┬───────┘ │
│ │ │
│ │ 找不到时向上查找 │
│ ▼ │
│ ┌──────────────┐ │
│ │ 中央仓库 │ https://repo.maven.apache.org/maven2 │
│ │ (Central) │ Maven官方维护的公共仓库 │
│ └──────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘2. Maven聚合（多模块项目）
2.1 什么是聚合？
聚合（Aggregation） 是指将多个Maven模块组织在一起，通过一个父模块统一进行构建管理。聚合的目的是一次性构建多个项目。
2.2 聚合项目结构
┌─────────────────────────────────────────────────────────────────────┐
│ 聚合项目结构示意图 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ parent-project/ │
│ ├── pom.xml ← 父POM（packaging: pom） │
│ │ │
│ ├── module-common/ ← 公共模块 │
│ │ ├── pom.xml │
│ │ └── src/ │
│ │ │
│ ├── module-dao/ ← 数据访问层模块 │
│ │ ├── pom.xml │
│ │ └── src/ │
│ │ │
│ ├── module-service/ ← 业务逻辑层模块 │
│ │ ├── pom.xml │
│ │ └── src/ │
│ │ │
│ └── module-web/ ← Web层模块 │
│ ├── pom.xml │
│ └── src/ │
│ │
└─────────────────────────────────────────────────────────────────────┘2.3 父POM配置示例
<?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>com.example</groupId>
<artifactId>parent-project</artifactId>
<version>1.0.0-SNAPSHOT</version>
<!-- 聚合项目必须使用pom打包方式 -->
<packaging>pom</packaging>
<name>父项目</name>
<description>这是一个聚合父项目</description>
<!-- 聚合配置：声明子模块 -->
<modules>
<module>module-common</module>
<module>module-dao</module>
<module>module-service</module>
<module>module-web</module>
</modules>
</project>2.4 聚合构建流程
┌─────────────────────────────────────────────────────────────────────┐
│ 聚合构建流程图 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 执行 mvn clean install │
│ │ │
│ ▼ │
│ ┌───────────────────────┐ │
│ │ 父项目 (parent) │ │
│ │ packaging: pom │ │
│ └───────────┬───────────┘ │
│ │ │
│ ┌───────────────┼───────────────┐ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌───────────────┐ ┌───────────┐ ┌───────────────┐ │
│ │ module-common │ │module-dao │ │module-service │ │
│ │ 构建顺序:1 │ │ 构建顺序:2 │ │ 构建顺序:3 │ │
│ └───────────────┘ └───────────┘ └───────────────┘ │
│ │ │
│ ▼ │
│ ┌───────────────────┐ │
│ │ module-web │ │
│ │ 构建顺序:4 │ │
│ └───────────────────┘ │
│ │
│ 注：Maven会自动分析模块间的依赖关系，按正确顺序构建 │
│ │
└─────────────────────────────────────────────────────────────────────┘3. Maven继承
3.1 什么是继承？
继承（Inheritance） 是指子模块可以继承父模块的配置，包括依赖、插件、属性等。继承的目的是统一管理公共配置，消除重复。
3.2 继承关系图
┌─────────────────────────────────────────────────────────────────────┐
│ 继承关系示意图 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────┐ │
│ │ Super POM │ │
│ │ (Maven内置) │ │
│ │ - 默认仓库配置 │ │
│ │ - 默认插件配置 │ │
│ └──────────┬──────────┘ │
│ │ 隐式继承 │
│ ▼ │
│ ┌─────────────────────┐ │
│ │ Parent POM │ │
│ │ (企业/项目父POM) │ │
│ │ - 公共依赖管理 │ │
│ │ - 公共插件配置 │ │
│ │ - 公共属性定义 │ │
│ └──────────┬──────────┘ │
│ │ 显式继承 │
│ ┌──────────────────┼──────────────────┐ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌────────────────┐ ┌────────────────┐ ┌────────────────┐ │
│ │ Child POM 1 │ │ Child POM 2 │ │ Child POM 3 │ │
│ │ module-common │ │ module-dao │ │ module-service │ │
│ └────────────────┘ └────────────────┘ └────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘3.3 可继承的元素
| 元素类型 | 说明 | 是否可继承 |
|---|---|---|
| groupId | 项目组ID | ✅ 是 |
| version | 项目版本 | ✅ 是 |
| properties | 自定义属性 | ✅ 是 |
| dependencies | 项目依赖 | ✅ 是 |
| dependencyManagement | 依赖管理 | ✅ 是 |
| pluginManagement | 插件管理 | ✅ 是 |
| build.plugins | 构建插件 | ✅ 是 |
| repositories | 仓库配置 | ✅ 是 |
| artifactId | 项目唯一标识 | ❌ 否 |
3.4 父POM完整配置示例
<?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>com.example</groupId>
<artifactId>parent-project</artifactId>
<version>1.0.0-SNAPSHOT</version>
<packaging>pom</packaging>
<!-- ==================== 属性定义 ==================== -->
<properties>
<java.version>1.8</java.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<spring.version>5.3.20</spring.version>
<spring-boot.version>2.3.12.RELEASE</spring-boot.version>
<mysql.version>8.0.28</mysql.version>
<fastjson.version>1.2.83</fastjson.version>
</properties>
<!-- ==================== 依赖管理（子模块按需引入） ==================== -->
<dependencyManagement>
<dependencies>
<!-- Spring Boot依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>${spring-boot.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!-- MySQL驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<!-- FastJSON -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>${fastjson.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
<!-- ==================== 公共依赖（所有子模块都会继承） ==================== -->
<dependencies>
<!-- 单元测试 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
</dependencies>
<!-- ==================== 插件管理 ==================== -->
<build>
<pluginManagement>
<plugins>
<!-- 编译插件 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>${java.version}</source>
<target>${java.version}</target>
<encoding>${project.build.sourceEncoding}</encoding>
</configuration>
</plugin>
<!-- 打包插件 -->
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>${spring-boot.version}</version>
</plugin>
</plugins>
</pluginManagement>
</build>
</project>3.5 子模块POM配置示例
<?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>
<!-- 继承父POM -->
<parent>
<groupId>com.example</groupId>
<artifactId>parent-project</artifactId>
<version>1.0.0-SNAPSHOT</version>
<!-- 相对路径，默认值为../pom.xml -->
<relativePath>../pom.xml</relativePath>
</parent>
<!-- 子模块只需定义artifactId，groupId和version继承自父POM -->
<artifactId>module-dao</artifactId>
<packaging>jar</packaging>
<name>数据访问层模块</name>
<description>数据访问层模块，提供数据库操作功能</description>
<dependencies>
<!-- 引用父POM中dependencyManagement管理的依赖，无需指定版本 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
</dependency>
</dependencies>
</project>4. 聚合与继承的关系
4.1 概念对比
┌─────────────────────────────────────────────────────────────────────┐
│ 聚合 VS 继承 对比图 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────┐ ┌─────────────────────────┐ │
│ │ 聚合 │ │ 继承 │ │
│ │ (Aggregation) │ │ (Inheritance) │ │
│ ├─────────────────────────┤ ├─────────────────────────┤ │
│ │ │ │ │ │
│ │ 目的：统一构建多模块 │ │ 目的：复用公共配置 │ │
│ │ │ │ │ │
│ │ 关系：父 → 子 │ │ 关系：子 → 父 │ │
│ │ (父知道子模块) │ │ (子知道父模块) │ │
│ │ │ │ │ │
│ │ 配置位置： │ │ 配置位置： │ │
│ │ 父POM的<modules> │ │ 子POM的<parent> │ │
│ │ │ │ │ │
│ │ 打包方式：pom │ │ 打包方式：pom │ │
│ │ │ │ │ │
│ └─────────────────────────┘ └─────────────────────────┘ │
│ │
│ ┌───────────────┐ │
│ │ 最佳实践 │ │
│ │ 两者结合使用 │ │
│ └───────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘4.2 dependencies VS dependencyManagement
┌─────────────────────────────────────────────────────────────────────┐
│ dependencies 与 dependencyManagement 区别 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ dependencies │ │
│ ├─────────────────────────────────────────────────────────────┤ │
│ │ • 直接声明项目依赖 │ │
│ │ • 子模块会自动继承父POM中的所有dependencies │ │
│ │ • 适用于：所有子模块都需要的公共依赖 │ │
│ │ │ │
│ │ 示例场景：junit、logging等通用依赖 │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ dependencyManagement │ │
│ ├─────────────────────────────────────────────────────────────┤ │
│ │ • 只声明依赖版本，不实际引入 │ │
│ │ • 子模块需要显式声明依赖才会生效（但无需指定版本） │ │
│ │ • 适用于：部分子模块需要的依赖，统一版本管理 │ │
│ │ │ │
│ │ 示例场景：mysql驱动、redis客户端等特定模块依赖 │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘5. Maven私服详解
5.1 什么是私服？
私服（Private Repository） 是企业内部搭建的Maven仓库服务器，用于：
-
缓存中央仓库的依赖，加速构建
-
存储企业内部开发的私有组件
-
管理第三方非开源依赖
-
控制依赖版本，保证构建稳定性
5.2 常见私服产品
| 产品名称 | 开发商 | 特点 | 推荐度 |
|---|---|---|---|
| Nexus Repository | Sonatype | 功能强大，社区版免费 | ⭐⭐⭐⭐⭐ |
| JFrog Artifactory | JFrog | 企业级功能，支持多种包格式 | ⭐⭐⭐⭐⭐ |
| Apache Archiva | Apache | 开源免费，功能较基础 | ⭐⭐⭐ |
| 阿里云云效Maven | 阿里云 | 云服务，无需自建 | ⭐⭐⭐⭐ |
5.3 私服架构图
┌─────────────────────────────────────────────────────────────────────┐
│ 私服架构示意图 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 开发者电脑 │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │ 开发者A │ │ 开发者B │ │ 开发者C │ │ │
│ │ └────┬─────┘ └────┬─────┘ └────┬─────┘ │ │
│ └───────┼───────────────┼───────────────┼──────────────────┘ │
│ │ │ │ │
│ └───────────────┼───────────────┘ │
│ │ │
│ ▼ │
│ ┌────────────────┐ │
│ │ 企业私服 │ │
│ │ (Nexus等) │ │
│ ├────────────────┤ │
│ │ │ │
│ ┌──────────────┴────────────────┴──────────────┐ │
│ │ │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌──────────────┐ │
│ │ │ hosted │ │ proxy │ │ group │ │
│ │ │ (宿主仓库) │ │ (代理仓库) │ │ (仓库组) │ │
│ │ ├─────────────┤ ├─────────────┤ ├──────────────┤ │
│ │ │ releases │ │ 代理中央仓库 │ │ 聚合多个仓库 │ │
│ │ │ snapshots │ │ 代理阿里云 │ │ 提供统一入口 │ │
│ │ │ 3rd-party │ │ 代理其他源 │ │ │ │
│ │ └─────────────┘ └──────┬──────┘ └──────────────┘ │
│ │ │ │
│ └──────────────────────────┼─────────────────────────────────────┘
│ │ │
│ ▼ │
│ ┌────────────────────────────┐ │
│ │ 远程仓库 │ │
│ ├────────────────────────────┤ │
│ │ • Maven中央仓库 │ │
│ │ • 阿里云镜像 │ │
│ │ • 其他公共仓库 │ │
│ └────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘5.4 Nexus仓库类型
┌─────────────────────────────────────────────────────────────────────┐
│ Nexus仓库类型详解 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 1. Hosted Repository（宿主仓库） │ │
│ │ - 存储企业内部开发的私有组件 │ │
│ │ - releases：存放正式发布版本 │ │
│ │ - snapshots：存放开发中的快照版本 │ │
│ │ - 3rd-party：存放第三方非开源依赖 │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 2. Proxy Repository（代理仓库） │ │
│ │ - 代理远程仓库，缓存下载的依赖 │ │
│ │ - 开发者请求时，先从缓存查找 │ │
│ │ - 缓存未命中时，从远程仓库下载并缓存 │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 3. Group Repository（仓库组） │ │
│ │ - 聚合多个仓库，提供统一访问入口 │ │
│ │ - 开发者只需配置一个仓库地址 │ │
│ │ - 自动从组内各仓库查找依赖 │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘5.5 私服配置详解
5.5.1 settings.xml配置（全局配置）
<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0
http://maven.apache.org/xsd/settings-1.0.0.xsd">
<!-- 本地仓库路径 -->
<localRepository>D:/maven-repository</localRepository>
<!-- 服务器认证配置 -->
<servers>
<!-- 发布Release版本的认证 -->
<server>
<id>nexus-releases</id>
<username>admin</username>
<password>admin123</password>
</server>
<!-- 发布Snapshot版本的认证 -->
<server>
<id>nexus-snapshots</id>
<username>admin</username>
<password>admin123</password>
</server>
</servers>
<!-- 镜像配置 -->
<mirrors>
<!-- 配置私服镜像，拦截所有请求 -->
<mirror>
<id>nexus-mirror</id>
<!-- 匹配所有仓库 -->
<mirrorOf>*</mirrorOf>
<name>Nexus Mirror</name>
<url>http://192.168.1.100:8081/repository/maven-public/</url>
</mirror>
</mirrors>
<!-- Profile配置 -->
<profiles>
<profile>
<id>nexus</id>
<!-- 仓库配置 -->
<repositories>
<repository>
<id>nexus</id>
<url>http://192.168.1.100:8081/repository/maven-public/</url>
<releases>
<enabled>true</enabled>
</releases>
<snapshots>
<enabled>true</enabled>
<updatePolicy>always</updatePolicy>
</snapshots>
</repository>
</repositories>
<!-- 插件仓库配置 -->
<pluginRepositories>
<pluginRepository>
<id>nexus</id>
<url>http://192.168.1.100:8081/repository/maven-public/</url>
<releases>
<enabled>true</enabled>
</releases>
<snapshots>
<enabled>true</enabled>
</snapshots>
</pluginRepository>
</pluginRepositories>
</profile>
</profiles>
<!-- 激活Profile -->
<activeProfiles>
<activeProfile>nexus</activeProfile>
</activeProfiles>
</settings>5.5.2 项目pom.xml配置（发布配置）
<!-- 发布管理配置 -->
<distributionManagement>
<!-- Release版本发布仓库 -->
<repository>
<id>nexus-releases</id>
<name>Nexus Release Repository</name>
<url>http://192.168.1.100:8081/repository/maven-releases/</url>
</repository>
<!-- Snapshot版本发布仓库 -->
<snapshotRepository>
<id>nexus-snapshots</id>
<name>Nexus Snapshot Repository</name>
<url>http://192.168.1.100:8081/repository/maven-snapshots/</url>
</snapshotRepository>
</distributionManagement>5.6 依赖下载流程
┌─────────────────────────────────────────────────────────────────────┐
│ 依赖下载完整流程图 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 开发者执行 mvn compile │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ Step 1: 检查本地仓库 │ │
│ │ (~/.m2/repository) │ │
│ └────────────────────────┬─────────────────────────────────┘ │
│ │ │
│ ┌──────┴──────┐ │
│ │ 找到依赖? │ │
│ └──────┬──────┘ │
│ 是 ↙ ↘ 否 │
│ ▼ ▼ │
│ ┌───────────┐ ┌──────────────────────────────────┐ │
│ │ 使用本地 │ │ Step 2: 请求私服 │ │
│ │ 缓存依赖 │ │ (Nexus Group Repository) │ │
│ └───────────┘ └───────────────────┬──────────────┘ │
│ │ │
│ ┌──────┴──────┐ │
│ │ 私服有缓存? │ │
│ └──────┬──────┘ │
│ 是 ↙ ↘ 否 │
│ ▼ ▼ │
│ ┌───────────────┐ ┌─────────────────┐
│ │ 返回缓存依赖 │ │ Step 3: │
│ │ 保存到本地 │ │ 私服代理请求 │
│ └───────────────┘ │ 中央仓库 │
│ └────────┬────────┘
│ │ │
│ ▼ │
│ ┌───────────────┐ │
│ │ 下载依赖 │ │
│ │ ↓ │ │
│ │ 私服缓存 │ │
│ │ ↓ │ │
│ │ 返回开发者 │ │
│ │ ↓ │ │
│ │ 本地缓存 │ │
│ └───────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘5.7 发布组件到私服
发布命令
# 发布到私服（根据版本号自动判断发布到releases还是snapshots）
mvn deploy
# 跳过测试发布
mvn deploy -DskipTests
# 发布指定模块
mvn deploy -pl module-common -am版本号规范
┌─────────────────────────────────────────────────────────────────────┐
│ 版本号命名规范 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ Release版本（正式版） │
│ ├── 1.0.0 │
│ ├── 1.0.1 │
│ ├── 1.1.0 │
│ └── 2.0.0 │
│ │
│ Snapshot版本（快照版） │
│ ├── 1.0.0-SNAPSHOT │
│ ├── 1.1.0-SNAPSHOT │
│ └── 2.0.0-SNAPSHOT │
│ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 版本号格式：主版本.次版本.修订版本[-SNAPSHOT] │ │
│ │ │ │
│ │ • 主版本：重大功能变更，可能不兼容 │ │
│ │ • 次版本：新增功能，向后兼容 │ │
│ │ • 修订版本：Bug修复，向后兼容 │ │
│ │ • SNAPSHOT：开发中版本，每次构建都会更新 │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘6. 实战案例
6.1 企业级多模块项目结构
┌─────────────────────────────────────────────────────────────────────┐
│ 企业级项目结构示例 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ my-enterprise-project/ │
│ │ │
│ ├── pom.xml ← 父POM（聚合+继承） │
│ │ │
│ ├── my-common/ ← 公共模块 │
│ │ ├── pom.xml │
│ │ └── src/ │
│ │ └── main/java/ │
│ │ └── com/example/common/ │
│ │ ├── util/ ← 工具类 │
│ │ ├── exception/ ← 异常定义 │
│ │ └── constant/ ← 常量定义 │
│ │ │
│ ├── my-model/ ← 实体模块 │
│ │ ├── pom.xml │
│ │ └── src/ │
│ │ └── main/java/ │
│ │ └── com/example/model/ │
│ │ ├── entity/ ← 实体类 │
│ │ ├── dto/ ← 数据传输对象 │
│ │ └── vo/ ← 视图对象 │
│ │ │
│ ├── my-dao/ ← 数据访问层 │
│ │ ├── pom.xml │
│ │ └── src/ │
│ │ └── main/ │
│ │ ├── java/ │
│ │ │ └── com/example/dao/ │
│ │ │ └── mapper/← MyBatis Mapper │
│ │ └── resources/ │
│ │ └── mapper/ ← Mapper XML │
│ │ │
│ ├── my-service/ ← 业务逻辑层 │
│ │ ├── pom.xml │
│ │ └── src/ │
│ │ └── main/java/ │
│ │ └── com/example/service/ │
│ │ ├── impl/ ← 服务实现 │
│ │ └── interfaces/← 服务接口 │
│ │ │
│ └── my-web/ ← Web层（可运行） │
│ ├── pom.xml │
│ └── src/ │
│ └── main/ │
│ ├── java/ │
│ │ └── com/example/web/ │
│ │ ├── controller/← 控制器 │
│ │ ├── config/ ← 配置类 │
│ │ └── Application.java │
│ └── resources/ │
│ ├── application.yml │
│ └── static/ │
│ │
└─────────────────────────────────────────────────────────────────────┘6.2 模块依赖关系图
┌─────────────────────────────────────────────────────────────────────┐
│ 模块依赖关系图 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────┐ │
│ │ my-web │ │
│ │ (可运行) │ │
│ └──────┬───────┘ │
│ │ 依赖 │
│ ▼ │
│ ┌──────────────┐ │
│ │ my-service │ │
│ │ (业务逻辑层) │ │
│ └──────┬───────┘ │
│ │ 依赖 │
│ ▼ │
│ ┌──────────────┐ │
│ │ my-dao │ │
│ │ (数据访问层) │ │
│ └──────┬───────┘ │
│ │ 依赖 │
│ ▼ │
│ ┌──────────────┐ │
│ │ my-model │ │
│ │ (实体模块) │ │
│ └──────┬───────┘ │
│ │ 依赖 │
│ ▼ │
│ ┌──────────────┐ │
│ │ my-common │ │
│ │ (公共模块) │ │
│ └──────────────┘ │
│ │
│ 依赖传递：my-web 会自动获得所有下层模块的依赖 │
│ │
└─────────────────────────────────────────────────────────────────────┘6.3 常用Maven命令
# ==================== 基础命令 ====================
# 清理项目（删除target目录）
mvn clean
# 编译项目
mvn compile
# 运行测试
mvn test
# 打包项目
mvn package
# 安装到本地仓库
mvn install
# 发布到远程仓库
mvn deploy
# ==================== 组合命令 ====================
# 清理并打包，跳过测试
mvn clean package -DskipTests
# 清理并安装到本地仓库
mvn clean install
# 清理并发布到私服
mvn clean deploy -DskipTests
# ==================== 多模块命令 ====================
# 只构建指定模块
mvn clean install -pl my-common
# 构建指定模块及其依赖模块
mvn clean install -pl my-service -am
# 构建指定模块及依赖它的模块
mvn clean install -pl my-common -amd
# ==================== 查看依赖 ====================
# 查看依赖树
mvn dependency:tree
# 分析依赖（查找无用依赖和缺失依赖）
mvn dependency:analyze
# 查看有效POM（合并所有继承后的完整POM）
mvn help:effective-pom7. 最佳实践总结
7.1 项目结构建议
┌─────────────────────────────────────────────────────────────────────┐
│ 最佳实践清单 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ ✅ 推荐做法 │
│ ├── 使用聚合+继承结合的方式管理多模块项目 │
│ ├── 在父POM中使用dependencyManagement统一管理依赖版本 │
│ ├── 只在父POM的dependencies中放置所有模块都需要的公共依赖 │
│ ├── 使用properties集中定义版本号 │
│ ├── 为企业搭建Maven私服 │
│ ├── 使用语义化版本号（主版本.次版本.修订版本） │
│ ├── 开发阶段使用SNAPSHOT版本，发布时改为正式版本 │
│ └── 定期清理私服中的过期SNAPSHOT版本 │
│ │
│ ❌ 避免做法 │
│ ├── 在子模块中硬编码依赖版本号 │
│ ├── 在父POM的dependencies中放置非公共依赖 │
│ ├── 直接依赖中央仓库而不使用私服 │
│ ├── 随意修改已发布的Release版本 │
│ └── 在不同模块使用不同版本的同一依赖 │
│ │
└─────────────────────────────────────────────────────────────────────┘7.2 依赖管理原则
- 最小依赖原则：只引入必需的依赖，避免依赖膨胀
- 版本统一原则：同一依赖在所有模块使用相同版本
- 显式声明原则：明确声明直接依赖，不依赖传递依赖
- 排除冲突原则：发现依赖冲突时及时排除或统一版本