从零开始学 Maven：简化 Java 项目的构建与管理

一、关于Maven

1.1 简介

Maven 是一个由 Apache 软件基金会开发的项目管理和构建自动化工具。它主要用在 Java 项目中，但也可以用于其他类型的项目。Maven 的设计目标是提供一种更加简单、一致的方法来构建和管理项目，它通过使用一个标准的目录布局和一组默认的构建规则来减少配置的数量。

‍

1.2 发展

1. Maven 的起源和初期发展

• 2002年 - Maven 项目的启动：
  Maven 最初由Sonatype 公司的 Jason van Zyl 于 2002 年发起。之前，Apache Ant 被广泛用于 Java 项目的构建，然而 Ant 依赖于大量的手动配置和命令行参数，且缺少统一的构建生命周期和依赖管理功能。这使得开发人员在管理多个项目时非常麻烦。Maven 的初衷就是解决这些问题。

  Jason van Zyl 希望通过 Maven 提供一个更高效、更灵活的构建工具，能够自动管理依赖关系并简化构建过程。

​ Jason van Zyl

​

• 2004年 - Maven 1.0 发布：
  Maven 1.0 是 Maven 的第一个稳定版本，它引入了 POM（Project Object Model） 的概念，提供了通过 XML 配置管理项目的依赖关系、构建过程和插件。Maven 1.0 提供了一些基本功能，如自动下载依赖库、标准化构建过程和创建 JAR 文件，但其插件支持和功能相对有限。

  Maven 1 的缺点之一是它的 POM 配置较为复杂，且构建速度不尽人意，导致其在一些较大项目中并未得到广泛应用。

2. Maven 2.x：重构和成熟阶段

• 2005年 - Maven 2 的开发：
  Maven 2 的开发始于 2005 年，它的目标是克服 Maven 1.x 中的一些设计缺陷。最显著的变化之一是 Maven 2 引入了全新的插件架构，并进行了彻底的重构。Maven 2 完全重写了 POM 文件，并将其格式与功能进行了优化，支持更复杂的依赖关系和模块化构建。

  其中，Maven 2 的依赖管理功能大大加强，它引入了 传递性依赖（即，如果项目 A 依赖于项目 B，而项目 B 又依赖于项目 C，Maven 会自动管理并下载 C）。此外，Maven 2 还支持了构建生命周期的概念，分阶段处理构建、测试、打包和部署。

• 2005年 - Maven 2.0.0 发布：
  Maven 2.0 于 2005 年发布，它不仅增强了依赖管理，还引入了新的构建生命周期，改进了 POM 文件的结构，并在性能上进行了优化。此外，Maven 2 提供了插件扩展机制，使得开发人员可以根据需求自定义构建过程。

  Maven 2 的出现，使得它在 Java 开发界获得了极大的关注和推广。其标准化的构建方式和强大的依赖管理功能吸引了越来越多的开发者和开源项目。

• 2007年 - Maven 2.x 的成熟：
  Maven 2 的后续版本逐步修复了 2.0 的一些缺陷，并不断扩展功能。例如，Maven 2.2.x 系列进一步完善了插件机制，并提升了构建效率。此时，Maven 已成为 Java 项目构建和依赖管理的标准工具，许多大型 Java 项目和企业开始采用 Maven 作为默认的构建工具。

3. Maven 3.x：进一步优化与社区支持

• 2010年 - Maven 3.0 发布：
  Maven 3.0 于 2010 年发布，它对 Maven 2 进行了进一步的优化和重构。Maven 3 引入了一些新特性，包括：

  • 改进的构建性能：通过更好的并行构建和缓存机制，Maven 3 提升了构建性能，尤其是在大型项目中的构建效率有了显著提高。
  • 兼容性增强：Maven 3 强调了与 Maven 2 的兼容性，使得从 Maven 2 升级到 Maven 3 变得更加平滑。
  • 对多模块项目的支持：Maven 3 在多模块项目构建方面进行了改进，支持更复杂的构建需求，增强了模块间依赖关系的管理。
  • 增强的插件支持：Maven 3 引入了新的插件接口，进一步提升了插件的可扩展性和复用性。

• 2011年 - Maven 3.0.x 系列发布：
  在 Maven 3.0 发布后，Maven 团队持续发布了多个次版本（如 3.0.x、3.1.x、3.2.x 等），每个版本都进一步修复了漏洞、提升了性能并增强了功能。此时，Maven 已经成为 Java 开发中的标准工具，广泛应用于企业级开发和开源项目中。

