文章目录
- 前言
- 一、Maven介绍
-
- [1. 基于XML语言的Maven](#1. 基于XML语言的Maven)
- [2. 核心特性](#2. 核心特性)
- [3. 发展历史](#3. 发展历史)
- [4. 主要功能和优势](#4. 主要功能和优势)
- [5. 主流构建工具对比](#5. 主流构建工具对比)
- 二、环境配置
-
- [1. 安装 JDK](#1. 安装 JDK)
- [2. Maven 下载安装](#2. Maven 下载安装)
- [3. 设置 Maven 环境变量](#3. 设置 Maven 环境变量)
- [4. 配置 Maven 本地仓库](#4. 配置 Maven 本地仓库)
- [三、第一个 Maven 项目](#三、第一个 Maven 项目)
-
- [1. 创建 Maven 项目](#1. 创建 Maven 项目)
- [2. 项目结构解析](#2. 项目结构解析)
- [3. 构建与运行](#3. 构建与运行)
- [4. 扩展：修改项目](#4. 扩展：修改项目)
- [5. 常见问题](#5. 常见问题)
-
- [1. 依赖下载失败](#1. 依赖下载失败)
- [2. 编译版本问题](#2. 编译版本问题)
- [6. 总结](#6. 总结)
- [四、Maven POM](#四、Maven POM)
-
- [1. POM 简介](#1. POM 简介)
- [2. POM 文件基本结构](#2. POM 文件基本结构)
- [3. 依赖管理](#3. 依赖管理)
- [4. 插件管理](#4. 插件管理)
- [5. 其他常用元素](#5. 其他常用元素)
- [6. 继承和聚合](#6. 继承和聚合)
- [7. 父（Super）POM](#7. 父（Super）POM)
- [8. Maven 仓库](#8. Maven 仓库)
- [9. POM 标签大全详解](#9. POM 标签大全详解)
- [10. 完整示例](#10. 完整示例)
- [五、Maven 构建生命周期](#五、Maven 构建生命周期)
-
- [1. clean 生命周期](#1. clean 生命周期)
- [2. default 生命周期](#2. default 生命周期)
- [3. site 生命周期](#3. site 生命周期)
- [4. 生命周期小结](#4. 生命周期小结)
- [六、Maven 构建配置文件](#六、Maven 构建配置文件)
-
- [1. 构建配置文件的类型](#1. 构建配置文件的类型)
- [2. 配置文件激活](#2. 配置文件激活)
- 七、构建部署
-
- [1. Maven 快照(SNAPSHOT)](#1. Maven 快照(SNAPSHOT))
- [2. 自动化构建](#2. 自动化构建)
- [3. Maven 自动化部署](#3. Maven 自动化部署)
- [八、Maven 常用命令](#八、Maven 常用命令)
前言
Maven
Maven 是一个 项目管理与构建自动化工具，主要用于 Java 项目，但也可用于其他语言（如 Kotlin、C#，Ruby，Scala 和其他语言）。可以对项目进行构建、依赖管理。
一、Maven介绍
1. 基于XML语言的Maven
Maven 翻译为"专家"、"内行"，是 Apache 下的一个纯 Java 开发的开源项目。基于项目对象模型（缩写：POM）概念，Maven利用一个中央信息片断能管理一个项目的构建、报告和文档等步骤。
Maven 曾是 Jakarta 项目的子项目，现为由 Apache 软件基金会主持的独立 Apache 项目。
Maven 可以帮助开发者确定特定软件的构建方式及其不同的依赖关系。它使用XML文件描述正在构建的项目以及与第三方模块有关的软件依赖性，构建顺序以及所需的插件。可以提前定义打包和编译之类的任务。
Maven将从不同的仓库下载库和插件，然后将它们全部放入本地计算机的缓存中。虽然主要用于Java项目，但是开发者可以将其用于Scala，Ruby和C＃以及其他多种语言。
2. 核心特性
Maven 解决了软件构建的两方面问题：
- 一是软件是如何构建的。
- 二是软件的依赖关系。
Maven 的核心功能包括：
-
项目构建（编译、测试、打包、部署）
-
依赖管理（自动下载和管理第三方库）
-
标准化项目结构（约定优于配置）
-
插件扩展（支持自定义构建流程）
3. 发展历史
-
2002年 ：Maven 由 Jason van Zyl 创建，用于替代 Apache Ant（Ant 需要手动编写构建脚本，而 Maven 提供标准化流程）。
-
2004年：Maven 1.0 发布。
-
2005年 ：Maven 2.0 引入 POM（Project Object Model） 和 依赖管理。
-
2010年：Maven 3.0 发布，优化性能并改进 API。
-
现在：Maven 仍然是 Java 生态中最流行的构建工具之一，与 Gradle 共同主导市场。
4. 主要功能和优势
| 功能 | 说明 |
|---|---|
| 依赖管理 | 自动下载和管理 .jar 文件，避免手动管理依赖 |
| 标准化构建流程 | 提供 clean、compile、test、package 等标准生命周期 |
| 项目模板（Archetype） | 快速生成项目结构（如 maven-archetype-quickstart） |
| 多模块支持 | 适用于大型项目，可以拆分为多个子模块 |
| 插件扩展 | 支持自定义构建任务（如 maven-compiler-plugin 指定 Java 版本） |
优势：
-
减少配置 ：约定优于配置，减少
build.xml（Ant）这样的手动配置。 -
依赖自动管理：只需声明依赖，Maven 自动下载并处理冲突。
-
跨平台：基于 Java，可在 Windows、Linux、macOS 上运行。
-
与 IDE 集成：Eclipse、IntelliJ IDEA、VS Code 都支持 Maven。
5. 主流构建工具对比
| 工具 | 特点 | 适用场景 |
|---|---|---|
| Maven | 基于 XML 配置，依赖管理强，标准化构建流程 | 传统 Java 项目，需要稳定依赖管理 |
| Gradle | 基于 Groovy/Kotlin DSL，构建脚本更灵活，性能更好 | Android、Kotlin 项目，需要自定义构建流程 |
| Ant | 基于 XML，手动编写构建步骤，灵活性高 | 遗留项目，需要精细控制构建过程 |
二、环境配置
1. 安装 JDK
- 下载 JDK
推荐 JDK 8/11/17
如果你还未安装 JDK，可以参考 Java 开发环境配置。
- 系统要求
| 项目 | 要求 |
|---|---|
| JDK | Maven 3.3 要求 JDK 1.7 或以上 Maven 3.2 要求 JDK 1.6 或以上 Maven 3.0/3.1 要求 JDK 1.5 或以上 |
| 内存 | 没有最低要求 |
| 磁盘 | Maven 自身安装需要大约 10 MB 空间。除此之外，额外的磁盘空间将用于你的本地 Maven 仓库。你本地仓库的大小取决于使用情况，但预期至少 500 MB |
| 操作系统 | 没有最低要求 |
- 检查 Java 环境
| 操作系统 | 任务 | 命令 |
|---|---|---|
| Windows | 打开命令控制台 | c:> java -version |
| Linux | 打开命令终端 | # java -version |
| Mac | 打开终端 | $ java -version |
2. Maven 下载安装
Maven 下载地址：Download Apache Maven -- Maven
不同平台下载对应的包：
| 系统 | 包名 |
|---|---|
| Windows | apache-maven-3.3.9-bin.zip |
| Linux | apache-maven-3.3.9-bin.tar.gz |
| Mac | apache-maven-3.3.9-bin.tar.gz |
下载包后解压到对应目录：
| 系统 | 存储位置 (可根据自己情况配置) |
|---|---|
| Windows | E:\Maven\apache-maven-3.3.9 |
| Linux | /usr/local/apache-maven-3.3.9 |
| Mac | /usr/local/apache-maven-3.3.9 |
3. 设置 Maven 环境变量
添加环境变量 MAVEN_HOME：
- Windows
右键 "计算机"，选择 "属性"，之后点击 "高级系统设置"，点击"环境变量"，来设置环境变量，有以下系统变量需要配置：新建系统变量 MAVEN_HOME，变量值：E:\Maven\apache-maven-3.3.9
编辑
系统变量 Path，添加变量值：;%MAVEN_HOME%\bin
注意：多个值之间需要有分号隔开，然后点击确定。
- Linux
下载解压：
shell
wget http://mirrors.hust.edu.cn/apache/maven/maven-3/3.3.9/binaries/apache-maven-3.3.9-bin.tar.gz
tar -xvf apache-maven-3.3.9-bin.tar.gz
sudo mv -f apache-maven-3.3.9 /usr/local/编辑 /etc/profile 文件 sudo vim /etc/profile，在文件末尾添加如下代码：
shell
export MAVEN_HOME=/usr/local/apache-maven-3.3.9
export PATH=${PATH}:${MAVEN_HOME}/bin保存文件，并运行如下命令使环境变量生效：
shell
source /etc/profile在控制台输入如下命令，如果能看到 Maven 相关版本信息，则说明 Maven 已经安装成功：
shell
mvn -v- Mac
下载解压：
shell
$ curl -O http://mirrors.hust.edu.cn/apache/maven/maven-3/3.3.9/binaries/apache-maven-3.3.9-bin.tar.gz
$ tar -xvf apache-maven-3.3.9-bin.tar.gz
$ sudo mv -f apache-maven-3.3.9 /usr/local/编辑 /etc/profile 文件 sudo vim /etc/profile，在文件末尾添加如下代码：
shell
export MAVEN_HOME=/usr/local/apache-maven-3.3.9
export PATH=${PATH}:${MAVEN_HOME}/bin保存文件，并运行如下命令使环境变量生效：
shell
$ source /etc/profile在控制台输入如下命令，如果能看到 Maven 相关版本信息，则说明 Maven 已经安装成功：
shell
$ mvn -v
Apache Maven 3.3.9 (bb52d8502b132ec0a5a3f4c09453c07478323dc5; 2015-11-11T00:41:47+08:00)
Maven home: /usr/local/apache-maven-3.3.9
Java version: 1.8.0_31, vendor: Oracle Corporation
Java home: /Library/Java/JavaVirtualMachines/jdk1.8.0_31.jdk/Contents/Home/jre
Default locale: zh_CN, platform encoding: ISO8859-1
OS name: "mac os x", version: "10.13.4", arch: "x86_64", family: "mac"- 验证安装
shell
mvn -v
# 应输出 Maven 版本和 Java 信息4. 配置 Maven 本地仓库
Maven 默认从远程仓库下载依赖，并存储在本地：
默认本地仓库路径：
-
Windows:
C:\Users\<用户名>\.m2\repository -
Linux/macOS:
~/.m2/repository
修改仓库位置（可选）：
在 MAVEN_HOME/conf/settings.xml 中修改：
xml
<localRepository>/path/to/your/repo</localRepository>三、第一个 Maven 项目
1. 创建 Maven 项目
- 使用 Maven Archetype 生成项目
Maven 提供了项目模板（Archetype），可以快速生成标准项目结构。最常用的是 maven-archetype-quickstart（基础 Java 项目模板）。
执行命令：
shell
mvn archetype:generate \
-DgroupId=com.example \
-DartifactId=my-first-app \
-DarchetypeArtifactId=maven-archetype-quickstart \
-DinteractiveMode=false参数说明：
| 参数 | 说明 |
|---|---|
-DgroupId |
组织名（如公司域名倒写） |
-DartifactId |
项目名称（会成为项目文件夹名） |
-DarchetypeArtifactId |
使用的模板（quickstart 是基础 Java 项目） |
-DinteractiveMode=false |
非交互模式（避免手动确认） |
这会生成一个标准 Maven 项目结构：
bash
my-first-app/
├── pom.xml # Maven 项目配置文件
├── src/
│ ├── main/ # 主代码目录
│ │ └── java/ # Java 源代码
│ │ └── com/example/App.java # 自动生成的示例类
│ └── test/ # 测试代码目录
│ └── java/ # 测试类
│ └── com/example/AppTest.java # 自动生成的测试类2. 项目结构解析
- pom.xml 详解
这是 Maven 的核心配置文件，定义了项目的基本信息和依赖。
生成的 pom.xml 示例：
xml
<project>
<!-- POM 模型版本，固定 4.0.0 -->
<modelVersion>4.0.0</modelVersion>
<!-- 项目坐标（唯一标识） -->
<groupId>com.example</groupId>
<artifactId>my-first-app</artifactId>
<version>1.0-SNAPSHOT</version>
<!-- 项目打包方式（默认 jar，也可以是 war、pom 等） -->
<packaging>jar</packaging>
<!-- 项目名称和 URL（可选） -->
<name>my-first-app</name>
<url>http://www.example.com</url>
<!-- 依赖管理 -->
<dependencies>
<!-- JUnit 测试依赖 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope> <!-- 仅用于测试 -->
</dependency>
</dependencies>
</project>- 源代码结构
| 目录 | 作用 |
|---|---|
src/main/java |
主 Java 源代码 |
src/main/resources |
配置文件（如 application.properties） |
src/test/java |
测试代码 |
src/test/resources |
测试资源文件 |
- 示例代码：
主类 App.java
java
package com.example;
public class App {
public static void main(String[] args) {
System.out.println("Hello Maven!");
}
}测试类 AppTest.java:
java
package com.example;
import org.junit.Test;
import static org.junit.Assert.*;
public class AppTest {
@Test
public void testApp() {
assertTrue(true); // 示例测试
}
}3. 构建与运行
- 常用 Maven 命令
| 命令 | 作用 |
|---|---|
mvn compile |
编译源代码 |
mvn test |
运行测试 |
mvn package |
打包（生成 .jar 文件） |
mvn install |
安装到本地仓库（供其他项目依赖） |
mvn clean |
清理 target 目录 |
- 完整构建流程
(1) 编译项目：
bash
mvn compile编译后的 .class 文件会放在 target/classes 目录。
(2) 运行测试：
bash
mvn test执行 src/test/java 下的测试类。
测试报告生成在 target/surefire-reports。
(3) 打包：
bash
mvn package生成 target/my-first-app-1.0-SNAPSHOT.jar。
(4) 运行程序：
bash
java -cp target/my-first-app-1.0-SNAPSHOT.jar com.example.App(5) 输出：
bash
Hello Maven!4. 扩展：修改项目
- 添加依赖
例如，添加 Gson 用于 JSON 处理：
修改 pom.xml：
xml
<dependencies>
<!-- 原有 JUnit 依赖 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- 新增 Gson 依赖 -->
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.9</version>
</dependency>
</dependencies>运行 mvn compile，Maven 会自动下载 Gson。
- 修改主类使用 Gson
java
package com.example;
import com.google.gson.Gson;
public class App {
public static void main(String[] args) {
Gson gson = new Gson();
String json = gson.toJson("Hello Maven with Gson!");
System.out.println(json);
}
}重新打包并运行：
bash
mvn package
java -cp target/my-first-app-1.0-SNAPSHOT.jar com.example.App输出：
bash
"Hello Maven with Gson!"5. 常见问题
1. 依赖下载失败
原因：网络问题或仓库不可用。
解决方案：
检查网络连接。
配置国内镜像仓库（如阿里云）：
aliyun https://maven.aliyun.com/repository/public central
阿里云仓库介绍：仓库服务。
2. 编译版本问题
错误：javac: invalid target release: 11
解决方案：在 pom.xml 中指定 Java 版本：
6. 总结
-
创建项目 ：
mvn archetype:generate生成标准结构。 -
项目结构：
-
pom.xml定义依赖和配置。 -
src/main/java放主代码，src/test/java放测试代码。
- 构建命令：
mvn compile→mvn test→mvn package。
- 运行 ：
java -jar或java -cp执行.jar文件。
四、Maven POM
1. POM 简介
POM ( Project Object Model，项目对象模型 ) 是 Maven 的核心配置文件，采用 XML 格式，默认命名为 pom.xml。
POM 是 Maven 工程的基本工作单元，是一个 XML 文件，包含了项目的基本信息，用于描述项目如何构建，声明项目依赖，等等。
执行任务或目标时，Maven 会在当前目录中查找 POM，获取所需的配置信息，然后执行目标。
POM 中可以指定以下配置：
- 项目依赖
- 插件
- 执行目标
- 项目构建 profile
- 项目版本
- 项目开发者列表
- 相关邮件列表信息
2. POM 文件基本结构
xml
<!-- 工程的根标签 -->
<project>
<!-- 1. 基础信息 -->
<!-- 模型版本。需要设置为 4.0 -->
<modelVersion>4.0.0</modelVersion>
<!-- 工程组的标识，公司或者组织的唯一标志。例如，一个银行组织 com.companyname.project-group 拥有所有的和银行相关的项目。-->
<!-- 配置时生成的路径也是由此生成， 如com.companyname.project-group，maven会将该项目打成的jar包放本地路径：/com/companyname/project-group -->
<groupId>com.companyname.project-group</groupId>
<!-- 工程的标识，项目的唯一ID，它通常是工程的名称。一个groupId下面可能多个项目，就是靠artifactId来区分的。 -->
<!-- 例如，消费者银行。groupId 和 artifactId 一起定义了 artifact 在仓库中的位置。-->
<artifactId>project</artifactId>
<!-- 工程的版本号。在 artifact 的仓库中，它用来区分不同的版本。 -->
<version>1.0.0</version>
<packaging>jar</packaging>
<!-- 2. 元信息 -->
<name>My Application</name>
<description>A demo project</description>
<url>https://example.com</url>
<!-- 3. 依赖管理 -->
<dependencies>...</dependencies>
<!-- 4. 构建配置 -->
<build>...</build>
<!-- 5. 环境配置 -->
<properties>...</properties>
<repositories>...</repositories>
</project>项目坐标（必须）：
| 元素 | 说明 | 示例 |
|---|---|---|
modelVersion |
POM 模型版本（固定 4.0.0） |
<modelVersion>4.0.0</modelVersion> |
groupId |
组织/公司标识（反向域名） | <groupId>com.example</groupId> |
artifactId |
项目名称 | <artifactId>my-app</artifactId> |
version |
项目版本 | <version>1.0.0</version> |
packaging |
打包类型（jar/war/pom） |
<packaging>jar</packaging> |
元信息（可选）：
| 元素 | 说明 |
|---|---|
name |
项目名称（显示用） |
description |
项目描述 |
url |
项目主页 |
licenses |
许可证信息 |
organization |
组织信息 |
xml
<name>My Awesome App</name>
<description>A demo project for learning Maven</description>
<url>https://github.com/example/my-app</url>3. 依赖管理
- 依赖机制
Maven 依赖机制是 Apache Maven 构建工具的核心功能之一，它能够自动下载和管理项目所需的外部库（JAR 文件）及其依赖关系。
Maven 依赖机制极大地简化了 Java 项目的构建过程，使开发者无需手动下载和管理各种第三方库。
Maven 通过中央仓库（Maven Central Repository）存储了数百万个开源库，当你在项目中声明某个依赖时，Maven 会自动从仓库中下载该库及其所有依赖项。
POM文件中可以定义项目的依赖：
xml
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>| 元素 | 说明 |
|---|---|
groupId |
依赖的组织标识 |
artifactId |
依赖的项目名称 |
version |
依赖的项目版本 |
scope |
依赖作用域（compile/test/provided/runtime） |
optional |
是否可选依赖（默认 false） |
- 依赖范围 (Scope)
Maven 定义了不同的依赖范围，决定了依赖在哪些阶段可用：
- compile（默认）：编译、测试和运行时都可用
- provided：编译和测试时可用，但运行时由 JDK 或容器提供
- runtime：只在测试和运行时需要
- test：仅在测试编译和执行阶段需要
- system：类似于 provided，但需要显式指定 JAR 路径
- 递性依赖 (Transitive Dependencies)
当项目 A 依赖项目 B，而项目 B 又依赖项目 C 时，Maven 会自动将项目 C 也作为项目 A 的依赖引入。这种自动处理依赖关系的特性称为传递性依赖。
传递规则取决于 Scope：
| 当前依赖Scope \ 传递依赖Scope | compile | provided | runtime | test |
|---|---|---|---|---|
| compile | compile | - | runtime | - |
| provided | provided | provided | provided | - |
| runtime | runtime | - | runtime | - |
| test | - | - | - | - |
- 高级特性
- 依赖版本管理
使用 dependencyManagement 统一管理版本：
org.springframework spring-core 5.3.18 org.springframework spring-core
- BOM 导入
管理一组相关依赖的版本：
org.springframework.boot spring-boot-dependencies 2.6.4 pom import
- 可选依赖（Optional）
标记依赖为可选，不传递：
com.example optional-lib 1.0 true
- 解析机制
-
依赖调解 (Dependency Mediation)。当出现版本冲突时，Maven 使用以下规则解决：
- 最近定义优先（在依赖树中路径最短的版本被选中）
- 如果路径长度相同，则先声明的依赖优先
-
依赖范围影响。不同范围的依赖会影响传递性：
- compile 范围的依赖会传递
- provided 和 test 范围的依赖不会传递
- runtime 范围的依赖会以 runtime 范围传递
不同 Scope 的依赖最终打包结果：
| Scope | 是否打包 | 典型应用 |
|---|---|---|
compile |
是 | 核心依赖 |
provided |
否 | 容器提供 |
runtime |
是 | 运行时需要 |
test |
否 | 单元测试 |
依赖相关命令
查看依赖树:
bash
mvn dependency:tree分析依赖问题:
bash
mvn dependency:analyze下载依赖到目录:
bash
mvn dependency:copy-dependencies4. 插件管理
POM 文件中也可以定义构建过程中的插件：
xml
<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>常用插件：
-
maven-compiler-plugin：指定 Java 版本 -
maven-surefire-plugin：控制测试执行 -
maven-jar-plugin：定制 JAR 包
5. 其他常用元素
properties: 定义项目中的一些属性变量。
xml
<properties>
<java.version>11</java.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>在依赖中引用：
xml
<version>${java.version}</version>repositories: 仓库配置。
指定远程仓库：
xml
<repositories>
<repository>
<id>aliyun</id>
<url>https://maven.aliyun.com/repository/public</url>
</repository>
</repositories>dependencyManagement: 用于管理依赖的版本，特别是在多模块项目中。
xml
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>5.3.9</version>
</dependency>
</dependencies>
</dependencyManagement>profiles: 用于定义不同的构建配置，可以根据不同的环境进行构建。
xml
<profiles>
<profile>
<id>development</id>
<properties>
<environment>dev</environment>
</properties>
</profile>
<profile>
<id>production</id>
<properties>
<environment>prod</environment>
</properties>
</profile>
</profiles>6. 继承和聚合
继承: 通过 parent 元素，一个POM文件可以继承另一个POM文件的配置：
xml
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.3.5</version>
</parent>聚合: 通过 modules 元素，一个 POM 文件可以管理多个子模块：
xml
<modules>
<module>infra-xxx-auth-api</module>
<module>infra-xxx-auth-service</module>
</modules>7. 父（Super）POM
父（Super）POM是 Maven 默认的 POM。所有的 POM 都继承自一个父 POM（无论是否显式定义了这个父 POM）。父 POM 包含了一些可以被继承的默认设置。因此，当 Maven 发现需要下载 POM 中的 依赖时，它会到 Super POM 中配置的默认仓库 http://repo1.maven.org/maven2 去下载。
Maven 使用 effective pom（Super pom 加上工程自己的配置）来执行相关的目标，它帮助开发者在 pom.xml 中做尽可能少的配置，当然这些配置可以被重写。
使用以下命令来查看 Super POM 默认配置：
bash
mvn help:effective-pom接下来我们创建目录 MVN/project，在该目录下创建 pom.xml，内容如下：
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>
<groupId>com.companyname.project-group</groupId>
<artifactId>project</artifactId>
<version>1.0</version>
</project>在命令控制台，进入 MVN/project 目录，执行以下命令：
bash
C:\MVN\project>mvn help:effective-pomMaven 将会开始处理并显示 effective-pom。
bash
[INFO] Scanning for projects...
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven-clean-plugin/2.5/maven-clean-plugin-2.5.pom
...
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 01:36 min
[INFO] Finished at: 2018-09-05T11:31:28+08:00
[INFO] Final Memory: 15M/149M
[INFO] ------------------------------------------------------------------------Effective POM 的结果就像在控制台中显示的一样，经过继承、插值之后，使配置生效。
xml
<?xml version="1.0" encoding="UTF-8"?>
<!-- ================================================================= -->
<!-- -->
<!-- Generated by Maven Help Plugin on 2012-07-05T11:41:51 -->
<!-- See: http://maven.apache.org/plugins/maven-help-plugin/ -->
<!-- -->
<!-- ================================================================= -->
<!-- ================================================================= -->
<!-- -->
<!-- Effective POM for project -->
<!-- 'com.companyname.project-group:project-name:jar:1.0' -->
<!-- -->
<!-- ================================================================= -->
<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 h
ttp://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.companyname.project-group</groupId>
<artifactId>project</artifactId>
<version>1.0</version>
<build>
<sourceDirectory>C:\MVN\project\src\main\java</sourceDirectory>
<outputDirectory>C:\MVN\project\target\classes</outputDirectory>
<scriptSourceDirectory>src/main/scripts</scriptSourceDirectory>
<testSourceDirectory>C:\MVN\project\src\test\java</testSourceDirectory>
<testOutputDirectory>C:\MVN\project\target\test-classes</testOutputDirectory>
<resources>
<resource>
<mergeId>resource-0</mergeId>
<directory>C:\MVN\project\src\main\resources</directory>
</resource>
</resources>
<testResources>
<testResource>
<mergeId>resource-1</mergeId>
<directory>C:\MVN\project\src\test\resources</directory>
</testResource>
</testResources>
<directory>C:\MVN\project\target</directory>
<finalName>project-1.0</finalName>
<pluginManagement>
<plugins>
<plugin>
<artifactId>maven-antrun-plugin</artifactId>
<version>1.3</version>
</plugin>
<plugin>
<artifactId>maven-assembly-plugin</artifactId>
<version>2.2-beta-2</version>
</plugin>
<plugin>
<artifactId>maven-clean-plugin</artifactId>
<version>2.2</version>
</plugin>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.0.2</version>
</plugin>
<plugin>
<artifactId>maven-dependency-plugin</artifactId>
<version>2.0</version>
</plugin>
<plugin>
<artifactId>maven-deploy-plugin</artifactId>
<version>2.4</version>
</plugin>
<plugin>
<artifactId>maven-ear-plugin</artifactId>
<version>2.3.1</version>
</plugin>
<plugin>
<artifactId>maven-ejb-plugin</artifactId>
<version>2.1</version>
</plugin>
<plugin>
<artifactId>maven-install-plugin</artifactId>
<version>2.2</version>
</plugin>
<plugin>
<artifactId>maven-jar-plugin</artifactId>
<version>2.2</version>
</plugin>
<plugin>
<artifactId>maven-javadoc-plugin</artifactId>
<version>2.5</version>
</plugin>
<plugin>
<artifactId>maven-plugin-plugin</artifactId>
<version>2.4.3</version>
</plugin>
<plugin>
<artifactId>maven-rar-plugin</artifactId>
<version>2.2</version>
</plugin>
<plugin>
<artifactId>maven-release-plugin</artifactId>
<version>2.0-beta-8</version>
</plugin>
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>2.3</version>
</plugin>
<plugin>
<artifactId>maven-site-plugin</artifactId>
<version>2.0-beta-7</version>
</plugin>
<plugin>
<artifactId>maven-source-plugin</artifactId>
<version>2.0.4</version>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.4.3</version>
</plugin>
<plugin>
<artifactId>maven-war-plugin</artifactId>
<version>2.1-alpha-2</version>
</plugin>
</plugins>
</pluginManagement>
<plugins>
<plugin>
<artifactId>maven-help-plugin</artifactId>
<version>2.1.1</version>
</plugin>
</plugins>
</build>
<repositories>
<repository>
<snapshots>
<enabled>false</enabled>
</snapshots>
<id>central</id>
<name>Maven Repository Switchboard</name>
<url>http://repo1.maven.org/maven2</url>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<releases>
<updatePolicy>never</updatePolicy>
</releases>
<snapshots>
<enabled>false</enabled>
</snapshots>
<id>central</id>
<name>Maven Plugin Repository</name>
<url>http://repo1.maven.org/maven2</url>
</pluginRepository>
</pluginRepositories>
<reporting>
<outputDirectory>C:\MVN\project\target/site</outputDirectory>
</reporting>
</project>在上面的 pom.xml 中，你可以看到 Maven 在执行目标时需要用到的默认工程源码目录结构、输出目录、需要的插件、仓库和报表目录。
Maven 提供了大量的原型插件来创建工程，包括工程结构和 pom.xml。
8. Maven 仓库
Maven 仓库是项目中依赖的第三方库，这个库所在的位置叫做仓库。
在 Maven 中，任何一个依赖、插件或者项目构建的输出，都可以称之为构件。
Maven 仓库能帮助我们管理构件（主要是 JAR），它就是放置所有 JAR 文件（WAR，ZIP，POM 等等）的地方。
Maven 仓库类型：
| 仓库类型 | 存储位置 | 作用 | 访问优先级 |
|---|---|---|---|
| 本地仓库 | 用户目录下的.m2/repository |
缓存远程下载的依赖 | 1 |
| 远程仓库 | 网络服务器 | 提供依赖和插件的集中存储 | 2 |
| - 中央仓库 | repo.maven.apache.org |
Maven官方维护的默认仓库 | 2.1 |
| - 私服仓库 | 公司内部搭建（如Nexus） | 托管私有依赖，加速构建 | 2.2 |
| - 其他公共仓库 | 如阿里云、JCenter等 | 镜像或补充中央仓库 | 2.3 |
9. POM 标签大全详解
以下是对 pom.xml 中所有重要标签的分类说明，涵盖 项目信息、依赖管理、构建配置、环境设置 等核心内容。
所有 POM 文件必须包含的标签： modelVersion、groupId、artifactId 和 version。
| 标签 | 类别 | 说明 | 示例/可选值 | 是否必需 |
|---|---|---|---|---|
| 基础信息 | ||||
<modelVersion> |
项目结构 | POM模型版本 | 4.0.0 |
是 |
<groupId> |
坐标 | 组织标识（反向域名） | com.example |
是 |
<artifactId> |
坐标 | 项目名称 | my-project |
是 |
<version> |
坐标 | 项目版本 | 1.0.0-SNAPSHOT |
是 |
<packaging> |
项目类型 | 打包格式 | jar/war/pom |
否（默认jar） |
<name> |
元信息 | 项目显示名称 | My Application |
否 |
<description> |
元信息 | 项目描述 | A demo project |
否 |
<url> |
元信息 | 项目主页URL | https://example.com |
否 |
| 依赖管理 | ||||
<dependencies> |
依赖 | 依赖列表容器 | 包含多个<dependency> |
否 |
<dependency> |
依赖 | 单个依赖定义 | 包含groupId等子标签 |
可选 |
<scope> |
依赖 | 依赖作用域 | compile/test/provided/runtime |
否（默认compile） |
<optional> |
依赖 | 是否可选依赖 | true/false |
否（默认false） |
<exclusions> |
依赖 | 排除传递性依赖 | 包含<exclusion>列表 |
否 |
| 构建配置 | ||||
<build> |
构建 | 构建配置容器 | 包含插件/资源等配置 | 否 |
<plugins> |
构建 | 插件列表容器 | 包含多个<plugin> |
否 |
<plugin> |
构建 | 单个插件定义 | 需指定groupId和artifactId |
可选 |
<resources> |
构建 | 资源文件配置 | 定义<resource>路径 |
否 |
<testResources> |
构建 | 测试资源文件配置 | 类似<resources> |
否 |
<finalName> |
构建 | 最终打包文件名 | my-app |
否 |
| 环境配置 | ||||
<properties> |
配置 | 自定义变量容器 | 定义键值对 | 否 |
<java.version> |
属性 | Java版本变量 | 11/17等 |
否 |
<repositories> |
仓库 | 自定义远程仓库列表 | 包含<repository> |
否 |
<pluginRepositories> |
仓库 | 自定义插件仓库 | 类似<repositories> |
否 |
| 多模块管理 | ||||
<modules> |
模块 | 子模块列表 | 包含多个<module> |
聚合项目需要 |
<parent> |
继承 | 父POM引用 | 需指定父项目坐标 | 继承项目需要 |
<dependencyManagement> |
依赖 | 统一管理依赖版本 | 定义版本但不引入 | 否 |
<profiles> |
配置 | 环境profile容器 | 定义不同环境配置 | 否 |
| 其他信息 | ||||
<licenses> |
法律 | 许可证信息 | 包含<license> |
否 |
<developers> |
人员 | 开发者列表 | 包含<developer> |
否 |
<contributors> |
人员 | 贡献者列表 | 类似<developers> |
否 |
<issueManagement> |
管理 | 问题跟踪系统 | 定义issue系统URL | 否 |
10. 完整示例
完整 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.0http://maven.apache.org/maven-v4_0_0.xsd">
<!--父项目的坐标。如果项目中没有规定某个元素的值，那么父项目中的对应值即为项目的默认值。 坐标包括group ID，artifact ID和
version。 -->
<parent>
<!--被继承的父项目的构件标识符 -->
<artifactId />
<!--被继承的父项目的全球唯一标识符 -->
<groupId />
<!--被继承的父项目的版本 -->
<version />
<!-- 父项目的pom.xml文件的相对路径。相对路径允许你选择一个不同的路径。默认值是../pom.xml。Maven首先在构建当前项目的地方寻找父项
目的pom，其次在文件系统的这个位置（relativePath位置），然后在本地仓库，最后在远程仓库寻找父项目的pom。 -->
<relativePath />
</parent>
<!--声明项目描述符遵循哪一个POM模型版本。模型本身的版本很少改变，虽然如此，但它仍然是必不可少的，这是为了当Maven引入了新的特性或者其他模型变更的时候，确保稳定性。 -->
<modelVersion>4.0.0</modelVersion>
<!--项目的全球唯一标识符，通常使用全限定的包名区分该项目和其他项目。并且构建时生成的路径也是由此生成， 如com.mycompany.app生成的相对路径为：/com/mycompany/app -->
<groupId>asia.banseon</groupId>
<!-- 构件的标识符，它和group ID一起唯一标识一个构件。换句话说，你不能有两个不同的项目拥有同样的artifact ID和groupID；在某个
特定的group ID下，artifact ID也必须是唯一的。构件是项目产生的或使用的一个东西，Maven为项目产生的构件包括：JARs，源 码，二进制发布和WARs等。 -->
<artifactId>banseon-maven2</artifactId>
<!--项目产生的构件类型，例如jar、war、ear、pom。插件可以创建他们自己的构件类型，所以前面列的不是全部构件类型 -->
<packaging>jar</packaging>
<!--项目当前版本，格式为:主版本.次版本.增量版本-限定版本号 -->
<version>1.0-SNAPSHOT</version>
<!--项目的名称, Maven产生的文档用 -->
<name>banseon-maven</name>
<!--项目主页的URL, Maven产生的文档用 -->
<url>http://www.baidu.com/banseon</url>
<!-- 项目的详细描述, Maven 产生的文档用。 当这个元素能够用HTML格式描述时（例如，CDATA中的文本会被解析器忽略，就可以包含HTML标
签）， 不鼓励使用纯文本描述。如果你需要修改产生的web站点的索引页面，你应该修改你自己的索引页文件，而不是调整这里的文档。 -->
<description>A maven project to study maven.</description>
<!--描述了这个项目构建环境中的前提条件。 -->
<prerequisites>
<!--构建该项目或使用该插件所需要的Maven的最低版本 -->
<maven />
</prerequisites>
<!--项目的问题管理系统(Bugzilla, Jira, Scarab,或任何你喜欢的问题管理系统)的名称和URL，本例为 jira -->
<issueManagement>
<!--问题管理系统（例如jira）的名字， -->
<system>jira</system>
<!--该项目使用的问题管理系统的URL -->
<url>http://jira.baidu.com/banseon</url>
</issueManagement>
<!--项目持续集成信息 -->
<ciManagement>
<!--持续集成系统的名字，例如continuum -->
<system />
<!--该项目使用的持续集成系统的URL（如果持续集成系统有web接口的话）。 -->
<url />
<!--构建完成时，需要通知的开发者/用户的配置项。包括被通知者信息和通知条件（错误，失败，成功，警告） -->
<notifiers>
<!--配置一种方式，当构建中断时，以该方式通知用户/开发者 -->
<notifier>
<!--传送通知的途径 -->
<type />
<!--发生错误时是否通知 -->
<sendOnError />
<!--构建失败时是否通知 -->
<sendOnFailure />
<!--构建成功时是否通知 -->
<sendOnSuccess />
<!--发生警告时是否通知 -->
<sendOnWarning />
<!--不赞成使用。通知发送到哪里 -->
<address />
<!--扩展配置项 -->
<configuration />
</notifier>
</notifiers>
</ciManagement>
<!--项目创建年份，4位数字。当产生版权信息时需要使用这个值。 -->
<inceptionYear />
<!--项目相关邮件列表信息 -->
<mailingLists>
<!--该元素描述了项目相关的所有邮件列表。自动产生的网站引用这些信息。 -->
<mailingList>
<!--邮件的名称 -->
<name>Demo</name>
<!--发送邮件的地址或链接，如果是邮件地址，创建文档时，mailto: 链接会被自动创建 -->
<post>banseon@126.com</post>
<!--订阅邮件的地址或链接，如果是邮件地址，创建文档时，mailto: 链接会被自动创建 -->
<subscribe>banseon@126.com</subscribe>
<!--取消订阅邮件的地址或链接，如果是邮件地址，创建文档时，mailto: 链接会被自动创建 -->
<unsubscribe>banseon@126.com</unsubscribe>
<!--你可以浏览邮件信息的URL -->
<archive>http:/hi.baidu.com/banseon/demo/dev/</archive>
</mailingList>
</mailingLists>
<!--项目开发者列表 -->
<developers>
<!--某个项目开发者的信息 -->
<developer>
<!--SCM里项目开发者的唯一标识符 -->
<id>HELLO WORLD</id>
<!--项目开发者的全名 -->
<name>banseon</name>
<!--项目开发者的email -->
<email>banseon@126.com</email>
<!--项目开发者的主页的URL -->
<url />
<!--项目开发者在项目中扮演的角色，角色元素描述了各种角色 -->
<roles>
<role>Project Manager</role>
<role>Architect</role>
</roles>
<!--项目开发者所属组织 -->
<organization>demo</organization>
<!--项目开发者所属组织的URL -->
<organizationUrl>http://hi.baidu.com/banseon</organizationUrl>
<!--项目开发者属性，如即时消息如何处理等 -->
<properties>
<dept>No</dept>
</properties>
<!--项目开发者所在时区， -11到12范围内的整数。 -->
<timezone>-5</timezone>
</developer>
</developers>
<!--项目的其他贡献者列表 -->
<contributors>
<!--项目的其他贡献者。参见developers/developer元素 -->
<contributor>
<name />
<email />
<url />
<organization />
<organizationUrl />
<roles />
<timezone />
<properties />
</contributor>
</contributors>
<!--该元素描述了项目所有License列表。 应该只列出该项目的license列表，不要列出依赖项目的 license列表。如果列出多个license，用户可以选择它们中的一个而不是接受所有license。 -->
<licenses>
<!--描述了项目的license，用于生成项目的web站点的license页面，其他一些报表和validation也会用到该元素。 -->
<license>
<!--license用于法律上的名称 -->
<name>Apache 2</name>
<!--官方的license正文页面的URL -->
<url>http://www.baidu.com/banseon/LICENSE-2.0.txt</url>
<!--项目分发的主要方式： repo，可以从Maven库下载 manual， 用户必须手动下载和安装依赖 -->
<distribution>repo</distribution>
<!--关于license的补充信息 -->
<comments>A business-friendly OSS license</comments>
</license>
</licenses>
<!--SCM(Source Control Management)标签允许你配置你的代码库，供Maven web站点和其它插件使用。 -->
<scm>
<!--SCM的URL,该URL描述了版本库和如何连接到版本库。欲知详情，请看SCMs提供的URL格式和列表。该连接只读。 -->
<connection>
scm:svn:http://svn.baidu.com/banseon/maven/banseon/banseon-maven2-trunk(dao-trunk)
</connection>
<!--给开发者使用的，类似connection元素。即该连接不仅仅只读 -->
<developerConnection>
scm:svn:http://svn.baidu.com/banseon/maven/banseon/dao-trunk
</developerConnection>
<!--当前代码的标签，在开发阶段默认为HEAD -->
<tag />
<!--指向项目的可浏览SCM库（例如ViewVC或者Fisheye）的URL。 -->
<url>http://svn.baidu.com/banseon</url>
</scm>
<!--描述项目所属组织的各种属性。Maven产生的文档用 -->
<organization>
<!--组织的全名 -->
<name>demo</name>
<!--组织主页的URL -->
<url>http://www.baidu.com/banseon</url>
</organization>
<!--构建项目需要的信息 -->
<build>
<!--该元素设置了项目源码目录，当构建项目的时候，构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。 -->
<sourceDirectory />
<!--该元素设置了项目脚本源码目录，该目录和源码目录不同：绝大多数情况下，该目录下的内容 会被拷贝到输出目录(因为脚本是被解释的，而不是被编译的)。 -->
<scriptSourceDirectory />
<!--该元素设置了项目单元测试使用的源码目录，当测试项目的时候，构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。 -->
<testSourceDirectory />
<!--被编译过的应用程序class文件存放的目录。 -->
<outputDirectory />
<!--被编译过的测试class文件存放的目录。 -->
<testOutputDirectory />
<!--使用来自该项目的一系列构建扩展 -->
<extensions>
<!--描述使用到的构建扩展。 -->
<extension>
<!--构建扩展的groupId -->
<groupId />
<!--构建扩展的artifactId -->
<artifactId />
<!--构建扩展的版本 -->
<version />
</extension>
</extensions>
<!--当项目没有规定目标（Maven2 叫做阶段）时的默认值 -->
<defaultGoal />
<!--这个元素描述了项目相关的所有资源路径列表，例如和项目相关的属性文件，这些资源被包含在最终的打包文件里。 -->
<resources>
<!--这个元素描述了项目相关或测试相关的所有资源路径 -->
<resource>
<!-- 描述了资源的目标路径。该路径相对target/classes目录（例如${project.build.outputDirectory}）。举个例
子，如果你想资源在特定的包里(org.apache.maven.messages)，你就必须该元素设置为org/apache/maven /messages。然而，如果你只是想把资源放到源码目录结构里，就不需要该配置。 -->
<targetPath />
<!--是否使用参数值代替参数名。参数值取自properties元素或者文件里配置的属性，文件在filters元素里列出。 -->
<filtering />
<!--描述存放资源的目录，该路径相对POM路径 -->
<directory />
<!--包含的模式列表，例如**/*.xml. -->
<includes />
<!--排除的模式列表，例如**/*.xml -->
<excludes />
</resource>
</resources>
<!--这个元素描述了单元测试相关的所有资源路径，例如和单元测试相关的属性文件。 -->
<testResources>
<!--这个元素描述了测试相关的所有资源路径，参见build/resources/resource元素的说明 -->
<testResource>
<targetPath />
<filtering />
<directory />
<includes />
<excludes />
</testResource>
</testResources>
<!--构建产生的所有文件存放的目录 -->
<directory />
<!--产生的构件的文件名，默认值是${artifactId}-${version}。 -->
<finalName />
<!--当filtering开关打开时，使用到的过滤器属性文件列表 -->
<filters />
<!--子项目可以引用的默认插件信息。该插件配置项直到被引用时才会被解析或绑定到生命周期。给定插件的任何本地配置都会覆盖这里的配置 -->
<pluginManagement>
<!--使用的插件列表 。 -->
<plugins>
<!--plugin元素包含描述插件所需要的信息。 -->
<plugin>
<!--插件在仓库里的group ID -->
<groupId />
<!--插件在仓库里的artifact ID -->
<artifactId />
<!--被使用的插件的版本（或版本范围） -->
<version />
<!--是否从该插件下载Maven扩展（例如打包和类型处理器），由于性能原因，只有在真需要下载时，该元素才被设置成enabled。 -->
<extensions />
<!--在构建生命周期中执行一组目标的配置。每个目标可能有不同的配置。 -->
<executions>
<!--execution元素包含了插件执行需要的信息 -->
<execution>
<!--执行目标的标识符，用于标识构建过程中的目标，或者匹配继承过程中需要合并的执行目标 -->
<id />
<!--绑定了目标的构建生命周期阶段，如果省略，目标会被绑定到源数据里配置的默认阶段 -->
<phase />
<!--配置的执行目标 -->
<goals />
<!--配置是否被传播到子POM -->
<inherited />
<!--作为DOM对象的配置 -->
<configuration />
</execution>
</executions>
<!--项目引入插件所需要的额外依赖 -->
<dependencies>
<!--参见dependencies/dependency元素 -->
<dependency>
......
</dependency>
</dependencies>
<!--任何配置是否被传播到子项目 -->
<inherited />
<!--作为DOM对象的配置 -->
<configuration />
</plugin>
</plugins>
</pluginManagement>
<!--使用的插件列表 -->
<plugins>
<!--参见build/pluginManagement/plugins/plugin元素 -->
<plugin>
<groupId />
<artifactId />
<version />
<extensions />
<executions>
<execution>
<id />
<phase />
<goals />
<inherited />
<configuration />
</execution>
</executions>
<dependencies>
<!--参见dependencies/dependency元素 -->
<dependency>
......
</dependency>
</dependencies>
<goals />
<inherited />
<configuration />
</plugin>
</plugins>
</build>
<!--在列的项目构建profile，如果被激活，会修改构建处理 -->
<profiles>
<!--根据环境参数或命令行参数激活某个构建处理 -->
<profile>
<!--构建配置的唯一标识符。即用于命令行激活，也用于在继承时合并具有相同标识符的profile。 -->
<id />
<!--自动触发profile的条件逻辑。Activation是profile的开启钥匙。profile的力量来自于它 能够在某些特定的环境中自动使用某些特定的值；这些环境通过activation元素指定。activation元素并不是激活profile的唯一方式。 -->
<activation>
<!--profile默认是否激活的标志 -->
<activeByDefault />
<!--当匹配的jdk被检测到，profile被激活。例如，1.4激活JDK1.4，1.4.0_2，而!1.4激活所有版本不是以1.4开头的JDK。 -->
<jdk />
<!--当匹配的操作系统属性被检测到，profile被激活。os元素可以定义一些操作系统相关的属性。 -->
<os>
<!--激活profile的操作系统的名字 -->
<name>Windows XP</name>
<!--激活profile的操作系统所属家族(如 'windows') -->
<family>Windows</family>
<!--激活profile的操作系统体系结构 -->
<arch>x86</arch>
<!--激活profile的操作系统版本 -->
<version>5.1.2600</version>
</os>
<!--如果Maven检测到某一个属性（其值可以在POM中通过${名称}引用），其拥有对应的名称和值，Profile就会被激活。如果值 字段是空的，那么存在属性名称字段就会激活profile，否则按区分大小写方式匹配属性值字段 -->
<property>
<!--激活profile的属性的名称 -->
<name>mavenVersion</name>
<!--激活profile的属性的值 -->
<value>2.0.3</value>
</property>
<!--提供一个文件名，通过检测该文件的存在或不存在来激活profile。missing检查文件是否存在，如果不存在则激活 profile。另一方面，exists则会检查文件是否存在，如果存在则激活profile。 -->
<file>
<!--如果指定的文件存在，则激活profile。 -->
<exists>/usr/local/hudson/hudson-home/jobs/maven-guide-zh-to-production/workspace/
</exists>
<!--如果指定的文件不存在，则激活profile。 -->
<missing>/usr/local/hudson/hudson-home/jobs/maven-guide-zh-to-production/workspace/
</missing>
</file>
</activation>
<!--构建项目所需要的信息。参见build元素 -->
<build>
<defaultGoal />
<resources>
<resource>
<targetPath />
<filtering />
<directory />
<includes />
<excludes />
</resource>
</resources>
<testResources>
<testResource>
<targetPath />
<filtering />
<directory />
<includes />
<excludes />
</testResource>
</testResources>
<directory />
<finalName />
<filters />
<pluginManagement>
<plugins>
<!--参见build/pluginManagement/plugins/plugin元素 -->
<plugin>
<groupId />
<artifactId />
<version />
<extensions />
<executions>
<execution>
<id />
<phase />
<goals />
<inherited />
<configuration />
</execution>
</executions>
<dependencies>
<!--参见dependencies/dependency元素 -->
<dependency>
......
</dependency>
</dependencies>
<goals />
<inherited />
<configuration />
</plugin>
</plugins>
</pluginManagement>
<plugins>
<!--参见build/pluginManagement/plugins/plugin元素 -->
<plugin>
<groupId />
<artifactId />
<version />
<extensions />
<executions>
<execution>
<id />
<phase />
<goals />
<inherited />
<configuration />
</execution>
</executions>
<dependencies>
<!--参见dependencies/dependency元素 -->
<dependency>
......
</dependency>
</dependencies>
<goals />
<inherited />
<configuration />
</plugin>
</plugins>
</build>
<!--模块（有时称作子项目） 被构建成项目的一部分。列出的每个模块元素是指向该模块的目录的相对路径 -->
<modules />
<!--发现依赖和扩展的远程仓库列表。 -->
<repositories>
<!--参见repositories/repository元素 -->
<repository>
<releases>
<enabled />
<updatePolicy />
<checksumPolicy />
</releases>
<snapshots>
<enabled />
<updatePolicy />
<checksumPolicy />
</snapshots>
<id />
<name />
<url />
<layout />
</repository>
</repositories>
<!--发现插件的远程仓库列表，这些插件用于构建和报表 -->
<pluginRepositories>
<!--包含需要连接到远程插件仓库的信息.参见repositories/repository元素 -->
<pluginRepository>
<releases>
<enabled />
<updatePolicy />
<checksumPolicy />
</releases>
<snapshots>
<enabled />
<updatePolicy />
<checksumPolicy />
</snapshots>
<id />
<name />
<url />
<layout />
</pluginRepository>
</pluginRepositories>
<!--该元素描述了项目相关的所有依赖。 这些依赖组成了项目构建过程中的一个个环节。它们自动从项目定义的仓库中下载。要获取更多信息，请看项目依赖机制。 -->
<dependencies>
<!--参见dependencies/dependency元素 -->
<dependency>
......
</dependency>
</dependencies>
<!--不赞成使用. 现在Maven忽略该元素. -->
<reports />
<!--该元素包括使用报表插件产生报表的规范。当用户执行"mvn site"，这些报表就会运行。 在页面导航栏能看到所有报表的链接。参见reporting元素 -->
<reporting>
......
</reporting>
<!--参见dependencyManagement元素 -->
<dependencyManagement>
<dependencies>
<!--参见dependencies/dependency元素 -->
<dependency>
......
</dependency>
</dependencies>
</dependencyManagement>
<!--参见distributionManagement元素 -->
<distributionManagement>
......
</distributionManagement>
<!--参见properties元素 -->
<properties />
</profile>
</profiles>
<!--模块（有时称作子项目） 被构建成项目的一部分。列出的每个模块元素是指向该模块的目录的相对路径 -->
<modules />
<!--发现依赖和扩展的远程仓库列表。 -->
<repositories>
<!--包含需要连接到远程仓库的信息 -->
<repository>
<!--如何处理远程仓库里发布版本的下载 -->
<releases>
<!--true或者false表示该仓库是否为下载某种类型构件（发布版，快照版）开启。 -->
<enabled />
<!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。这里的选项是：always（一直），daily（默认，每日），interval：X（这里X是以分钟为单位的时间间隔），或者never（从不）。 -->
<updatePolicy />
<!--当Maven验证构件校验文件失败时该怎么做：ignore（忽略），fail（失败），或者warn（警告）。 -->
<checksumPolicy />
</releases>
<!-- 如何处理远程仓库里快照版本的下载。有了releases和snapshots这两组配置，POM就可以在每个单独的仓库中，为每种类型的构件采取不同的
策略。例如，可能有人会决定只为开发目的开启对快照版本下载的支持。参见repositories/repository/releases元素 -->
<snapshots>
<enabled />
<updatePolicy />
<checksumPolicy />
</snapshots>
<!--远程仓库唯一标识符。可以用来匹配在settings.xml文件里配置的远程仓库 -->
<id>banseon-repository-proxy</id>
<!--远程仓库名称 -->
<name>banseon-repository-proxy</name>
<!--远程仓库URL，按protocol://hostname/path形式 -->
<url>http://192.168.1.169:9999/repository/</url>
<!-- 用于定位和排序构件的仓库布局类型-可以是default（默认）或者legacy（遗留）。Maven 2为其仓库提供了一个默认的布局；然
而，Maven 1.x有一种不同的布局。我们可以使用该元素指定布局是default（默认）还是legacy（遗留）。 -->
<layout>default</layout>
</repository>
</repositories>
<!--发现插件的远程仓库列表，这些插件用于构建和报表 -->
<pluginRepositories>
<!--包含需要连接到远程插件仓库的信息.参见repositories/repository元素 -->
<pluginRepository>
......
</pluginRepository>
</pluginRepositories>
<!--该元素描述了项目相关的所有依赖。 这些依赖组成了项目构建过程中的一个个环节。它们自动从项目定义的仓库中下载。要获取更多信息，请看项目依赖机制。 -->
<dependencies>
<dependency>
<!--依赖的group ID -->
<groupId>org.apache.maven</groupId>
<!--依赖的artifact ID -->
<artifactId>maven-artifact</artifactId>
<!--依赖的版本号。 在Maven 2里, 也可以配置成版本号的范围。 -->
<version>3.8.1</version>
<!-- 依赖类型，默认类型是jar。它通常表示依赖的文件的扩展名，但也有例外。一个类型可以被映射成另外一个扩展名或分类器。类型经常和使用的打包方式对应，
尽管这也有例外。一些类型的例子：jar，war，ejb-client和test-jar。如果设置extensions为 true，就可以在 plugin里定义新的类型。所以前面的类型的例子不完整。 -->
<type>jar</type>
<!-- 依赖的分类器。分类器可以区分属于同一个POM，但不同构建方式的构件。分类器名被附加到文件名的版本号后面。例如，如果你想要构建两个单独的构件成
JAR，一个使用Java 1.4编译器，另一个使用Java 6编译器，你就可以使用分类器来生成两个单独的JAR构件。 -->
<classifier></classifier>
<!--依赖范围。在项目发布过程中，帮助决定哪些构件被包括进来。欲知详情请参考依赖机制。 - compile ：默认范围，用于编译 - provided：类似于编译，但支持你期待jdk或者容器提供，类似于classpath
- runtime: 在执行时需要使用 - test: 用于test任务时使用 - system: 需要外在提供相应的元素。通过systemPath来取得
- systemPath: 仅用于范围为system。提供相应的路径 - optional: 当项目自身被依赖时，标注依赖是否传递。用于连续依赖时使用 -->
<scope>test</scope>
<!--仅供system范围使用。注意，不鼓励使用这个元素，并且在新的版本中该元素可能被覆盖掉。该元素为依赖规定了文件系统上的路径。需要绝对路径而不是相对路径。推荐使用属性匹配绝对路径，例如${java.home}。 -->
<systemPath></systemPath>
<!--当计算传递依赖时， 从依赖构件列表里，列出被排除的依赖构件集。即告诉maven你只依赖指定的项目，不依赖项目的依赖。此元素主要用于解决版本冲突问题 -->
<exclusions>
<exclusion>
<artifactId>spring-core</artifactId>
<groupId>org.springframework</groupId>
</exclusion>
</exclusions>
<!--可选依赖，如果你在项目B中把C依赖声明为可选，你就需要在依赖于B的项目（例如项目A）中显式的引用对C的依赖。可选依赖阻断依赖的传递性。 -->
<optional>true</optional>
</dependency>
</dependencies>
<!--不赞成使用. 现在Maven忽略该元素. -->
<reports></reports>
<!--该元素描述使用报表插件产生报表的规范。当用户执行"mvn site"，这些报表就会运行。 在页面导航栏能看到所有报表的链接。 -->
<reporting>
<!--true，则，网站不包括默认的报表。这包括"项目信息"菜单中的报表。 -->
<excludeDefaults />
<!--所有产生的报表存放到哪里。默认值是${project.build.directory}/site。 -->
<outputDirectory />
<!--使用的报表插件和他们的配置。 -->
<plugins>
<!--plugin元素包含描述报表插件需要的信息 -->
<plugin>
<!--报表插件在仓库里的group ID -->
<groupId />
<!--报表插件在仓库里的artifact ID -->
<artifactId />
<!--被使用的报表插件的版本（或版本范围） -->
<version />
<!--任何配置是否被传播到子项目 -->
<inherited />
<!--报表插件的配置 -->
<configuration />
<!--一组报表的多重规范，每个规范可能有不同的配置。一个规范（报表集）对应一个执行目标 。例如，有1，2，3，4，5，6，7，8，9个报表。1，2，5构成A报表集，对应一个执行目标。2，5，8构成B报表集，对应另一个执行目标 -->
<reportSets>
<!--表示报表的一个集合，以及产生该集合的配置 -->
<reportSet>
<!--报表集合的唯一标识符，POM继承时用到 -->
<id />
<!--产生报表集合时，被使用的报表的配置 -->
<configuration />
<!--配置是否被继承到子POMs -->
<inherited />
<!--这个集合里使用到哪些报表 -->
<reports />
</reportSet>
</reportSets>
</plugin>
</plugins>
</reporting>
<!-- 继承自该项目的所有子项目的默认依赖信息。这部分的依赖信息不会被立即解析,而是当子项目声明一个依赖（必须描述group ID和 artifact
ID信息），如果group ID和artifact ID以外的一些信息没有描述，则通过group ID和artifact ID 匹配到这里的依赖，并使用这里的依赖信息。 -->
<dependencyManagement>
<dependencies>
<!--参见dependencies/dependency元素 -->
<dependency>
......
</dependency>
</dependencies>
</dependencyManagement>
<!--项目分发信息，在执行mvn deploy后表示要发布的位置。有了这些信息就可以把网站部署到远程服务器或者把构件部署到远程仓库。 -->
<distributionManagement>
<!--部署项目产生的构件到远程仓库需要的信息 -->
<repository>
<!--是分配给快照一个唯一的版本号（由时间戳和构建流水号）？还是每次都使用相同的版本号？参见repositories/repository元素 -->
<uniqueVersion />
<id>banseon-maven2</id>
<name>banseon maven2</name>
<url>file://${basedir}/target/deploy</url>
<layout />
</repository>
<!--构件的快照部署到哪里？如果没有配置该元素，默认部署到repository元素配置的仓库，参见distributionManagement/repository元素 -->
<snapshotRepository>
<uniqueVersion />
<id>banseon-maven2</id>
<name>Banseon-maven2 Snapshot Repository</name>
<url>scp://svn.baidu.com/banseon:/usr/local/maven-snapshot</url>
<layout />
</snapshotRepository>
<!--部署项目的网站需要的信息 -->
<site>
<!--部署位置的唯一标识符，用来匹配站点和settings.xml文件里的配置 -->
<id>banseon-site</id>
<!--部署位置的名称 -->
<name>business api website</name>
<!--部署位置的URL，按protocol://hostname/path形式 -->
<url>
scp://svn.baidu.com/banseon:/var/www/localhost/banseon-web
</url>
</site>
<!--项目下载页面的URL。如果没有该元素，用户应该参考主页。使用该元素的原因是：帮助定位那些不在仓库里的构件（由于license限制）。 -->
<downloadUrl />
<!--如果构件有了新的group ID和artifact ID（构件移到了新的位置），这里列出构件的重定位信息。 -->
<relocation>
<!--构件新的group ID -->
<groupId />
<!--构件新的artifact ID -->
<artifactId />
<!--构件新的版本号 -->
<version />
<!--显示给用户的，关于移动的额外信息，例如原因。 -->
<message />
</relocation>
<!-- 给出该构件在远程仓库的状态。不得在本地项目中设置该元素，因为这是工具自动更新的。有效的值有：none（默认），converted（仓库管理员从
Maven 1 POM转换过来），partner（直接从伙伴Maven 2仓库同步过来），deployed（从Maven 2实例部 署），verified（被核实时正确的和最终的）。 -->
<status />
</distributionManagement>
<!--以值替代名称，Properties可以在整个POM中使用，也可以作为触发条件（见settings.xml配置文件里activation元素的说明）。格式是<name>value</name>。 -->
<properties />
</project>五、Maven 构建生命周期
Maven 构建生命周期定义了一个项目构建跟发布的过程，包含三个标准生命周期：
- clean：清理项目
- default（或 build）：核心构建流程
- site：生成项目文档
每个生命周期由多个阶段（phase）组成，执行时按顺序运行。
1. clean 生命周期
clean 生命周期负责清理项目的临时文件和目录（主要是target/），包含以下主要阶段：
| 阶段 | 说明 | 自动绑定的插件目标 |
|---|---|---|
pre-clean |
清理前的准备工作 | 无默认绑定 |
clean |
删除target/目录 |
maven-clean-plugin:clean |
post-clean |
清理后的收尾工作 | 无默认绑定 |
常用命令:
bash
mvn clean # 执行clean阶段（包含pre-clean和clean）2. default 生命周期
default 生命周期是 Maven 最主要的生命周期，包含项目构建和部署的所有核心步骤。
一个典型的 Maven 构建（build）生命周期是由以下几个阶段的序列组成的：
| 阶段 | 处理 | 描述 |
|---|---|---|
| 验证 validate | 验证项目 | 验证项目是否正确且所有必须信息是可用的 |
| 编译 compile | 执行编译 | 源代码编译在此阶段完成 |
| 测试 Test | 测试 | 使用适当的单元测试框架（例如JUnit）运行测试。 |
| 包装 package | 打包 | 将编译后的代码打包成可分发的格式，例如 JAR 或 WAR |
| 检查 verify | 检查 | 对集成测试的结果进行检查，以保证质量达标 |
| 安装 install | 安装 | 安装打包的项目到本地仓库，以供其他项目使用 |
| 部署 deploy | 部署 | 拷贝最终的工程包到远程仓库中，以共享给其他开发人员和工程 |
为了完成 default 生命周期，这些阶段（包括其他未在上面罗列的生命周期阶段）将被按顺序地执行。
阶段依赖关系:
常用命令:
bash
mvn compile # 编译主代码
mvn test # 运行测试
mvn package # 打包（生成target/*.jar）
mvn install # 安装到本地仓库（~/.m2/repository）
mvn deploy # 部署到远程仓库（需配置distributionManagement）3. site 生命周期
site 生命周期用于生成项目站点文档：
| 阶段 | 说明 | 自动绑定的插件目标 |
|---|---|---|
pre-site |
生成站点前的准备 | 无默认绑定 |
site |
生成项目站点文档 | maven-site-plugin:site |
post-site |
站点生成后的收尾 | 无默认绑定 |
site-deploy |
部署站点到服务器 | maven-site-plugin:deploy |
常用命令:
bash
mvn site # 生成站点（输出在target/site/）
mvn site-deploy # 部署站点（需配置site URL）4. 生命周期小结
Maven 有以下三个标准的生命周期：
1、Clean 生命周期：
- clean：删除目标目录中的编译输出文件。这通常是在构建之前执行的，以确保项目从一个干净的状态开始。
2、Default 生命周期（也称为 Build 生命周期）：
- validate：验证项目的正确性，例如检查项目的版本是否正确。
- compile：编译项目的源代码。
- test：运行项目的单元测试。
- package：将编译后的代码打包成可分发的格式，例如 JAR 或 WAR。
- verify：对项目进行额外的检查以确保质量。
- install：将项目的构建结果安装到本地 Maven 仓库中，以供其他项目使用。
- deploy：将项目的构建结果复制到远程仓库，以供其他开发人员或团队使用。
3、Site 生命周期：
- site：生成项目文档和站点信息。
- deploy-site：将生成的站点信息发布到远程服务器，以便共享项目文档。
六、Maven 构建配置文件
构建配置文件是一系列的配置项的值，可以用来设置或者覆盖 Maven 构建默认值。
使用构建配置文件，你可以为不同的环境，比如说生产环境（Production）和开发（Development）环境，定制构建方式。
配置文件在 pom.xml 文件中使用 activeProfiles 或者 profiles 元素指定，并且可以通过各种方式触发。配置文件在构建时修改 POM，并且用来给参数设定不同的目标环境（比如说，开发（Development）、测试（Testing）和生产环境（Production）中数据库服务器的地址）。
1. 构建配置文件的类型
构建配置文件大体上有三种类型:
| 类型 | 在哪定义 |
|---|---|
| 项目级（Per Project） | 定义在项目的POM文件pom.xml中 |
| 用户级 （Per User） | 定义在Maven的设置xml文件中 (%USER_HOME%/.m2/settings.xml) |
| 全局（Global） | 定义在 Maven 全局的设置 xml 文件中 (%M2_HOME%/conf/settings.xml) |
2. 配置文件激活
Maven的构建配置文件可以通过多种方式激活。
- 使用命令控制台输入显式激活。
- 通过 maven 设置。
- 基于环境变量（用户或者系统变量）。
- 操作系统设置（比如说，Windows系列）。
- 文件的存在或者缺失。
配置文件激活实例
假定项目结构如下：
其中在src/main/resources文件夹下有三个用于测试文件：
| 文件名 | 描述 |
|---|---|
| env.properties | 如果未指定配置文件时默认使用的配置。 |
| env.test.properties | 当测试配置文件使用时的测试配置。 |
| env.prod.properties | 当生产配置文件使用时的生产配置。 |
注意：这三个配置文件并不是代表构建配置文件的功能，而是用于本次测试的目的；比如，我指定了构建配置文件为 prod 时，项目就使用 env.prod.properties文件。
注意：下面的例子仍然是使用 AntRun 插件，因为此插件能绑定 Maven 生命周期阶段，并通过 Ant 的标签不用编写一点代码即可输出信息、复制文件等，经此而已。其余的与本次构建配置文件无关。
- 配置文件激活
profile 可以让我们定义一系列的配置信息，然后指定其激活条件。这样我们就可以定义多个 profile，然后每个 profile 对应不同的激活条件和配置信息，从而达到不同环境使用不同配置信息的效果。
注意 ：构建配置文件 采用的是 节点。
其中 区分了不同的 执行不同的 AntRun 任务；而 AntRun 的任务可以这么理解，AntRun 监听 test 的 Maven 生命周期阶段，当 Maven 执行 test 时，就触发了 AntRun 的任务，任务里面为输出文本并复制文件到指定的位置；而至于要执行哪个 AntRun 任务，此时构建配置文件 起到了传输指定的作用，比如，通过命令行参数输入指定的 。
执行命令：
bash
mvn test -Ptest- 通过Maven设置激活配置文件
打开 %USER_HOME%/.m2 目录下的 settings.xml 文件，其中 %USER_HOME% 代表用户主目录。如果 setting.xml 文件不存在就直接拷贝 %M2_HOME%/conf/settings.xml 到 .m2 目录，其中 %M2_HOME% 代表 Maven 的安装目录。
配置 setting.xml 文件，增加 <activeProfiles>属性：
xml
<settings 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/settings-1.0.0.xsd">
...
<activeProfiles>
<activeProfile>test</activeProfile>
</activeProfiles>
</settings>执行命令：
bash
mvn test提示 1：此时不需要使用 -Ptest 来输入参数了，上面的 setting.xml 文件的 已经指定了 test 参数代替了。
提示 2 ：同样可以使用在 %M2_HOME%/conf/settings.xml 的文件进行配置，效果一致。
- 通过环境变量激活配置文件
先把上一步测试的 setting.xml 值全部去掉。
然后在 pom.xml 里面的 为 test 的 节点，加入 节点：
xml
<profiles>
<profile>
<id>test</id>
<activation>
<property>
<name>env</name>
<value>test</value>
</property>
</activation>
<build>
</build>
</profile>
<profile>
<id>prod</id>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-antrun-plugin</artifactId>
<version>1.8</version>
<executions>
<execution>
<phase>test</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<tasks>
<echo>Using env.prod.properties</echo>
<copy file="src/main/resources/env.prod.properties" tofile="${project.build.outputDirectory}/env.properties" overwrite="true"/>
</tasks>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
</profiles>
</project>执行命令：
bash
mvn test -Denv=test提示 1 ：上面使用 -D 传递环境变量，其中 env 对应刚才设置的 值，test 对应。
提示 2：在 Windows 10 上测试了系统的环境变量，但是不生效，所以，只能通过 -D 传递。
- 通过操作系统激活配置文件
activation 元素包含下面的操作系统信息。当系统为 windows XP 时，test Profile 将会被触发。
xml
<profile>
<id>test</id>
<activation>
<os>
<name>Windows XP</name>
<family>Windows</family>
<arch>x86</arch>
<version>5.1.2600</version>
</os>
</activation>
</profile>执行命令：
bash
mvn test- 通过文件的存在或者缺失激活配置文件
现在使用 activation 元素包含下面的操作系统信息。当 target/generated-sources/axistools/wsdl2java/com/companyname/group 缺失时，test Profile 将会被触发。
xml
<profile>
<id>test</id>
<activation>
<file>
<missing>target/generated-sources/axistools/wsdl2java/
com/companyname/group</missing>
</file>
</activation>
</profile>执行命令：
bash
mvn test七、构建部署
1. Maven 快照(SNAPSHOT)
一个大型的软件应用通常包含多个模块，并且通常的场景是多个团队开发同一应用的不同模块。举个例子，设想一个团队开发应用的前端，项目为 app-ui(app-ui.jar:1.0)，而另一个团队开发应用的后台，使用的项目是 data-service(data-service.jar:1.0)。
现在可能出现的情况是开发 data-service 的团队正在进行快节奏的 bug 修复或者项目改进，并且他们几乎每隔一天就要发布库到远程仓库。 现在如果 data-service 团队每隔一天上传一个新版本，那么将会出现下面的问题：
- data-service 团队每次发布更新的代码时都要告知 app-ui 团队。
- app-ui 团队需要经常地更新他们 pom.xml 文件到最新版本。
- 什么是快照?
快照是一种特殊的版本，指定了某个当前的开发进度的副本。不同于常规的版本，Maven 每次构建都会在远程仓库中检查新的快照。 现在 data-service 团队会每次发布更新代码的快照到仓库中，比如说 data-service:1.0-SNAPSHOT 来替代旧的快照 jar 包。
- 快照(SNAPSHOT) vs 发布版本(RELEASE)
对于发布版本，如果 Maven 以前下载过指定的版本文件，比如说 data-service:1.0，Maven 将不会再从仓库下载新的可用的 1.0 文件。若要下载更新的代码，data-service 的版本需要升到1.1。
快照的情况下，每次 app-ui 团队构建他们的项目时，Maven 将自动获取最新的快照(data-service:1.0-SNAPSHOT)。
2. 自动化构建
自动化构建定义了这样一种场景: 在一个项目成功构建完成后，其相关的依赖工程即开始构建，这样可以保证其依赖项目的稳定。
比如一个团队正在开发一个项目 bus-core-api， 并且有其他两个项目 app-web-ui 和 app-desktop-ui 依赖于这个项目。
现在 app-web-ui 和 app-desktop-ui 项目的团队要求不管 bus-core-api 项目何时变化，他们的构建过程都应当可以启动。
使用快照可以确保最新的 bus-core-api 项目被使用，但要达到上面的要求，我们还需要做一些额外的工作。
可以使用两种方式：
- 在 bus-core-api 项目的 pom 文件中添加一个 post-build 目标操作来启动 app-web-ui 和 app-desktop-ui 项目的构建。
- 使用持续集成（CI） 服务器，比如 Hudson，来自行管理构建自动化。
3. Maven 自动化部署
项目开发过程中，部署的过程包含需如下步骤：
- 将所的项目代码提交到 代码托管服务 或者代码库中并打上标签。
- 从 代码托管服务 下载完整的源代码。
- 构建应用。
- 存储构建输出的 WAR 或者 EAR 文件到一个常用的网络位置下。
- 从网络上获取文件并且部署文件到生产站点上。
- 更新文档并且更新应用的版本号。
- 问题描述
通常情况下上面的提到开发过程中会涉及到多个团队。一个团队可能负责提交代码，另一个团队负责构建等等。很有可能由于涉及的人为操作和多团队环境的原因，任何一个步骤都可能出错。比如，较旧的版本没有在网络机器上更新，然后部署团队又重新部署了较早的构建版本。
- 解决方案
通过结合以下方案来实现自动化部署：
- 使用 Maven 构建和发布项目
- 使用 代码托管服务，代码仓库来管理源代码
- 使用远程仓库管理软件（Jfrog或者Nexus） 来管理项目二进制文件。
可以使用 Maven 发布的插件来创建一个自动化发布过程。在 pom.xml 文件中，我们常用到的一些重要元素节点如下表所示：
| 元素节点 | 描述 |
|---|---|
| SCM | 配置 SVN 的路径，Maven 将从该路径下将代码取下来。 |
| repository | 构建的 WAR 或 EAR 或JAR 文件的位置，或者其他源码构建成功后生成的构件的存储位置。 |
| Plugin | 配置 maven-release-plugin 插件来实现自动部署过程。 |
八、Maven 常用命令
Maven 命令遵循以下模式：
mvn [选项] [生命周期阶段] [目标]
检查 Maven 版本
bash
mvn -v这个命令会显示已安装的 Maven 版本、Java 版本等信息。
Maven 生命周期命令
Maven 基于构建生命周期的概念，包含三个主要的生命周期：
- clean：清理项目
- default (build)：项目构建
- site：生成项目文档
清理项目
bash
mvn clean这个命令会删除 target 目录，即删除所有构建生成的文件。
编译项目
bash
mvn compile编译源代码，编译后的 class 文件会放在 target/classes 目录下。
运行测试
bash
mvn test运行项目中的所有测试用例。
打包项目
bash
mvn package根据 POM 文件中指定的打包类型（如 jar、war）打包项目。
安装到本地仓库
bash
mvn install将项目构建并安装到本地 Maven 仓库，供其他项目依赖使用。
部署到远程仓库
bash
mvn deploy将最终的项目包复制到远程仓库，供其他开发人员和项目使用。
依赖管理命令
查看项目依赖树
bash
mvn dependency:tree显示项目的依赖树，有助于分析依赖关系和解决依赖冲突。
下载源代码
bash
mvn dependency:sources下载项目依赖的源代码。
分析依赖
bash
mvn dependency:analyze分析项目中使用但未声明的依赖，以及声明但未使用的依赖。
项目创建命令
创建简单项目
bash
mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false使用 Maven 原型系统创建一个简单的 Java 项目。
创建 Web 项目
bash
mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-web-app -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false创建一个简单的 Web 应用程序项目。
其他实用命令
跳过测试
bash
mvn install -DskipTests构建项目并安装到本地仓库，但跳过测试阶段。
运行特定测试
bash
mvn test -Dtest=TestClassName只运行指定的测试类。
bash
mvn test -Dtest=TestClassName#testMethodName只运行指定测试类中的特定测试方法。
更新依赖
bash
mvn versions:display-dependency-updates检查项目中哪些依赖有更新的版本可用。
生成站点文档
bash
mvn site生成项目的站点文档，包括各种报告。
运行特定阶段
bash
mvn clean package先执行 clean 生命周期，然后执行 default 生命周期到 package 阶段。
Maven 命令组合使用
Maven 命令可以组合使用以提高效率：
bash
mvn clean install先清理项目，然后编译、测试并安装到本地仓库。
bash
mvn clean package -DskipTests清理项目，打包但不运行测试。
常见问题解决
强制更新快照依赖
bash
mvn clean install -U-U 参数强制 Maven 检查远程仓库中依赖的更新版本。
离线模式
bash
mvn -o package-o 参数让 Maven 在离线模式下运行，只使用本地仓库中的依赖。
调试模式
bash
mvn -X clean install-X 参数启用调试输出，显示详细的执行信息。
基础构建命令
| 命令 | 作用 | 执行的生命周期阶段 |
|---|---|---|
mvn clean |
删除target/目录 |
clean |
mvn validate |
验证项目是否正确 | validate |
mvn compile |
编译主源代码 | compile |
mvn test-compile |
编译测试代码 | test-compile |
mvn test |
运行单元测试 | test |
mvn package |
打包项目 | package |
mvn verify |
运行集成测试 | verify |
mvn install |
安装到本地仓库 | install |
mvn deploy |
部署到远程仓库 | deploy |
典型开发流程:
bash
mvn clean compile test package依赖管理命令
| 命令 | 作用 |
|---|---|
mvn dependency:tree |
显示依赖树 |
mvn dependency:analyze |
分析依赖问题 |
mvn dependency:copy-dependencies |
复制依赖到目录 |
mvn dependency:purge-local-repository |
清除本地依赖缓存 |
mvn versions:display-dependency-updates |
检查依赖更新 |
查看依赖树
bash
mvn dependency:tree检查可用更新
bash
mvn versions:display-dependency-updates插件相关命令
| 命令 | 作用 |
|---|---|
mvn help:describe -Dplugin=插件名 |
查看插件信息 |
mvn help:effective-pom |
查看最终生效的POM |
mvn 插件前缀:目标 |
直接运行插件目标 |
查看compiler插件信息
bash
mvn help:describe -Dplugin=compiler直接运行compiler插件的compile目标
bash
mvn compiler:compile测试相关命令
| 命令 | 作用 |
|---|---|
mvn test |
运行所有测试 |
mvn -Dtest=测试类名 test |
运行指定测试类 |
mvn -Dtest=测试类名#方法名 test |
运行指定测试方法 |
mvn -DskipTests=true package |
跳过测试 |
只运行UserServiceTest类
mvn -Dtest=UserServiceTest test
只运行UserServiceTest中的testCreate方法
mvn -Dtest=UserServiceTest#testCreate test
多模块项目命令
| 命令 | 作用 |
|---|---|
mvn -pl 模块名 命令 |
对指定模块执行命令 |
mvn -am -pl 模块名 命令 |
执行命令并处理依赖模块 |
mvn -rf 模块名 命令 |
从指定模块继续执行 |
只编译service模块
bash
mvn -pl service compile编译web模块及其依赖的模块
bash
mvn -am -pl web compile高级用法
| 命令 | 作用 |
|---|---|
mvn -T 4 install |
使用4个线程并行构建 |
mvn -o package |
离线模式运行 |
mvn -X clean install |
开启调试输出 |
mvn -U clean install |
强制更新snapshot依赖 |
mvn release:prepare |
准备项目发布 |
mvn release:perform |
执行项目发布 |
并行构建(4线程)
bash
mvn -T 4 clean install强制更新snapshot依赖
bash
mvn -U clean install常用命令组合
| 组合命令 | 作用 |
|---|---|
mvn clean install |
清理后重新安装 |
mvn clean package -DskipTests |
清理后打包并跳过测试 |
mvn clean test |
清理后运行测试 |
mvn clean deploy |
清理后部署 |
实用技巧
快速查看项目信息：
bash
mvn help:effective-pom
mvn help:describe -Dcmd=compile调试构建问题：
bash
mvn -X clean install跳过检查：
bash
mvn install -Dcheckstyle.skip=true -Dpmd.skip=true指定配置文件：
bash
mvn install -P production查看构建时间：
bash
mvn install --batch-mode | grep "Total time"本文的引用仅限自我学习如有侵权，请联系作者删除。
参考知识
菜鸟教程-MAVEN