Maven 从 0 到 1：安装、配置与依赖管理一站式指南

[Maven 从 0 到 1：安装、配置与依赖管理一站式指南](#Maven 从 0 到 1：安装、配置与依赖管理一站式指南)
- [一、Maven 是什么？](#一、Maven 是什么？)
- 二、核心概念：POM
- [三、Maven 是如何工作的？------ 仓库机制](#三、Maven 是如何工作的？—— 仓库机制)
- 四、安装Maven
- [五、在 IntelliJ IDEA 里配置Maven](#五、在 IntelliJ IDEA 里配置Maven)
- [六、解析 Maven 坐标](#六、解析 Maven 坐标)
- - [6.1 Maven 坐标的核心组成部分](#6.1 Maven 坐标的核心组成部分)
  - [6.2 一个具体的例子](#6.2 一个具体的例子)
  - 6.3其他重要概念
  - 6.4总结
- [七、Maven 依赖配置超简三步走](#七、Maven 依赖配置超简三步走)
- - [第 1 步：找到依赖项信息](#第 1 步：找到依赖项信息)
  - [第 2 步：将依赖项添加到 pom.xml](#第 2 步：将依赖项添加到 pom.xml)
  - [第 3 步：排除依赖](#第 3 步：排除依赖)
- [八、Maven 生命周期核心讲解](#八、Maven 生命周期核心讲解)
- - [1. 三大生命周期 (Lifecycle)](#1. 三大生命周期 (Lifecycle))
  - [2. 生命周期阶段 (Phase)](#2. 生命周期阶段 (Phase))
  - [3. 在IDEA里面使用Maven命令](#3. 在IDEA里面使用Maven命令)
  - [4. 在终端里使用Maven命令](#4. 在终端里使用Maven命令)

Maven 从 0 到 1：安装、配置与依赖管理一站式指南

你是否曾经在开始一个 Java 项目时，面对一堆需要下载的 .jar 包感到头疼？是否因为项目结构混乱，导致团队协作困难？别担心，Maven 就是来解决这些问题的！

这篇文章将用最通俗易懂的方式，带你从零开始认识 Maven。

一、Maven 是什么？

简单来说，Maven 是一个项目管理和构建工具。

你可以把它想象成一个非常智能、全能的项目助理。你只需要告诉它你的项目需要什么（比如需要 Spring 框架版本 5.x，需要 JUnit 来测试），它就会自动帮你：

下载和管理 这些依赖的库（.jar 包）。
编译你的源代码。
运行测试用例。
打包你的项目（打成 .jar 或 .war 文件）。
部署你的项目。

它的核心思想是 "约定优于配置" 。这意味着 Maven 已经为你规定好了一个标准的项目目录结构。只要你按照这个结构来放置文件，Maven 就知道该去哪里找源代码、资源文件等，你就不需要再写一大堆配置去告诉它了。

二、核心概念：POM

Maven 的所有行为都围绕一个核心文件展开：pom.xml。

POM 的全称是 Project Object Model（项目对象模型）。它就像是你这个项目的"身份证"和"说明书"，存放在你项目的根目录下。

在这个 pom.xml 文件里，你定义了关于你项目的所有重要信息，Maven 正是通过读取这个文件才知道该如何工作的。

一个最基本的 pom.xml 长这样：

xml 复制代码

<?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.mycompany</groupId>   <!-- 公司或组织名，倒叙域名 -->
	<artifactId>my-first-app</artifactId> <!-- 项目名 -->
	<version>1.0.0-SNAPSHOT</version>     <!-- 版本号 -->

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

	<!-- 依赖列表 -->
	<dependencies>
	    <!-- 一个具体的依赖 -->
	    <dependency>
	        <groupId>junit</groupId>
	        <artifactId>junit</artifactId>
	        <version>4.13.2</version>
	        <scope>test</scope> <!-- 作用域：只在测试时使用 -->
	    </dependency>
	</dependencies>
</project>

什么是"坐标"？

groupId, artifactId, version 这三个属性组成了 Maven 世界的"坐标"，通过这个坐标，Maven 可以唯一地定位到任何一个第三方库。这也是它能够自动下载依赖的秘诀。

三、Maven 是如何工作的？------ 仓库机制

Maven 通过仓库来统一管理所有依赖。

本地仓库 ：在你个人电脑上的一个文件夹。Maven 会先把所有下载好的 jar 包放在这里。默认路径是 ~/.m2/repository。
中央仓库：由 Maven 社区维护的全球唯一仓库。当你声明了一个依赖后，Maven 会首先在本地仓库查找，如果找不到，就会自动去中央仓库下载到你本地。
私服：一些大公司会在内部搭建的私有仓库服务器，作为中央仓库的镜像，目的是节省带宽和加速构建。

这个过程完全是自动的 ，你只需要在 pom.xml 中声明 "我需要什么"，而不需要手动搜索、下载、添加。这极大地解决了依赖管理带来的混乱。

四、安装Maven

Maven官网下载地址：https://maven.apache.org/download.cgi

下载好了之后将压缩包解压在没有中文路径的地方。

配置一个本地仓库 （新建一个名为mvn_repo的文件夹）
我此处的路径为：D:\apache-maven-3.9.11\mvn_repo
修改配置文件，用记事本打开"D:\apache-maven-3.9.11\conf\settings.xml"

添加这串代码

xml 复制代码

  <localRepository>D:\apache-maven-3.9.11\mvn_repo</localRepository>

将镜像替换为阿里云镜像

xml 复制代码

    <mirror>
        <id>alimaven</id>
        <name>aliyun maven</name>
        <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
        <mirrorOf>central</mirrorOf>
    </mirror>

在系统变量里面添加%MAVEN_HOME%目录选择D:\apache-maven-3.9.11
在path里面新建一个%MAVEN_HOME%\bin
在cmd里面输入mvn -v
若出现这个则说明安装完成

五、在 IntelliJ IDEA 里配置Maven

首先打开 IntelliJ IDEA 的设置（记得先关闭当前项目，在全局设置里面调，不然调的是项目的设置）

在构建、执行、部署 里找到构建工具 ------>Maven

更改主路径和用户设置文件
在 Maven的下面的【运行程序】里面添加当前你的JRE版本
检查Java编译器，项目字节码版本应该与语言级别相同
创建一个新项目，在项目结构里面检查一下
运行成功就说明配置好了

六、解析 Maven 坐标

Maven 坐标是 Maven 的核心概念，它就像是一个物件的唯一身份证，通过一组标识来精确定位和管理项目所依赖的任何一个构件（Jar 包、War 包等）。

6.1 Maven 坐标的核心组成部分

一个完整的 Maven 坐标主要由以下 5 个基本元素组成，其中前三个是必选的，后两个是可选的。

元素	说明	是否必须	举例
`groupId`	组织/公司标识。通常使用反向域名规则，如公司域名倒序。它定义了项目所属的组织或集团，下辖多个 `artifactId`。	必须	`org.springframework.boot`, `com.google.guava`
`artifactId`	项目/模块标识。代表该组织下的一个具体项目或模块。生成的构件的名称会基于这个 `artifactId`。	必须	`spring-boot-starter-web`, `guava`
`version`	版本号。指定项目的当前版本。	必须	`2.7.3`, `31.1-jre`
`packaging`	打包方式。指定项目构建后生成的构件类型。如果未指定，默认为 `jar`。	可选	`jar`, `war`, `pom`, `maven-plugin`, `ear`
`classifier`	分类器。用于区分从相同 POM 但内容不同的构件。例如，`javadoc` 和 `sources` 构件。	可选	`sources`（源码包）, `javadoc`（文档包）, `jdk8`（针对JDK 8的版本）

6.2 一个具体的例子

我们来看一个非常常见的 Maven 依赖声明，它来自 pom.xml 文件中<dependencies> 部分：

xml 复制代码

<dependency>

	<groupId>org.springframework.boot</groupId>
	
	<artifactId>spring-boot-starter-web</artifactId>
	
	<version>2.7.3</version>

</dependency>

解析这个坐标：

groupId: org.springframework.boot
- 这告诉我们，这个依赖是由 Spring Boot 这个组织（项目）维护的。所有 Spring Boot 官方提供的构件都以这个开头。
artifactId: spring-boot-starter-web
- 这是 Spring Boot 组织下的一个具体模块，名为 spring-boot-starter-web。从名字就能看出，它是用于支持 Web 应用开发的起步依赖。
version: 2.7.3
- 这个 Web 起步依赖的具体版本是 2.7.3 。Maven 会根据这个版本号去仓库里寻找对应的 jar 文件。
packaging: jar (默认值，未显式写出)
- 这个依赖最终被打包成一个 Jar 文件，例如 spring-boot-starter-web-2.7.3.jar。

最终，Maven 会根据这个坐标，在本地仓库或远程中央仓库中寻找名为：
org/springframework/boot/spring-boot-starter-web/2.7.3/spring-boot-starter-web-2.7.3.jar

的文件。

6.3其他重要概念

坐标的唯一性 ：groupId + artifactId + version + packaging + classifier 这五个元素组合起来，构成了一个全球唯一的标识。世界上不会有两个构件拥有完全相同的这组坐标。
SNAPSHOT 版本 ：版本号中如果带有 -SNAPSHOT（例如 1.0.0-SNAPSHOT），表示这是一个快照版本，通常处于开发阶段。Maven 会优先去远程仓库检查是否有更新的快照版本，这对于团队协作开发非常有用。
版本范围 ：你可以指定一个版本范围而不是固定版本（如 [1.2.0,)），但不推荐使用，因为它会导致构建的不确定性。
<scope> ：虽然不属于坐标本身，但常与坐标一同使用。它定义了依赖的作用范围 （如 compile, test, provided, runtime），决定了依赖在项目生命周期哪个阶段可用。

6.4总结

Maven 坐标是一个简单而强大的寻址系统。理解它的每个部分意味着：

当你需要添加一个依赖时 ，你知道如何去网上（如 Maven Central Repository）查找正确的 groupId, artifactId 和 version。
当你看到一段依赖配置时，你能立刻明白它引用的是哪个组织的哪个项目的哪个版本。
当出现依赖冲突时，你能根据坐标信息快速定位问题来源。

七、Maven 依赖配置超简三步走

第 1 步：找到依赖项信息

当你想要在项目中使用某个第三方库时，你需要知道它的坐标（Coordinates），即三个信息：

groupId: 通常代表组织或项目组。
artifactId: 代表项目中的具体库名。
version: 库的版本号。

如何找到这些信息？

最直接的方法是去 Maven 中央仓库https://mvnrepository.com/搜索。

打开网站，在搜索框输入你想要的库名，例如 Spring Context。
选择一个稳定且常用的版本（版本号后面有 Usage柱状图的那个），点击进去。
3. 页面中会直接给出它的 Maven 配置代码，复制即可。

第 2 步：将依赖项添加到 pom.xml

在你的 Maven 项目根目录下，有一个最重要的文件叫 pom.xml。打开它，找到 <dependencies>标签。所有的依赖项都要放在这个标签里面。如果还没有这个标签，就在 <project>标签内，自己创建它。把你从中央仓库复制的代码，粘贴到 <dependencies>内部。

示例：

假设我们找到了 Jackson Databind版本 2.15.2，那么你的 pom.xml看起来应该是这样的：

点击刷新，看到maven这栏依赖项里面有就说明配置好了

第 3 步：排除依赖

如果需要某个依赖，但想排除它带来的特定子依赖，使用 <exclusions>标签：

xml 复制代码

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.2.7</version>
            <exclusions>
                <!-- 排除不需要的子依赖 -->
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-aop</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-expression</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

再次刷新过后可以发现依赖项已经被删除了

八、Maven 生命周期核心讲解

Maven 的生命周期被设计得非常完善和有序，它包含了项目构建的所有环节。其核心思想是：生命周期由多个阶段（Phase）组成，每个阶段负责一个特定的任务，并且这些阶段是按顺序执行的。

1. 三大生命周期 (Lifecycle)

Maven 拥有三套相互独立的生命周期：

clean ：清理生命周期，负责清除上次构建生成的文件（比如删除 target 目录）。
default (或 build)：构建生命周期，这是最核心的部分，负责编译、测试、打包、部署等整个构建过程。
site：站点生命周期，负责生成项目报告、站点文档等。

2. 生命周期阶段 (Phase)

每个生命周期都由一系列按顺序排列的阶段构成。执行某个阶段，会自动执行它之前的所有阶段。

以最重要的 default（构建）生命周期为例，其关键阶段包括（按顺序）：

validate：验证项目是否正确且所有必要信息可用。
compile：编译项目的源代码。
test：使用单元测试框架（如 JUnit）运行测试。此阶段不会要求打包或部署代码。
package：将编译后的代码打包成可分发格式，如 JAR、WAR 包。
verify：对集成测试结果进行检查，以确保满足质量要求。
install ：将打包好的软件包安装到本地仓库，以便其他本地项目依赖使用。
deploy ：在构建环境中完成，将最终的软件包复制到远程仓库，以便其他开发者和项目共享。

3. 在IDEA里面使用Maven命令

以下面的pom.xml为例

xml 复制代码

<?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>org.example</groupId>
    <artifactId>Maven2</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>21</maven.compiler.source>
        <maven.compiler.target>21</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.2.7</version>
            <exclusions>
                <!-- 排除不需要的子依赖 -->
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-aop</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-expression</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>
</project>

在IDEA右侧的Lifestyle里面双击即可执行

以下是执行完package之后的场景，会在target里面生成一个jar包

运行完install之后可以在我们本地仓库里面找到安装好的jar包

此时我的路径为D:\apache-maven-3.9.11\mvn_repo\org\example\Maven2\1.0-SNAPSHOT

<groupId>org.example</groupId>这行代码里面的org.example就是我们在本地仓库里面需要找的路径

4. 在终端里使用Maven命令

项目编译与打包

命令	说明
`mvn compile`	编译源代码，生成 `.class` 文件到 `target/classes` 目录
`mvn test`	运行测试用例（会先自动执行 `compile`）
`mvn package`	打包项目（会先执行 `test`），生成 JAR/WAR 包到 `target/` 目录
`mvn install`	安装到本地仓库（会先执行 `package`），以便其他本地项目引用
`mvn clean`	清理项目，删除 `target` 目录
`mvn clean install`	最常用组合：先清理再安装，确保是全新构建

跳过测试相关

命令	说明
`mvn install -DskipTests`	跳过测试，但会编译测试代码
`mvn install -Dmaven.test.skip=true`	完全跳过测试，不编译也不执行测试

依赖管理

命令	说明
`mvn dependency:tree`	显示依赖树，查看所有传递性依赖，排查 Jar 包冲突神器
`mvn dependency:resolve`	解析依赖，下载所有依赖包
`mvn dependency:purge-local-repository`	清理本地仓库中当前项目的依赖缓存（慎用）

其他实用命令

命令	说明
`mvn help:effective-pom`	查看有效 POM，显示所有默认配置与自定义配置合并后的最终结果
`mvn --version` 或 `mvn -v`	查看 Maven 版本信息
`mvn <phase> -h` 或 `--help`	获取帮助，例如 `mvn install -h`