4. Maven 的生态系统和扩展

随着 Maven 的普及，越来越多的企业和开源项目开始基于 Maven 构建工具，Maven 不仅仅是一个构建工具，它逐渐形成了一个完整的生态系统，包括：

• Maven 中央仓库：作为全球最大的 Java 库仓库，Maven 中央仓库提供了成千上万的 Java 依赖，开发者可以方便地获取开源库并直接用于项目中。
• 插件生态系统：Maven 拥有大量的官方插件和第三方插件，支持从代码质量检查、单元测试、文档生成、到部署发布的各个方面。开发者可以根据需求添加和配置插件。
• Maven 依赖管理：Maven 的依赖管理不仅限于下载外部库，还包括了多种依赖版本冲突的解决方案，例如版本排除、优先级等。

5. Maven 的当前状态与未来

• 2014年及之后 - Maven 3.x 持续更新：
  Maven 团队在 2014 年以后继续发布 Maven 3.x 的小版本更新，修复了一些小错误和提高了对新技术的支持。尽管没有像 3.0 那样大的版本变动，但 Maven 仍然在不断发展，保持着对新技术的支持。
• 与其他工具的兼容性：
  Maven 仍然与其他构建工具（如 Gradle）共同存在，并且在一定程度上与其他工具兼容。例如，Maven 可以与 Jenkins 等 CI/CD 工具集成，并支持多种构建和部署需求。
• Maven 的未来：
  Maven 作为一个成熟的构建工具，尽管现在已经被许多新工具如 Gradle 和 Bazel 竞争，但它依然是 Java 社区中最流行的构建工具之一。未来，Maven 可能会继续优化性能、增强插件生态系统、改善与其他语言（如 Kotlin、Scala 等）的集成，并继续支持企业级开发中的需求。

‍

1.3 功能特点

Maven 是一个强大的构建工具，尤其在 Java 项目中广泛使用。它具有以下几个显著的特点：

1. 标准化的构建流程

Maven 提供了标准化的构建生命周期，能够自动化整个项目的构建过程。通过固定的目录结构和生命周期，Maven 使得开发者在构建、测试、打包、部署时遵循统一的规则，减少了重复性配置和不一致性。Maven 的构建生命周期分为多个阶段，如：

• validate：验证项目是否正确。
• compile：编译源代码。
• test：运行单元测试。
• package：将编译好的代码打包成 JAR 或 WAR 文件。
• install：将打包后的文件安装到本地仓库。
• deploy：将构建好的文件部署到远程仓库。

这些标准化的步骤有助于团队成员之间的一致性和效率。

‍

2. 依赖管理

Maven 的依赖管理是其最强大的特点之一。它通过 POM（Project Object Model） 文件来声明项目的依赖，自动下载和管理依赖的库。Maven 解决了以下问题：

• 自动下载依赖：Maven 会自动从中央仓库或自定义仓库中下载所需的 JAR 包，并将其缓存到本地仓库中。
• 传递性依赖：如果项目 A 依赖于项目 B，而项目 B 又依赖于项目 C，Maven 会自动下载并管理这些传递性依赖关系。
• 版本管理：Maven 允许开发者指定特定的版本，或者使用范围和范围限制来管理版本冲突。

这种依赖管理机制避免了“JAR 地狱”问题（即不同版本的 JAR 包相互冲突）。

‍

3. 跨平台支持

Maven 是一个 Java 构建工具，能够跨平台运行，支持不同操作系统（如 Windows、Linux、Mac）。它通过命令行接口 (CLI) 运行，不依赖于任何 IDE，可以在任何支持 Java 的环境中使用。

‍

4. 中央仓库和远程仓库支持

Maven 提供了一个 中央仓库，这是一个开源的公共仓库，包含了大量的常用 Java 库和框架（如 Spring、Hibernate 等）。除了中央仓库，Maven 还支持 远程仓库 和 私有仓库，开发者可以将自己的库或公司内部的依赖上传到远程仓库，进行共享和版本控制。

• 中央仓库：Maven 默认使用中央仓库来下载依赖。
• 远程仓库：开发团队可以配置额外的远程仓库，Maven 会自动从这些仓库下载依赖。
• 本地仓库：Maven 会将下载的依赖存储在本地仓库中，避免重复下载。

‍

5. 插件机制

Maven 提供了丰富的插件机制。通过插件，Maven 不仅能够进行构建，还可以执行测试、代码质量检查、文档生成、打包、部署等任务。常见的 Maven 插件有：

• Maven Compiler Plugin：用于编译 Java 源代码。
• Maven Surefire Plugin：用于运行单元测试。
• Maven JAR Plugin：用于生成 JAR 文件。
• Maven Clean Plugin：用于清理构建生成的文件。
• Maven Deploy Plugin：用于将构建的文件发布到远程仓库。

开发者还可以自定义插件来扩展 Maven 的功能。

‍

6. 继承与聚合

Maven 支持项目的 继承 和 聚合，这对于多模块（multi-module）项目非常有用：

• 继承：子项目可以继承父项目的配置，包括插件、依赖和构建设置。通过继承，子项目可以共享父项目中的 POM 文件，从而简化管理。
• 聚合：Maven 支持将多个模块聚合在一个父项目中，统一管理和构建。这使得管理大型、多模块的企业级项目变得更加简便。

‍

7. 项目对象模型（POM）

POM 是 Maven 构建的核心，所有的构建配置和依赖都在 POM 文件中进行定义。POM 文件是一个 XML 文件，描述了项目的各种信息：

• 项目版本
• 依赖的库和插件
• 构建配置
• 构建生命周期和阶段
• 项目描述（如开发者、许可证、URL 等）

POM 文件为 Maven 提供了灵活和可扩展的配置能力，使得构建过程可以根据项目需求进行精细调整。

‍

8. 集成与扩展

Maven 能与多种工具和服务进行集成，支持包括 CI/CD（持续集成/持续交付） 在内的自动化构建和部署流程。常见的集成工具包括：

• Jenkins：可以使用 Maven 插件来集成自动化构建过程。
• SonarQube：用于代码质量分析，Maven 可以通过插件集成 SonarQube 来检查代码质量。
• Docker：Maven 可以与 Docker 集成，将构建生成的文件自动部署到 Docker 容器中。

此外，Maven 还支持与 Git、SVN 等版本控制系统的集成，可以在构建过程中自动获取代码仓库中的最新代码。

‍

9. 良好的社区支持

Maven 拥有一个强大而活跃的开源社区，提供了大量的文档、教程和支持。很多流行的开源项目（如 Spring、Hibernate）都提供了对 Maven 的支持，开发者可以方便地使用 Maven 来构建和管理这些框架。

‍

10. 易于配置与扩展

通过简单的配置文件（POM），Maven 可以进行高度自定义。开发者可以根据具体需求配置不同的插件、依赖、构建生命周期等。而且，Maven 的插件支持自定义，可以根据项目的特定需求进行扩展。

‍

‍

二、Maven相关概念及流程

2.1 Maven 的核心概念

项目对象模型（POM）

POM 是 Maven 构建过程的核心，每个 Maven 项目都会有一个 pom.xml​ 文件，里面定义了项目的基本信息、依赖、构建生命周期、插件和其他配置。POM 文件包含了如下重要部分：

• 项目的基本信息：如 groupId​, artifactId​, version​ 等。
• 依赖管理：定义了项目所需要的外部库及其版本。
• 插件和目标：Maven 构建过程的实际执行步骤由插件完成，插件通过不同的目标来定义行为。
• 构建生命周期：定义了从编译、测试、打包到发布的所有步骤。

‍

依赖管理

Maven 可以通过配置文件自动下载项目所需要的所有依赖包，解决了传统构建工具中手动管理依赖的麻烦。它允许开发者指定依赖的版本、范围等信息，并且可以从 Maven 中央仓库或指定的私有仓库中下载这些依赖。依赖管理的一个重要特性是 传递性依赖，即如果项目依赖于某个库，而该库又依赖于其他库，Maven 会自动下载这些间接依赖。

‍

构建生命周期

Maven 通过预定义的构建生命周期来管理项目的构建过程。每个生命周期由多个阶段（phase）组成，每个阶段执行一个特定的任务，生命周期的执行是按顺序进行的。Maven 默认有三个生命周期：

• 默认生命周期（default lifecycle） ：负责项目的构建过程，包括编译、测试、打包、安装等。
• 清理生命周期（clean lifecycle） ：负责清理构建过程中产生的临时文件。
• 验证生命周期（site lifecycle） ：用于生成项目的文档或报告。

每个生命周期包括若干个阶段（phase），例如 compile​、test​、package​、install​ 等，Maven 会根据所执行的目标自动决定运行哪些阶段。

‍

插件

Maven 的功能大多通过插件来扩展，插件可以执行构建过程中的各个任务。插件不仅可以执行编译、测试、打包等任务，还可以执行代码质量检查、报告生成、发布等功能。常见的插件包括：

• Compiler Plugin：用于编译 Java 源代码。
• Surefire Plugin：用于运行单元测试。
• Jar Plugin：用于生成 JAR 包。
• Deploy Plugin：用于将构建的 artifact 部署到远程仓库。

‍

仓库

Maven 使用仓库来存储项目依赖包和构建产物。Maven 仓库分为：

• 本地仓库（Local Repository） ：每个开发者机器上都有一个本地仓库，默认路径是 ~/.m2/repository​。当你第一次构建项目时，Maven 会下载依赖包并存储到本地仓库，以供后续使用。
• 中央仓库（Central Repository） ：Maven 提供了一个官方的中央仓库，包含了大量的开源 Java 库，开发者可以直接从中获取依赖。
• 远程仓库（Remote Repository） ：一些企业或组织可能会使用自己的远程仓库来存储内部使用的库和组件。Maven 支持通过配置文件来连接到这些远程仓库。

‍

2.2 Maven 构建过程

Maven 的构建过程是基于生命周期和阶段的，构建过程的每一个阶段都会调用一组插件任务。一个典型的 Maven 构建过程如下：

1. clean 阶段：删除 target/​ 目录。(会删除原来编译和测试的目录，即 target 目录，但是已经 install 到仓库里的包不会删除)
2. validate 阶段：验证项目的 POM 文件是否有效。
3. compile 阶段：编译源代码。(会在当前目录下生成一个 target,里边存放编译主程序之后生成的字节码文件)
4. test 阶段：运行单元测试。(会生成一个目录surefire-reports，保存测试结果)
5. package 阶段：将编译后的代码打包成 JAR、WAR 或其他类型的文件。
6. verify 阶段：运行集成测试等验证。
7. install 阶段：将构建好的 artifact 安装到本地仓库。
8. deploy 阶段：将构建好的 artifact 发布到远程仓库。

‍

2.3 Maven 常用命令

• mvn clean: 清理项目，删除 target​ 目录。
• mvn compile: 编译项目。
• mvn test: 运行单元测试。
• mvn package: 打包项目（生成 JAR、WAR、EAR 文件）。
• mvn install: 将构建的包安装到本地仓库。
• mvn deploy: 将构建的包发布到远程仓库。
• mvn site: 生成项目的文档和报告。

‍

2.4 Maven 配置文件

​pom.xml​​ 示例

pom.xml​ 是 Maven 项目的核心配置文件，包含了项目信息、依赖、构建插件、构建生命周期等内容。一个简单的 pom.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/POM/4.0.0/maven.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>myapp</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <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>
</project>

‍

这是一个典型的 Maven 项目的 pom.xml​ 配置文件，定义了项目的基本信息、依赖、构建插件等内容。逐行解析这个 pom.xml​ 文件的每个部分：

1. 文件声明

<?xml version="1.0" encoding="UTF-8"?>

• 这是 XML 文件的声明，指定文件的编码格式为 UTF-8。

2. ​<project>​ ​ 元素

<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/POM/4.0.0/maven.xsd">

• <project>​ 是 Maven POM 文件的根元素，所有的配置都在这个元素下。
• xmlns​ 声明了 XML 命名空间，指定了 Maven POM 的版本（4.0.0​）。
• xsi:schemaLocation​ 指定了 XML Schema 的位置，用于验证 pom.xml​ 文件的结构。

3. ​<modelVersion>​ ​ 元素

<modelVersion>4.0.0</modelVersion>

• 这个元素指定了 POM 文件的模型版本。4.0.0​ 是当前的标准版本，几乎所有的 Maven 项目都会使用这个版本。

4. 项目信息

<groupId>com.example</groupId>
<artifactId>myapp</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>

• <groupId>​：定义了项目的组织 ID，通常使用反转的域名作为标识。例如，这里的 com.example​ 表示这个项目属于 com.example​ 这个组织。
• <artifactId>​：定义了项目的名称（ID）。在这里，myapp​ 是该项目的名称。
• <version>​：定义了项目的版本。1.0-SNAPSHOT​ 表示该版本是一个开发版本（“SNAPSHOT” 表示这个版本还在开发中，可能会发生更改）。
• <packaging>​：定义了项目的打包类型。这里是 jar​，表示构建一个 JAR 文件。常见的还有 war​、pom​ 等。

5. ​<dependencies>​ ​ 元素

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

• <dependencies>​：用于定义项目的依赖。这里列出了一个依赖项，表示项目需要使用 JUnit​ 测试框架。

• <dependency>​：每个 <dependency>​ 元素代表一个 Maven 依赖项。它包括：

  • <groupId>​：依赖项的组织标识符。这里是 junit​。
  • <artifactId>​：依赖项的名称。这里是 junit​。
  • <version>​：依赖项的版本。这里是 4.13.2​。
  • <scope>​：指定依赖的作用范围。这里是 test​，表示 JUnit​ 只在测试阶段需要（不会被打包到最终的 JAR 文件中）。

6. ​<build>​ ​ 元素

<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>

• <build>​：定义了构建相关的信息和配置。

• <plugins>​：用于列出构建插件，Maven 会根据这些插件来执行项目的构建任务。

• <plugin>​：定义一个构建插件。这个例子中使用的是 maven-compiler-plugin​，它用于编译 Java 代码。

  • <groupId>​：指定插件的组织 ID，这里是 org.apache.maven.plugins​，表示这是 Maven 官方提供的插件。

  • <artifactId>​：指定插件的名称，这里是 maven-compiler-plugin​，表示这是编译插件。

  • <version>​：插件的版本，这里是 3.8.1​。

  • <configuration>​：在这里配置插件的具体行为。

    • <source>​：指定源代码的版本，这里设置为 1.8​，表示使用 Java 8 编写的代码。
    • <target>​：指定编译后的字节码的目标版本，这里也设置为 1.8​，表示编译后生成的字节码可以在 Java 8 环境下运行。

总结

这个 pom.xml​ 文件定义了一个 Maven 项目的基本配置，包括：

• 项目的基本信息（如 groupId​、artifactId​、version​ 和 packaging​）。
• 项目依赖（这里引入了 JUnit 测试框架，且限定了 test​ 作用域）。
• 项目的构建配置（通过 maven-compiler-plugin​ 插件配置了 Java 编译器的版本）。

这些配置告诉 Maven 如何管理项目的构建、依赖和插件，确保项目在不同环境中能够一致地构建和运行。

‍

‍

三、Maven 项目结构及创建

3.1 Maven 项目结构

Maven 是一个流行的项目管理和构建自动化工具，广泛用于 Java 项目的构建、依赖管理和项目生命周期管理。在 Maven 项目中，推荐使用标准的目录结构，这种结构帮助开发者和构建工具更容易地理解和维护项目。以下是 Maven 项目的标准目录结构：

1. 项目根目录

Maven 项目的根目录包含了几个重要的文件和目录，包括 pom.xml​ 和项目的子模块等。

my-maven-project/
├── pom.xml           # 项目的根 POM 文件
├── src/              # 项目的源代码和资源文件
└── target/           # 构建输出目录（编译后的类文件和 JAR 包等）

2. ​pom.xml​​ 文件

在 Maven 项目中，pom.xml​ 是非常重要的配置文件。它包含了项目的基本信息，如依赖项、插件、构建配置、版本控制等。POM 文件是 Maven 构建和管理的核心，包含以下基本内容：

• 项目信息：如 groupId​、artifactId​、version​ 等。
• 依赖管理：列出项目依赖的其他库或模块。
• 构建配置：包括编译插件、打包插件等。

3. ​src​​ 目录

src​ 目录包含了源代码、资源文件、测试代码等。它是 Maven 项目的主要开发区域。标准的 Maven 项目结构要求 src​ 目录进一步细分为以下几个子目录：

src/
├── main/               # 主代码和资源文件
│   ├── java/           # Java 源代码
│   ├── resources/      # 资源文件（如配置文件、XML 文件等）
│   ├── webapp/         # 适用于 Web 项目的静态资源（如 JSP、HTML、CSS 文件等）
├── test/               # 测试代码和资源文件
│   ├── java/           # 测试源代码
│   ├── resources/      # 测试资源文件

3.1 ​src/main​​ 目录

src/main​ 目录下的文件通常用于生产代码和资源。

• ​src/main/java/​ ​：用于存放 Java 源代码。这里是开发者编写主要应用逻辑的地方。
• ​src/main/resources/​ ​：存放项目的资源文件，如配置文件、数据库脚本、XML 文件等。Maven 会将这些资源文件复制到输出目录 target/classes​ 中。
• ​src/main/webapp/​ ​：如果是一个 Web 应用项目，src/main/webapp/​ 目录会包含 HTML、JSP、CSS、JavaScript 等前端文件。

3.2 ​src/test​​ 目录

src/test​ 目录下的文件通常用于存放单元测试代码和测试资源。

• ​src/test/java/​ ​：用于存放 Java 测试代码。测试类通常会模仿主代码目录中的包结构。
• ​src/test/resources/​ ​：存放测试资源文件，这些资源文件在执行单元测试时可能需要。

4. ​target​​ 目录

target​ 目录是 Maven 构建过程中生成的输出目录。它通常包含编译后的字节码文件、构建产物（如 JAR 文件、WAR 文件）、临时文件等。

target/
├── classes/           # 编译后的类文件（来自 src/main/java）
├── test-classes/      # 编译后的测试类文件（来自 src/test/java）
├── my-maven-project-1.0-SNAPSHOT.jar   # 生成的 JAR 文件（如果是 JAR 项目）
└── ...                # 其他构建生成的文件

5. 其他常见目录和文件

• ​.mvn/​ ​：存放 Maven 特定的配置文件（如 Maven Wrapper），用于在不同的开发环境中统一使用相同版本的 Maven。
• ​lib/​ ​：通常不是 Maven 项目结构的一部分，但某些项目可能会将第三方依赖手动存放在 lib​ 目录下。一般情况下，Maven 会从中央仓库自动下载和管理依赖。

‍

Maven 目录结构示例

一个完整的 Maven 项目目录结构示例如下：

my-maven-project/
├── pom.xml
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/App.java
│   │   ├── resources/
│   │   │   └── application.properties
│   │   └── webapp/
│   │       ├── index.html
│   │       └── css/
│   │           └── style.css
│   └── test/
│       ├── java/
│       │   └── com/example/AppTest.java
│       └── resources/
│           └── test-config.properties
└── target/
    ├── classes/
    ├── test-classes/
    ├── my-maven-project-1.0-SNAPSHOT.jar
    └── ...

一个具体Java Web maven项目示例
​

‍

3.2 Maven项目创建

创建 Maven 项目有多种方法，常见的有通过命令行使用 mvn​ 命令、使用 IDE（如 IntelliJ IDEA、Eclipse）或使用脚本来初始化项目。以下是几种常见方法的详细步骤。

方法 1：通过命令行创建 Maven 项目

你可以使用 Maven 的 archetype​ 插件在命令行中创建一个 Maven 项目。Maven 提供了许多模板（archetype），这些模板定义了项目的基本结构。以下是创建 Maven 项目的步骤：

1. 安装 Maven（如果还没安装）

• 下载并安装 Maven：Maven官网
• 配置环境变量：将 Maven 的 bin​ 目录添加到系统的 PATH​ 环境变量中。（后面详细介绍安装流程）

2. 使用 Maven Archetype 创建项目

在命令行中，运行以下命令：

mvn archetype:generate -DgroupId=com.example -DartifactId=my-maven-project -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

参数说明：

• -DgroupId=com.example​：指定项目的 Group ID（通常是组织或公司域名的反转）。
• -DartifactId=my-maven-project​：指定项目的 Artifact ID（即项目名称）。
• -DarchetypeArtifactId=maven-archetype-quickstart​：指定要使用的 Archetype 模板（这里是 maven-archetype-quickstart​，用于创建简单的 Java 项目）。
• -DinteractiveMode=false​：在命令行模式下自动使用默认设置，避免交互式询问。

3. 目录结构

命令执行完成后，Maven 会在当前目录下创建一个新的项目目录，并按照标准的 Maven 项目结构生成文件：

my-maven-project/
├── pom.xml               # 项目的 POM 文件
├── src/
│   ├── main/
│   │   └── java/
│   │       └── com/example/App.java
│   └── test/
│       └── java/
│           └── com/example/AppTest.java
└── target/               # 编译后的文件和构建产物

‍

方法 2：使用 IDE 创建 Maven 项目

如果你使用的是集成开发环境（IDE），如 IntelliJ IDEA 或 Eclipse，创建 Maven 项目会更加方便。以下是 IntelliJ IDEA 和 Eclipse 中创建 Maven 项目的步骤。

1. 在 IntelliJ IDEA 中创建 Maven 项目

1. 打开 IntelliJ IDEA，点击 Create New Project。

2. 在左侧选择 Maven，并选择 Create from archetype。

3. 选择合适的 Archetype 模板（例如，maven-archetype-quickstart​）。

4. 填写项目的基本信息：

   • GroupId：项目的组织标识（如 com.example​）。
   • ArtifactId：项目的名称（如 my-maven-project​）。
   • Version：项目的版本（默认 1.0-SNAPSHOT​）。

5. 点击 Finish，IDEA 会自动创建 Maven 项目，并将其导入。

​
‍

2. 在 Eclipse 中创建 Maven 项目

1. 打开 Eclipse，选择 File > New > Maven Project。
2. 选择一个合适的 Archetype（例如 maven-archetype-quickstart​）。
3. 填写项目的 GroupId 和 ArtifactId 信息。
4. 点击 Finish，Eclipse 会自动创建 Maven 项目。

‍

方法 3：手动创建 Maven 项目

你也可以手动创建 Maven 项目，首先创建项目的目录结构，然后创建 pom.xml​ 文件。

1. 创建项目目录

在你的工作空间中创建一个新目录，命名为项目名称：

mkdir my-maven-project
cd my-maven-project

2. 创建 pom.xml​ 文件

在项目的根目录下创建 pom.xml​ 文件，它是 Maven 项目的核心配置文件。以下是一个简单的 pom.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.example</groupId>
    <artifactId>my-maven-project</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>My Maven Project</name>

    <dependencies>
        <!-- Example dependency -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

3. 创建目录结构和源代码

在 src​ 目录下创建 main/java​ 和 test/java​ 目录，分别存放主代码和测试代码。

src/
├── main/
│   └── java/
│       └── com/example/App.java
└── test/
    └── java/
        └── com/example/AppTest.java

创建 App.java​ 和 AppTest.java​ 文件（参考 maven-archetype-quickstart​ 的模板）：

src/main/java/com/example/App.java​：

package com.example;

public class App {
    public static void main(String[] args) {
        System.out.println("Hello, Maven!");
    }
}

src/test/java/com/example/AppTest.java​：

package com.example;

import org.junit.Test;
import static org.junit.Assert.assertTrue;

public class AppTest {
    @Test
    public void testApp() {
        assertTrue(true);
    }
}

4. 构建项目

在命令行中进入项目根目录，运行以下命令来构建项目：

mvn clean install

Maven 会下载所需的依赖，编译源代码，并在 target​ 目录下生成项目构建的产物（如 JAR 文件）。

‍

方法 4：使用 Maven Wrapper

Maven Wrapper 是一个可以让项目自动带上 Maven 配置的工具，不需要用户单独安装 Maven。可以通过以下步骤生成 Maven Wrapper：

1. 进入项目目录，运行：

   mvn -N io.takari:maven:wrapper
   

2. 执行完成后，项目中会出现以下文件：

   • mvnw​ 和 mvnw.cmd​：执行 Maven Wrapper 脚本。
   • .mvn/​ 目录：存放 Maven Wrapper 的配置文件。

之后，使用 ./mvnw​（在 Linux/Mac 上）或 mvnw.cmd​（在 Windows 上）来执行 Maven 构建命令，确保项目在任何环境下都能构建，而无需安装 Maven。

‍

以上是几种创建 Maven 项目的常见方法。无论是通过命令行、IDE，还是手动创建，都可以快速启动一个 Maven 项目。最重要的是要理解 Maven 的项目结构（如 pom.xml​ 配置、src​ 目录结构等）以及如何管理依赖和构建。

‍

总的来说，Maven 是一款功能强大且被广泛应用的构建工具，它能够帮助开发者简化项目的构建流程，提高开发效率。虽然入门起来有些复杂，但只要掌握了它的核心原理和实践方法，你就能更高效地管理依赖、自动化构建和发布项目。希望你能通过本文的学习，深入理解 Maven 的精髓，并挑战自己在实际开发中熟练应用。未来的开发路上，Maven 将是你强大的助手。