Maven-和-Eclipse-全-

Maven 和 Eclipse（全）

原文：zh.annas-archive.org/md5/3070d3ef452ff1197943495e230aee86

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

Maven for Eclipse 是一本不可或缺的指南，帮助您使用 m2eclipse 插件在 Eclipse IDE 中理解和使用 Maven。它绝对不是一本深入和全面的资源。相反，它是一本关于 Maven 项目开发的快速便捷指南。它从 Apache Maven 的基础开始；涵盖核心概念；并展示如何在 Eclipse IDE 中使用 m2eclipse 插件创建、导入、构建、运行、打包和自定义，以生成 Maven 项目的项目工件。

本书涵盖内容

第一章，Apache Maven – 简介和安装，为用户提供了一个关于 Apache Maven 的快速介绍和安装参考。到本章结束时，用户将能够在他们的系统上运行一个 Maven 项目。

第二章，安装 m2eclipse，为用户提供安装 m2eclipse 插件的参考，并提供了 Eclipse 的 Maven 集成。到本章结束时，用户将在他们的系统上安装好 m2eclipse 并准备好使用。

第三章，创建和导入项目，从 Maven 项目结构开始，介绍核心方面和概念，并指导您使用 m2eclipse 插件创建和导入 Maven 项目。到本章结束时，用户将熟悉 Maven 项目结构的核心概念，并且能够创建和导入 Maven 项目。

第四章，构建和运行项目，向用户介绍不同的构建生命周期，并教授他们如何查看 m2eclipse 控制台以及如何构建和运行项目。到本章结束时，用户将熟悉构建生命周期，并且能够熟练使用 m2eclipse 构建和运行项目。

第五章，调味 Maven 项目，教授用户如何创建一个简单的 Web 应用程序，展示如何自定义它，并提供如何编写和运行单元测试的指南。到本章结束时，用户将学会使用 m2eclipse 创建 Web 应用程序，并学习如何更改 POM 文件以针对单元测试生成报告。

第六章，创建多模块项目，旨在介绍多模块项目的概念，并教授用户如何创建、构建和运行项目。到本章结束时，用户将了解如何使用 m2eclipse 插件创建和运行多模块 Maven 项目。

第七章，探索 m2eclipse，深入探讨了 m2eclipse 插件，并介绍了不同的功能和方面，使生活更加便捷。到本章结束时，用户将熟悉 m2eclipse 的每个方面，并能高效且轻松地使用它。

您需要为这本书准备什么

建议您在开发期间使用以下配置的笔记本电脑或台式机以获得最佳性能：

• 4 GB RAM

• Windows OS 7 / Ubuntu 12.04 / Mac OS Maverick

• 双核 / iSeries 处理器

• 互联网连接

本书面向对象

本书面向初学者和现有开发者，他们想学习如何为 Java 项目使用 Maven。假设您有 Java 编程经验，并且您已经使用 IDE 进行开发。

习惯用法

在本书中，您将找到许多不同风格的文本，以区分不同类型的信息。以下是一些这些风格的示例及其含义的解释。

文本中的代码单词、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 昵称将如下所示："可以在pom文件中声明性地包含插件和目标，以自定义项目的执行。"

代码块将如下设置：

<project><modelVersion>4.0.0</modelVersion><groupId>com.packt.mvneclipse</groupId><artifactId>mvneclipse</artifactId><version>1.2</version>
</project>

当我们希望您注意代码块中的特定部分时，相关的行或项目将以粗体显示：

<!--General project Information --><modelVersion>4.0.0</modelVersion><groupId>com.packt.mvneclipse</groupId><artifactId>hello-project</artifactId><version>0.0.1-SNAPSHOT</version><name>hello-project</name><url>http://maven.apache.org</url><properties>1<project.build.sourceEncoding>UTF8</project.build.sourceEncoding>
</properties><repositories><repository><snapshots><enabled>false</enabled></snapshots><id>central</id><name>Maven Repository Switchboard</name><url>http://repo1.maven.org/maven2</url></repository>
</repositories>

任何命令行输入或输出将如下所示：

set PATH =%PATH%;%M2_HOME%\bin

新术语和重要词汇将以粗体显示。您在屏幕上看到的单词，例如在菜单或对话框中，在文本中将如下所示："要使 m2eclipse 使用外部 Maven，请转到 Eclipse 中的窗口 | 首选项，然后出现首选项窗口。"

注意

警告或重要注意事项将以如下框中显示。

小贴士

小贴士和技巧如下所示。

读者反馈

我们始终欢迎读者的反馈。请告诉我们您对这本书的看法——您喜欢什么或可能不喜欢什么。读者反馈对我们开发您真正从中受益的标题非常重要。

要向我们发送一般反馈，只需将电子邮件发送到<feedback@packtpub.com>，并在邮件主题中提及书籍标题。

如果您在某个主题领域有专业知识，并且您有兴趣撰写或为书籍做出贡献，请参阅我们的作者指南www.packtpub.com/authors。

客户支持

现在，您是 Packt 书籍的骄傲拥有者，我们有一些事情可以帮助您从购买中获得最大收益。

下载示例代码

您可以从您在www.packtpub.com的账户下载您购买的所有 Packt 书籍的示例代码文件。如果您在其他地方购买了这本书，您可以访问www.packtpub.com/support并注册，以便将文件直接通过电子邮件发送给您。

错误清单

尽管我们已经尽一切努力确保我们内容的准确性，但错误仍然会发生。如果您在我们的某本书中发现错误——可能是文本或代码中的错误——如果您能向我们报告这一点，我们将不胜感激。通过这样做，您可以节省其他读者的挫败感，并帮助我们改进本书的后续版本。如果您发现任何错误清单，请通过访问www.packtpub.com/submit-errata，选择您的书籍，点击错误提交表单链接，并输入您的错误详细信息来报告它们。一旦您的错误得到验证，您的提交将被接受，错误将被上传到我们的网站，或添加到该标题的现有错误清单中，在“错误清单”部分下。您可以通过从www.packtpub.com/support选择您的标题来查看任何现有错误清单。

盗版

互联网上对版权材料的盗版是一个跨所有媒体的持续问题。在 Packt，我们非常重视我们版权和许可证的保护。如果您在互联网上发现我们作品的任何非法副本，无论形式如何，请立即提供位置地址或网站名称，以便我们可以寻求补救措施。

请通过链接到疑似盗版材料的方式，通过<copyright@packtpub.com>联系我们。

我们感谢您在保护我们作者以及为我们提供有价值内容的能力方面的帮助。

问题

如果您在本书的任何方面遇到问题，可以通过<questions@packtpub.com>联系我们，我们将尽力解决。

第一章. Apache Maven – 简介和安装

“千里之行，始于足下”，老子。正如此，如果你在这里阅读这句话，你已经迈出了迈向 Maven 之旅的第一步，使用 Eclipse 作为这一旅程的一部分。在这一旅程的第一章，我们将向您介绍 Maven 及其基本架构，然后通过以下子主题引导您完成安装过程：

• Maven 简介

• Maven 的起源

• Maven 的原则

• Maven 的组件架构

• Maven 与 Ant 的比较

• 下载 Maven

• 安装 Maven

• 在 Windows 上安装 Maven

• 在 Linux 和 Mac OS 上安装 Maven

• 验证 Maven 的安装

Maven 简介

Apache Maven 的官方网站声明，Apache Maven，也称为Maven，是一个软件项目管理和理解工具。通常，软件项目管理包括规划、组织、管理资源池和开发资源估算；因此，用 Maven 提供的产品来证明其价值是一种无意义的抽象。简单来说，Maven 是一种将模式应用于构建基础设施的综合方法，其主要目标如下：

• 简化构建过程

• 提供统一的构建系统

• 提供高质量的项目信息

• 提供最佳实践开发的指南

• 允许透明迁移到新功能

为了实现上述目标，Maven 提供了一套构建标准、一个工件仓库模型、一个描述项目的引擎以及一个标准的生命周期来构建、测试和部署项目工件。

Maven 的起源

Maven，一个意第绪语单词，意为知识的积累者，最初是作为简化 Jakarta Turbine 项目中构建过程的尝试而启动的。在 Maven 之前，Ant 是跨项目使用的构建工具，不同项目之间有不同的 Ant 构建文件。此外，没有标准或一致的项目 Ant 构建文件，JAR 文件也需要在子版本控制系统中进行检查。因此，有必要标准化项目的构建过程及其结构，发布项目信息，并在项目之间重用 JAR 文件，这导致了新工具 Maven 的形成。Maven 使开发者的日常工作变得容易，并为任何 Java 项目提供了理解。

Maven 的原则

Maven 的原则可以概括为以下几点：

• 约定优于配置：Maven 定义了默认的项目结构，并构建了一个简化开发负担的生命周期。通过指定一个公开定义的模型，它使得项目更加易于理解。

• 声明式执行：Maven 定义了一个包含阶段的生命周期，这些阶段又由插件目标组成。插件和目标可以声明性地包含在pom文件中，以自定义项目的执行。

• 可重用性：Maven 的构建和执行声明是以可重用性为前提构建的。一个项目的构建和执行声明可以在不同的项目中使用。Maven 还使得创建组件并将其集成到多项目构建系统中变得更加容易。此外，通过 Maven 最佳实践，鼓励整个行业进行开发。

• 依赖的一致性组织：Maven 负责依赖管理，从而减轻了开发者的负担。不同依赖之间的冲突也得到了很好的处理。

• 专注于编写应用程序：有了标准的项目布局和构建生命周期，就不需要开发构建；重点应该主要放在构建应用程序上。

Maven 的组件架构

Maven 是围绕以下图所示的各个组件构建的：

Maven 组件架构（参考 Apache 团队演示）

Plexus 容器

Plexus 是一个 IOC 容器，它提供面向组件的编程，以构建模块化、可重用的组件，这些组件可以轻松组装和重用。它支持的一些功能如下：

• 组件生命周期

• 组件实例化策略

• 嵌套容器

• 组件配置

• 自动装配

• 组件依赖

• 包括构造函数注入、setter 注入和私有字段注入在内的各种依赖注入技术

注意

更多信息可以在plexus.codehaus.org/找到。

Wagon

Maven Wagon 是一个在 Maven 工件和仓库处理代码中使用的传输抽象。Wagon 定义了一个统一的 API，并且目前有以下提供者：

• 文件

• HTTP

• 轻量级 HTTP

• FTP

• SSH/SCP

• WebDAV

注意

更多信息可以在maven.apache.org/wagon/找到。

Maven Doxia

Doxia 是一个内容生成框架，它为用户提供强大的技术来生成静态和动态内容。Doxia 还用于基于 Web 的发布环境中生成静态站点，同时还集成到动态内容生成系统，如博客、维基和内容管理系统。

注意

更多关于 Maven Doxia 的信息，请参阅maven.apache.org/doxia/。

Modello

Maven 中的 Modello 组件可以在构建时根据数据模型生成以下类型的工件：

• 数据模型的 Java POJOs

• Java POJOs 到 XML

• XML 到 Java POJOs

• 数据模型 Xdoc 文档

• XML 模式用于验证 XML 内容是否与数据模型匹配

注意

更多信息，请参阅maven.apache.org/maven-1.x/plugins/modello/。

Maven 版本控制

此组件提供了一个通用的 API 来执行源代码管理（SCM）操作。以下类型的 SCM 得到支持：

• Bazaar

• CVS

• Git

• Jazz

• Mercurial

• Perforce

• StarTeam

• Subversion

• CM 能源

注意

更多信息请参阅 maven.apache.org/scm/。

Maven 与 Ant

在 Maven 出现之前，Ant 是 Java 项目中最广泛使用的构建工具。Ant 从 C/C++ 编程中创建文件的概念发展成为一个平台独立的构建工具。Ant 使用 XML 文件来定义构建过程及其相应的依赖关系。

另一个实用的工具（Ant）是由 James Duncan Davidson 在准备 Sun 的参考 JSP/Servlet 引擎 Apache Tomcat 时构思的。以下是一个简单的 Ant 构建文件示例（ant.apache.org/manual/using.html）：

<project name="MyProject" default="dist" basedir="."><description>simple example build file</description><!-- set global properties for this build --><property name="src" location="src"/><property name="build" location="build"/><property name="dist"  location="dist"/><target name="init"><!-- Create the time stamp --><tstamp/><!-- Create the build directory structure used by compile --><mkdir dir="${build}"/></target><target name="compile" depends="init"description="compile the source " ><!-- Compile the java code from ${src} into ${build} --><javac srcdir="${src}" destdir="${build}"/></target><target name="dist" depends="compile"description="generate the distribution" ><!-- Create the distribution directory --><mkdir dir="${dist}/lib"/><!-- Put everything in ${build} into the MyProject-${DSTAMP}.jar file --><jar jarfile="${dist}/lib/MyProject-${DSTAMP}.jar" basedir="${build}"/></target><target name="clean"description="clean up" ><!-- Delete the ${build} and ${dist} directory trees --><delete dir="${build}"/><delete dir="${dist}"/></target>
</project>

小贴士

下载示例代码

您可以从您在 www.packtpub.com 的账户中下载您购买的所有 Packt 书籍的示例代码文件。如果您在其他地方购买了这本书，您可以访问 www.packtpub.com/support 并注册，以便将文件直接通过电子邮件发送给您。

此示例展示了如何构建一个简单的 JAR 文件。注意，必须指定与源文件、类文件和 JAR 文件相对应的所有详细信息。甚至必须指定步骤的顺序。这导致构建文件复杂，并且通常有很多重复的 XML。

让我们看看最简单的 Maven 构建文件，即 pom 文件，它将在第三章（part0024_split_000.html#page "第三章. 创建和导入项目”）中更详细地讨论，创建和导入项目。

一个简单的 pom 文件看起来如下所示：

<project><modelVersion>4.0.0</modelVersion><groupId>com.packt.mvneclipse</groupId><artifactId>mvneclipse</artifactId><version>1.2</version>
</project>

这就是我们从一个 Java 项目中构建和打包为 JAR 所需要的一切。前面示例中 Ant 和 Maven 之间的一些差异如下：

• 约定优于配置：Ant 需要开发者为从源代码的位置到 JAR 文件的存储配置一切。另一方面，Maven 遵循约定，有一个定义良好的项目结构，并知道如何引用源文件、资源文件以及放置输出。

• 生命周期：Ant 没有生命周期，需要定义目标和它们的依赖关系。此外，在 Ant 中，需要指定任务的顺序。Maven 定义了一个生命周期，由构建阶段和目标组成；因此，不需要进行配置。

除了前面简单示例中可以引用的差异之外，Maven 在以下方面优于 Ant：

• 更高的重用性：Maven 可以在不同的 Maven 项目中重用构建逻辑。

• 更少的维护：有了标准化的结构和可重用选项，它需要更少的维护工作。

• 依赖管理：Maven 相对于 Ant 的一个最优越的方面是其管理相应依赖的能力。尽管最近，结合 Apache Ivy 的 Ant 确实简化了依赖管理；然而，Maven 有其他方面超过了这个组合提供的内容。

• 自动下载：Maven 会自动下载依赖项；然而，Ant 缺乏这一功能。虽然 Ant 可以使用 Ivy 来复制这种行为，但它需要额外的行为。

• 仓库管理：Maven 仓库是任意且可访问的位置，用于存储 Maven 构建的工件。它们将仓库管理为本地与远程（将在第三章的仓库部分详细讨论，创建和导入项目）。Ant 没有这一功能。

下载 Maven

要下载 Maven，请访问maven.apache.org/download.cgi。点击最新版本，apache-maven-x.x.x-bin.zip；在撰写本文时，当前版本是apache-maven-3.2.1-bin.zip。按照以下截图所示下载最新版本：

一旦下载了 ZIP 文件，请将其解压到，比如说，maven3。解压后，maven3文件夹内将会有一个名为apache-maven-3.2.1的文件夹，该文件夹的内容如下所示：

安装 Maven

在我们安装 Maven 之前，我们需要安装 JDK。使用以下命令检查 Java 安装：

>javac -version

对于 Windows，打开命令提示符，对于 Linux/Mac OS，打开终端，并使用前面的命令查看已安装的 JDK 版本。

如果未安装 JDK，请参考以下链接并安装它：

www.oracle.com/technetwork/java/javase/index-137561.html

一旦 Java 安装就绪，让我们转向 Maven 的安装。

Maven 的安装是一个简单的两步过程：

• 设置 Maven 家目录，即M2_HOME变量

• 将 Maven 家目录添加到PATH变量中

在 Windows 上安装 Maven

Maven 的安装只是设置解压的 Maven 文件夹中的 Maven 家目录。为了方便，我们假设maven3文件夹位于C:\Program Files。现在，在命令提示符中使用以下命令设置 Maven 家目录：

set M2_HOME="c:\Program Files\maven3\apache-maven-3.2.1"

按照以下方式更新PATH变量：

set PATH =%PATH%;%M2_HOME%\bin

或者，可以通过导航到桌面 | 我的电脑 | 属性来永久设置变量。访问www.computerhope.com/issues/ch000549.htm获取更多信息。

在 Linux 和 Mac OS 上安装 Maven

假设maven3文件夹位于/opt文件夹中。由于 Mac OS 没有/opt文件夹，让我们在根目录下创建一个名为opt的文件夹，即/opt。现在，假设我们有一个maven3，其中包含解压的文件夹。然后，通过终端执行以下命令设置 Maven 家目录：

export  M2_HOME=/opt/maven3/apache-maven-3.2.1

按照以下方式将 Maven 添加到PATH变量中：

export PATH=${M2_HOME}/bin:${PATH}

要永久添加，请将其添加到bash文件中，如下所示：

cd $HOME
vi .bash_profile

将前面的变量添加到文件中，即添加两行，然后保存，并执行以下命令：

source  .bash_profile

验证 Maven 的安装

在执行了前面的步骤之后，现在是时候验证 Maven 的安装了。为了验证安装，请执行以下操作：

• 对于 Windows，打开命令提示符并输入以下命令：

  mvn -version

• 对于 Linux 和 Mac OS，打开终端并输入以下命令：

  mvn -version

应该会显示已安装 Maven 的相应版本，如下面的截图所示：

摘要

恭喜！到本章结束时，你已经熟悉了 Maven，并在系统中安装了 Maven。现在你准备好开始这段旅程了。在下一章中，你将学习如何为 Eclipse 安装和设置 m2eclipse 插件。

第二章：安装 m2eclipse

我们通过在前一章中迈出的第一步开始了我们的旅程；在这里，我们将迈出另一步。在本章中，我们将从安装 IDE（即 Eclipse）开始，然后深入了解将 Maven 集成到 Eclipse 插件（即 m2eclipse）的细节。本章涵盖的主题包括：

• m2eclipse 简介

• 下载 Eclipse

• 安装和启动 Eclipse

• 安装 m2eclipse 的方法

• 设置 Maven 以便使用

m2eclipse 简介

m2eclipse 是一个插件，它提供了 Maven 与 Eclipse 的集成。它的目的是弥合 Eclipse 和 Maven 之间的差距，帮助使用 Maven 架构创建项目，并使用简单直观的界面启动和管理使用简单编辑器构建的项目。它使得在 IDE 中使用 Maven 变得更加容易。m2eclipse 提供的一些功能如下：

• 创建和导入 Maven 项目

• 在 Eclipse 内启动 Maven 构建

• Eclipse 构建路径的依赖项管理

• 自动依赖项下载和更新

• 实现一个项目

• 浏览和搜索远程 Maven 仓库

• 支持多模块 Maven 项目

除了上述功能外，结合不同的 m2e 连接器和 Mylyn 插件，它还提供了与代码版本控制仓库和基于任务的界面进行通信的能力。

m2eclipse 自 2006 年以来一直存在，归功于尤金·库列绍夫。它在 2008 年被移至 Eclipse 基金会之前，在 Codehaus 社区开发了两年。

下载 Eclipse

如果你已经安装了 Eclipse，你可以跳过这一节和下一节，直接进入 安装 m2eclipse 部分。

要下载 Eclipse，请访问以下 URL：

www.eclipse.org/downloads/

下一个截图可以可视化。在撰写本书时，Eclipse 的最新版本是 Eclipse Kepler 4.3.2 SR2，我们将下载这个版本并在本书的其余部分使用它。

从下拉菜单中选择一个合适的操作系统，并为相应的架构（即 32 位或 64 位）下载 Eclipse IDE for Java Developers 软件包（如图所示）。对于安装在系统中的 32 位 Java，选择 32 位；对于 64 位 Java，选择 64 位。

在下一步中，选择您所在位置附近的适当镜像，下载将开始。镜像屏幕可能看起来如下截图所示：

安装和启动 Eclipse

前往下载文件的所在位置，如图所示，并将其提取到您选择的位置。提取将生成一个名为 eclipse 的文件夹。eclipse 文件夹的内容如图所示：

我们可以看到有一个名为eclipse的应用程序或可执行文件，双击它将启动 Eclipse IDE。当 Eclipse 启动时，它会提示你输入工作区位置。提供一个合适的位置来存储项目，然后点击确定。现在，我们就在 Eclipse 空间中，准备开始操作。你将看到类似于以下截图的内容：

安装 m2eclipse 的方法

安装 m2eclipse 相当简单。主要来说，有两种方法在 Eclipse 中安装 m2eclipse 插件：

• 使用 Eclipse Marketplace：使用 Eclipse Marketplace 查找并安装插件

• 使用更新站点：添加 m2eclipse 更新站点并安装

使用 Eclipse Marketplace

使用 Eclipse Marketplace 安装 m2eclipse 的步骤如下：

1. 导航到帮助 | Eclipse Marketplace，如图所示：

2. 然后，在搜索框中搜索m2eclipse，并点击 Eclipse 包的 Maven 集成安装按钮，如图所示：

3. 在下一个窗口中，确认要安装的包如下：

4. 接受条款和条件，然后点击完成。安装完成后，将出现以下提示：

5. 点击是以重启 Eclipse 并使更改生效。

6. 对于 Mac 用户，选择立即重启选项，对于其他操作系统，选择是。

使用更新站点

使用更新站点安装 m2eclipse 的步骤如下：

1. 导航到帮助 | 安装新软件，你的屏幕将类似于以下截图：

2. 点击添加...按钮。将download.eclipse.org/technology/m2e/releases站点添加为 m2eclipse 更新站点，如图所示，然后点击确定：

3. 选择如图所示的包：

4. 点击下一步，同意条款，最后点击完成以开始安装。安装完成后，将出现以下提示：

5. 点击是以重启 Eclipse 并使更改生效。对于 Mac 用户，选择立即重启选项，对于其他操作系统用户，选择是。

   注意

   Eclipse Kepler 4.3.2 SR2 已安装 m2eclipse，因此前面的安装步骤将更新插件到最新版本。无论使用上述哪种安装方法，Eclipse Kepler 中打包的 m2eclipse 都将更新。

   因此，在中间阶段，你将看到以下类似的屏幕：

   

6. 点击 下一步 并接受条款，点击 完成 以开始安装，然后您需要重新启动以使更改生效。

设置 Maven 以便使用

m2eclipse 内置了 Maven 组件，因此 第一章 中讨论的外部 Maven 安装，Apache Maven – 简介和安装 是可选的。然而，为了使用 Maven 的最新版本，我们被要求在外部安装 Maven，正如前一章所讨论的那样。我们还需要确保我们的 m2eclipse 插件使用它。此外，现在使用持续集成服务器需要我们在服务器之间有一个共同的 Maven 版本，因此我们使用外部安装的 Maven。

要使 m2eclipse 使用外部 Maven 版本，在 Eclipse 中导航到 窗口 | 首选项，将出现 首选项 窗口。在左侧窗格的搜索框中搜索 maven，然后点击 安装，如下面的截图所示：

点击 添加... 按钮，选择 Maven 目录的位置。从上一章，我们的位置是 /opt/maven3/apache-maven-3.2.1。检查相应的外部 Maven 复选框，如图所示，然后点击 应用，接着点击 确定：

现在，m2eclipse 将使用这个 Maven。

摘要

到本章结束时，您已经了解了安装 Eclipse 和 m2eclipse 以及设置 m2eclipse 以使用外部安装的 Maven。在下一章中，我们将探讨 Maven 的重要概念，您将学习如何创建和导入 Maven 项目，并熟悉 Maven 项目的结构。

第三章：创建和导入项目

让我们继续我们的旅程。在本章中，我们将从 Maven 项目结构开始，然后是构建架构，接着我们将介绍一些基本概念，最后学习如何创建简单的 Maven 项目。本章分为以下部分：

• Maven 项目的结构

• POM（项目对象模型）

  • Maven 坐标

  • POM 关系

  • 简单 POM

  • 超级 POM

• Maven 项目的构建架构

• 其他基本概念

  • 仓库

  • 项目依赖

  • 插件和目标

  • 站点生成和报告

• 创建 Maven 项目

  • 使用原型

  • 不使用原型

  • 检出 Maven 项目

• 导入 Maven 项目

Maven 项目的结构

如前几章所述，Maven 遵循约定优于配置。这使得我们相信 Maven 项目结构有一个标准布局。在我们开始创建和操作 Maven 项目之前，让我们首先了解 Maven 项目的基本通用布局，如下所示：

文件夹/文件	描述
src/main/java	这包含应用程序的 Java 源文件
src/main/resources	这包含应用程序的资源文件，如图像、声音、模板等
src/main/filters	这包含资源的过滤器文件
src/main/config	这包含应用程序的配置文件
src/main/scripts	这包含特定于应用程序的脚本文件
src/main/webapp	这包含 Web 应用程序的源文件
src/test/java	这包含 Java 的单元测试文件
src/test/resources	这包含在应用程序中使用的针对单元测试的特定资源
src/filters	这包含针对资源的测试特定过滤器文件
src/it	这包含集成测试文件（主要用于插件）
src/assembly	这包含汇编描述符的文件
src/site	这包含站点工件
LICENSE.txt	这表示项目的许可证
NOTICE.txt	这包括项目依赖的通知和归属
README.txt	这表示项目的 readme 信息
target	这包含构建的所有输出
pom.xml	这是项目的pom文件（将在后续章节中详细讨论）

尽管之前提到的布局是标准推荐约定，但在项目描述符文件（pom文件）中这总可以被覆盖。

POM（项目对象模型）

POM代表项目对象模型。它主要是文件名为pom.xml的项目 XML 表示。POM 是 Maven 项目的身份，没有它，项目就没有存在。它与Make文件或Ant的build.xml文件类似。

在广义上，一个项目应该包含不仅仅是代码文件，而应该作为一个一站式商店，提供所有与之相关的事物。Maven 使用 pom 文件来满足这一需求。POM 通常回答如下问题：源代码在哪里？资源在哪里？如何进行打包？单元测试在哪里？组件在哪里？构建环境是什么样的？项目的参与者是谁？等等。

简而言之，POM 的内容属于以下四个类别：

• 项目信息：这提供了关于项目的通用信息，例如项目名称、URL、组织、开发者列表和贡献者、许可证等。

• POM 关系：在罕见的情况下，一个项目可以是一个单一实体，不依赖于其他项目。本节提供了关于其依赖项、从父项目继承的信息，以及其子模块等。

• 构建设置：这些设置提供了关于 Maven 构建配置的信息。通常，行为定制，如源代码位置、测试、报告生成、构建插件等，都是在这里完成的。

• 构建环境：这指定并激活了不同环境的构建设置。它还使用配置文件来区分开发、测试和生产环境。

如下所示，一个包含所有讨论类别的 POM 文件：

<project><!-- The Basics Project Information--><groupId>...</groupId><artifactId>...</artifactId><version>...</version><packaging>...</packaging><dependencies>...</dependencies><parent>...</parent><dependencyManagement>...</dependencyManagement><modules>...</modules><properties>...</properties><!-- Build Settings --><build>...</build><reporting>...</reporting><properties>...</properties><packaging>...</packaging><!-- More Project Information --><name>...</name><description>...</description><url>...</url><inceptionYear>...</inceptionYear><licenses>...</licenses><organization>...</organization><developers>...</developers><contributors>...</contributors><!-- POM Relationships --><groupId>...</groupId><artifactId>...</artifactId><version>...</version><parent>...</parent><dependencyManagement>...</dependencyManagement><dependencies>...</dependencies><modules>...</modules><!-- Environment Settings --><issueManagement>...</issueManagement><ciManagement>...</ciManagement><mailingLists>...</mailingLists><scm>...</scm><prerequisites>...</prerequisites><repositories>...</repositories><pluginRepositories>...</pluginRepositories><distributionManagement>...</distributionManagement><profiles>...</profiles>
</project>

Maven 坐标

Maven 坐标定义了一组标识符，这些标识符可以用来在 Maven POM 中唯一地识别一个项目、一个依赖项或一个插件。类似于代数中一个点通过其在空间中的坐标来识别，Maven 坐标在存储库中标记了一个特定的位置，充当 Maven 项目的坐标系。Maven 坐标的组成部分如下：

• groupId：这代表一个组、公司、团队、组织或项目。组 ID 的一般约定是该项目的创建组织的反向域名开头。然而，它可能不一定使用与 junit 项目中相同的点表示法。组构成了在存储库中存储的基础，并且与在操作系统中的 Java 打包结构非常相似。相应的点被替换为操作系统特定的目录分隔符（例如 Unix 中的 /），从而形成了从基本存储库的相对目录结构。例如，如果 groupId 是 com.packt.mvneclipse，它位于 $M2_REPO/com/packt/mvneclipse 目录中。

• artifactId：这是 groupId 下的一个唯一标识符，代表一个单一项目/已知的项目。与 groupId 坐标一起，artifactId 坐标完全定义了在存储库中该组件的居住地。例如，继续前面的例子，具有 hello-project 的组件 ID 位于 $M2_REPO/com/packt/mvneclipse/hello-project 路径。

• 项目版本：这表示项目的特定版本。它还在工件仓库中使用，以区分不同的版本。例如，版本为 1.0 的 hello-project 存在于 $M2_REPO/com/packt/mvneclipse/hello-project/1.0/ 目录中。

• 打包：这描述了由项目生成的打包输出。如果没有声明打包，Maven 假设工件是默认的 jar 文件。Maven 中可用的核心打包值包括：pom、jar、maven-plugin、ejb、war、ear、rar 和 par。以下图示展示了 Maven 坐标的示例：

注意

作为本地仓库，$M2_REPO 表示用户机器上的 %USER_HOME% /.m2 目录。

POM 关系

POM 关系标识了它们与其他模块、项目和其它 POM 之间的关系。这种关系可以是依赖关系、多模块项目、父子关系（也称为继承）和聚合。POM 关系的元素如图所示：

类似地，XML 文件中 POM 关系的元素可以指定如下所示代码：

    <!-- POM Relationships --><groupId>...</groupId><artifactId>...</artifactId><version>...</version><parent>...</parent><dependencyManagement>...</dependencyManagement><dependencies>...</dependencies><modules>...</modules>

一个简单的 POM

最基本的 POM 只包含 Maven 坐标，足以构建和生成项目的 jar 文件。一个简单的 POM 文件可能如下所示代码：

<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.packt.mvneclipse</groupId><artifactId>hello-project</artifactId><version>1.0</version></project>

以下要点将解释这些元素：

• modelVersion 值为 4.0.0。Maven 支持此版本的 POM 模型。

• 每个项目都有一个 POM 文件。

• 所有 POM 文件都需要 project 元素和三个强制字段：groupId、artifactId 和 version。

• pom.xml 的根元素是 project，它有三个主要子节点。

在现实世界的项目中，一个简单的 POM（如前代码片段所示）几乎是不够的。

一个超级 POM

类似于 Java，其中每个对象都继承自 java.lang.Object，每个 POM 都继承自一个称为 Super POM 的基本 POM。隐式地，每个 POM 都从基本 POM 继承默认值。这简化了开发者在 pom.xml 文件中的最小配置工作。然而，当它们在项目的相应 pom 文件中指定时，可以轻松地覆盖默认值。可以通过在相应项目内部运行以下命令来获取超级 POM 的默认配置：

mvn help:effective-pom

超级 POM 是 Maven 安装的一部分，可以在 $M2_HOME/lib 下的 maven-x.y.z-uber.jar 或 maven-model-builder-x.y.z.jar 文件中找到，其中 x.y.z 表示版本。在相应的 JAR 文件中，org.apache.maven.model 包下有一个名为 pom-4.0.0.xml 的文件。

在示例项目中继承的超级 POM 的默认配置如下；为了简洁起见，仅展示了某些重要方面：

<!--General project Information --><modelVersion>4.0.0</modelVersion><groupId>com.packt.mvneclipse</groupId><artifactId>hello-project</artifactId><version>0.0.1-SNAPSHOT</version><name>hello-project</name><url>http://maven.apache.org</url><properties>1<project.build.sourceEncoding>UTF8</project.build.sourceEncoding>
</properties><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><!-- Build source directory and details><build>
…<sourceDirectory> ...</sourceDirectory><scriptSourceDirectory>..</scriptSourceDirectory><testOutputDirectory>..</testOutputDirectory><outputDirectory>...<outputDirectory>
…<finalName>hello-project-0.0.1-SNAPSHOT</finalName><pluginManagement><plugins><plugin><artifactId>maven-antrun-plugin</artifactId><version>1.3</version></plugin><plugin><artifactId>maven-assembly-plugin</artifactId><version>2.2-beta-5</version></plugin><plugin><artifactId>maven-dependency-plugin</artifactId><version>2.1</version></plugin><plugin><artifactId>maven-release-plugin</artifactId><version>2.0</version></plugin></plugins></pluginManagement><plugins><!-- Plugins, phases and goals --><plugin><artifactId>maven-clean-plugin</artifactId><version>2.4.1</version><executions><execution><id>default-clean</id><phase>clean</phase><goals><goal>clean</goal></goals></execution></executions></plugin><plugin><artifactId>maven-surefire-plugin</artifactId><version>2.7.2</version><executions><execution><id>default-test</id><phase>test</phase><goals><goal>test</goal></goals></execution></executions></plugin><plugin><artifactId>maven-compiler-plugin</artifactId><version>2.3.2</version><executions><execution><id>default-testCompile</id><phase>test-compile</phase><goals><goal>testCompile</goal></goals></execution><execution><id>default-compile</id><phase>compile</phase><goals><goal>compile</goal></goals></execution></executions></plugin><plugin><artifactId>maven-jar-plugin</artifactId><version>2.3.1</version><executions><execution><id>default-jar</id><phase>package</phase><goals><goal>jar</goal></goals></execution></executions></plugin><plugin><artifactId>maven-deploy-plugin</artifactId><version>2.5</version><executions><execution><id>default-deploy</id><phase>deploy</phase><goals><goal>deploy</goal></goals></execution></executions></plugin><plugin><artifactId>maven-site-plugin</artifactId><version>2.0.1</version><executions><execution><id>default-site</id><phase>site</phase><goals><goal>site</goal></goals><configuration></project>

Maven 项目构建架构

以下图展示了 Maven 项目的常见构建架构。本质上，每个 Maven 项目都包含一个 POM 文件，该文件定义了项目的所有基本方面。Maven 使用 POM 的详细信息来决定不同的操作和工件生成。指定的依赖项首先在本地仓库中搜索，然后是在中央仓库中。还有一个概念，如果 POM 中指定了远程仓库，则会搜索远程仓库。我们将在下一节中讨论仓库。此外，POM 定义了在生成站点时要包含的详细信息。

看看以下图：

其他基本概念

Maven 的其他基本概念将在以下章节中讨论。

仓库

Maven 仓库是可访问的位置，用于存储 Maven 构建产生的工件。更准确地说，仓库是一个用于存储项目工件的位置，它被设计成与 Maven 坐标匹配。

Maven 仓库可以是以下类型之一：

• 本地

• 中央

• 远程

本地仓库

本地仓库是位于 Maven 构建运行的同一台机器上的仓库。它是用户机器的 $USER_HOME 目录中的一个 .m2 文件夹。当第一次运行 mvn 命令时创建。然而，要覆盖默认位置，如果存在，请打开 settings.xml 文件；否则，在 $M2_HOME\conf (对于 Windows: %M2_HOME%\conf) 文件夹中创建一个，并按照以下代码中的相应位置：

<settings xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0http://maven.apache.org/xsd/settings-1.0.0.xsd"><localRepository>/opt/m2repos</localRepository>
</settings>

当我们运行 Maven 命令时，Maven 会将依赖项下载到自定义路径。

中央仓库

中央仓库是由 Maven 社区提供的仓库。它包含了一个大型常用库的仓库。当 Maven 在本地仓库中找不到库时，该仓库就会发挥作用。中央仓库可以在以下位置找到：search.maven.org/#browse。

远程仓库

企业通常维护自己的仓库，用于存储项目中使用的库。这些仓库与本地仓库不同；仓库是在一个独立的服务器上维护的，不同于开发者的机器，并且可以在组织内部访问。此外，有时中央仓库中库的可用性不确定，因此产生了对远程仓库的需求。

例如，以下 POM 文件提到了远程仓库，其中依赖项在中央仓库中不可用：

<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.packt.mvneclipse</groupId><artifactId>hello-project</artifactId><version>1.0</version><dependencies><dependency><groupId>com.packt.commons</groupId><artifactId>utility-lib</artifactId><version>1.0.0</version></dependency><dependencies><repositories><repository><id>packt.ser1</id><url>http://download.packt.net/maven2/1</url></repository><repository><id>packt.ser2</id><url>http://download.packt.net/maven2/2</url></repository></repositories>
</project>

仓库中的搜索顺序

以下图说明了在执行 Maven 构建时在仓库中执行搜索操作的顺序：

Maven 按照以下顺序在仓库中搜索依赖库，顺序如下所述：

1. 在步骤 1 中，Maven 在本地仓库中搜索依赖项；如果找到，则继续进行，否则它将转到中央仓库。

2. 在步骤 2 中，搜索继续在中央仓库中进行；如果找到，它将下载依赖库到本地仓库并继续处理。如果在中央仓库中搜索失败，并且 POM 文件中提到了远程仓库，它将继续进行步骤 3，否则抛出错误并停止。

3. 在步骤 3 中，搜索继续在远程仓库中进行。如果找到，它将下载依赖库到本地仓库并继续处理。如果搜索遇到失败，它将抛出错误并在该处停止。

项目依赖

Maven 的强大功能是其对任何项目的依赖项管理。依赖项可能是外部库或内部（内部）库/项目。POM 中的依赖项可以以下列标签和以下属性进行声明，如下所示：

<dependencies><dependency><groupId>org.testng </groupId><artifactId>testng</artifactId><version>6.1.1</version><type>jar</type><scope>test</scope><optional>true</optional></dependency>
...</dependencies>

`groupId`, `artifactId`, and `version`: These are the Maven coordinates for dependency.`type`: This is a dependency packaging type. The default type is JAR. We have already discussed this in an earlier section.`scope`: This provides a mechanism of control over the inclusion of dependencies in the class path and with an application. We will talk about this scope in the next section.`optional`: This indicates the dependency as optional when the project is a dependency. To put this in simple terms, consider that project A has the `optional` dependency, which means it needs this library at build time. Now, project B has this project A that is dependency defined, so this implies B may not need A's dependency for its build and is a part of transitive dependencies.

依赖项范围

依赖项范围控制类路径中依赖项的可用性，并与应用程序一起打包。有六个依赖项范围，以下详细描述如下：

• Compile：如果没有指定，这是默认范围。具有此范围的依赖项在所有类路径中可用，并且被打包。

• Provided：与 compile 范围类似，但表示 JDK 或容器提供它们。它仅在编译和测试类路径中可用，并且不是传递的。

• Runtime：此范围表示依赖项在编译时不需要，但在执行时可用。例如，JDBC 驱动程序仅在运行时需要，然而 JDBC API 在编译时需要。

• Test：此范围表示依赖项对于应用程序的正常使用不是必需的，并且它仅在测试编译和执行阶段可用。

• System：这与 provided 范围类似，但明确指出了本地文件系统上 JAR 的路径。路径必须是绝对路径，例如 $JAVA_HOME/lib。Maven 不会检查仓库；相反，它将检查文件的存在。

传递依赖

项目 A 依赖于项目 B，而项目 B 依赖于 C——现在 C 是 A 的传递依赖。Maven 的优势在于它可以处理传递依赖，并从开发者的知识中隐藏依赖链。作为开发者，项目的直接依赖被定义，而所有其他依赖链的麻烦都由 Maven 通过有效的版本冲突管理来处理。范围限制依赖项的传递性，如前所述，通过允许包含适合构建当前阶段的依赖项。

更多信息，请访问maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html。

以下图示说明了传递依赖关系：

插件和目标

Maven 本质上是一个插件框架，其中每个动作都是某个插件的结果。每个插件由目标（也称为 Mojos）组成，这些目标定义了要执行的操作。简单来说，目标是工作单元。例如，compiler插件有compile作为目标，用于编译项目的源代码。以下是一个示例：

带有目标集的插件可以使用以下命令执行：

mvn [pluginID:goalID]

通常，以下是一些插件类型：

类型	描述
构建插件	这些插件在构建期间执行，并在pom文件中的<build> <build/>元素中指定。
报告插件	这些插件在站点生成期间执行，并在pom文件中的<reporting> <reporting/>元素中配置。
核心插件	这些插件对应于默认的核心阶段。
打包类型/工具	这些与相应的打包工件类型相关。

以下表格包含了一些常见的插件：

插件	描述
compiler	这用于编译源代码。
jar	这将从项目构建jar文件。
war	这将从项目构建war文件。
install	这将构建工件安装到本地仓库。
site	这将为当前项目生成站点。
surefire	这将运行单元测试并生成报告。
clean	这将在构建后清理目标。
javadoc	这将为项目生成 Javadoc。
pdf	这将为项目文档生成 PDF 版本。

更多插件，请访问maven.apache.org/plugins/。

站点生成和报告

很少有项目是单个开发者的资产。一个项目包含利益相关者，并且他们之间的协作是必不可少的。通常，缺乏有效的文档会使项目、其维护和其使用陷入瘫痪。Maven 及其site插件通过生成与项目相关的站点和报告，简化了拥有有效项目文档的过程。可以使用以下命令生成站点：

mvn site

网站生成在target/site目录下。Maven 使用 Doxia 组件（在第一章的Maven 组件架构部分中讨论），Apache Maven – 简介 和 安装来生成文档。网站还包含所有配置的报告，如单元测试覆盖率、PMD 报告等。我们将在第五章的生成网站文档部分中更详细地介绍网站和报告的生成，Spicing Up a Maven Project。

创建 Maven 项目

m2eclipse 使创建 Maven 项目变得简单。Maven 项目可以通过以下两种方式创建：

• 使用原型

• 不使用原型

现在，我们将讨论如何使用这些方法创建项目。

使用原型

原型是一个插件，允许用户使用称为原型的定义模板创建 Maven 项目。不同类型的项目有不同的原型。

原型主要用于创建以下内容：

• Maven 插件

• 简单的 Web 应用程序

• 简单项目

我们现在将看到如何使用原型创建一个简单的 Hello World! 项目：

1. 导航到文件 | 新建并点击其他。项目向导出现并展开Maven文件夹。如图所示选择Maven 项目并点击下一步：

2. 新 Maven 项目向导出现。使用默认的工作空间，并如图所示点击下一步：

3. 选择一个原型向导出现。这显示了 Maven 仓库中可用的原型列表。可以通过添加原型按钮添加新的原型。在我们的案例中，让我们选择如图所示的maven-archetype-quickstart并点击下一步：

4. 出现一个指定 Maven 坐标的向导。请在以下表格中填写截图后的详细信息，并点击完成：

   字段	值
   组 ID	com.packt.mvneclipse
   工件 ID	hello-project
   版本	默认 – 0.0.1-SNAPSHOT
   包名	com.packt.mvneclipse.hello

   

现在已经创建了一个示例 Maven 项目，它包含一个打印Hello World!的 Java 文件。项目具有以下结构：

不使用原型

您可以使用以下步骤不使用原型创建 Maven 项目：

1. 导航到文件 | 新建并点击其他。项目向导出现并展开Maven文件夹。选择Maven 项目并点击下一步。

2. 新建 Maven 项目向导出现。使用默认工作区并勾选以下截图所示的跳过原型复选框，然后点击下一步：

3. 出现指定 Maven 坐标的向导。请填写以下截图所示的详细信息，然后点击完成：

4. 将创建一个骨架结构，如以下截图所示，我们将根据我们构建的应用程序类型对其进行自定义：

检出 Maven 项目

检出 Maven 项目意味着从源代码版本控制系统检出。在我们处理之前，我们需要确保我们已安装了计划使用的相应 SCM 的 Maven 连接器。使用以下步骤检出 Maven 项目：

1. 在 Mac 上导航到Eclipse | 首选项，在其他操作系统上则导航到Windows | 首选项搜索，并搜索Maven，展开它，然后点击发现。

2. 然后，点击打开目录。这列出了市场上所有可用的 m2connectors。在我们的例子中，我们将使用 SVN，因此选择m2-Subversive，如以下截图所示，然后点击完成。在接下来的屏幕上，点击下一步，接受许可协议，最后点击完成以安装它。同样，我们可以选择我们打算用于 SCM 的任何连接器。

3. 就像创建项目一样，导航到文件 | 新建，然后点击其他。出现项目向导。展开 Maven 文件夹。点击从 SCM 检出 Maven 项目，然后点击下一步。

4. 在下一个屏幕上，选择 SCM 连接器SVN并提供相应的 SVN URL，如以下截图所示，然后点击完成。如果您点击下一步，它将显示仓库结构。

导入 Maven 项目

导入 Maven 项目就像导入任何其他 Java 项目一样。导入 Maven 项目的步骤如下：

1. 从文件菜单中，点击导入。选择导入，出现一个源窗口，展开Maven，然后点击现有 Maven 项目，如以下截图所示：

2. 在下一个向导中，我们必须选择 Maven 项目的位置。使用浏览...按钮导航到相应的位置，然后点击完成以完成导入，如以下截图所示；项目将被导入到工作区：

摘要

恭喜！在本章中，你了解了 Maven 项目的结构、POM 文件、Maven 领域的其他基本概念，最后你学习了如何创建和导入 Maven 项目。如需更多信息，你可以参考 Tim O'Brien 所著的 Maven: The Complete Reference，由 Sonatype, Inc. 出版，以及 Apache Maven 网站。在下一章中，我们将探讨构建周期，你将学习如何运行 Maven 项目。

第四章。构建和运行项目

恭喜！你已经完成了这本书的一半。正如前面章节所讨论的，Maven 遵循约定优于配置；这意味着有一个默认的构建机制。构建机制，通常称为构建生命周期，形成了一系列步骤，这些步骤在阶段（也称为阶段）中分组。每个阶段都伴随着一组目标，这些目标定义了任务的单元。在本章中，我们将探讨三个标准生命周期——清理、默认和站点——并熟悉其他常见生命周期。你还将了解如何构建和运行在第三章中创建的hello-project，即创建和导入项目。本章包括以下部分：

• 构建生命周期

  • 默认生命周期

  • 清理生命周期

  • 站点生命周期

• 包特定生命周期

• Maven 控制台

• 构建和打包项目

• 运行 hello-project

构建生命周期

构建 Maven 项目会导致在阶段中分组的目标执行。尽管 Maven 有一个默认的构建周期，但它可以根据我们的需求进行自定义；这就是 Maven 所继承的美。为了确定这一点，了解构建的生命周期是至关重要的。本质上，以下是在 Maven 中的三个标准生命周期：

• 默认

• 清理

• 站点

默认生命周期

默认生命周期处理项目的构建和部署。它是 Maven 的主要生命周期，也称为构建生命周期。一般来说，它为 Java 应用程序提供构建过程模型。默认生命周期有 23 个阶段，从验证开始，以部署结束。有关所有 23 个阶段的详细信息，请参阅maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html#Lifecycle_Reference。

然而，在这里我们将看到一些阶段以及与常见应用程序开发相关的默认目标，这些目标如下：

生命周期阶段	描述	插件：目标
验证	这验证项目是否正确，并包含执行构建操作所需的所有必要信息	-
编译	这将编译源代码	compiler:compile
测试编译	这将在测试目标目录中编译测试源代码	compiler:testCompile
测试	使用在pom文件中配置的合适的单元测试框架运行测试	surefire:test
打包	这将编译后的源代码打包到相应的可分发格式，如 JAR、WAR、EAR 等	jar:jar（用于 JAR 打包）
安装	这将在本地仓库中安装包，它可以作为其他项目的依赖项	install:install
deploy	此操作将最终包复制到远程仓库，以便与其他开发者和项目共享	deploy:deploy

清洁生命周期

清洁生命周期是 Maven 中最简单的生命周期，它由以下阶段组成：

• pre-clean：此阶段在项目清理前执行所需的过程

• clean：此阶段删除由早期 build (即 target 目录) 生成的所有文件

• post-clean：此阶段在项目清理后执行所需的过程

在这些阶段中，引起我们兴趣的是 clean 阶段。Maven 的 "clean:clean" 目标绑定到清洁阶段。它清理项目的 build (通常是 target) 目录。执行任何阶段都会导致执行该阶段及其之前的所有阶段，例如，调用清洁阶段会执行第一个 pre-clean 阶段然后是清洁阶段；同样，调用 post-clean 会导致调用 pre-clean、clean 和 post-clean 阶段。以下图表说明了清洁生命周期阶段的执行（参考：Apache Maven 网站）：

我们可以将其他目标绑定到清洁生命周期的阶段。假设我们想在预清洁阶段输出一些消息；我们可以通过将 maven-antrun-plugin:run 目标绑定到该阶段来实现，如下所示：

</project>...........
<build><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-antrun-plugin</artifactId><executions><execution><id>precleanid</id><phase>pre-clean</phase><goals><goal>run</goal></goals><configuration><tasks><echo>Hello am in pre-clean phase</echo></tasks></configuration></execution>

站点生命周期

站点生命周期处理项目站点文档的创建。站点生命周期的阶段如下图所示：

以下表格描述了站点生命周期阶段按执行顺序。 (参考：Apache Maven 网站)

阶段	描述
pre-site	此阶段在生成项目站点之前执行所需的过程。
site	此阶段生成项目站点的文档
post-site	此阶段在生成站点后执行所需的过程，并为站点部署做准备
site-deploy	此阶段将生成的站点文档部署到指定的 Web 服务器

执行任何阶段都会导致执行该阶段及其之前的所有阶段。例如，调用 post-site 会执行 pre-site、site 和 post-site 阶段。类似于清洁生命周期，我们可以在站点的生命周期中绑定其他目标。

包特定的生命周期

每种打包类型都有自己的默认目标。JAR 打包的默认目标与 WAR 打包不同。Maven 为以下内置打包类型提供生命周期：

• JAR

• WAR

• EAR

• POM

• EJB

• Maven 插件

这里描述了 WAR 打包的生命周期和目标绑定。对于其他打包的生命周期和目标绑定，请参阅 maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html#Built-in_Lifecycle_Bindings。

阶段	插件目标
处理资源	resources:resources
编译	compiler:compile
处理测试资源	resources:testResources
测试编译	compiler:testCompile
测试	surefire:test
打包	war:war
安装	install:install
部署	deploy:deploy

Maven 控制台

在我们动手构建和执行 Maven 项目之前，我们需要启用 Maven 控制台。可以通过以下步骤启用 Maven 控制台：

1. 导航到 窗口 | 显示视图 | 控制台。这显示了控制台视图。

2. 接下来，点击以下屏幕中所示的 打开控制台 小箭头，然后点击 Maven 控制台：

Maven 控制台显示了 Maven 构建过程的全部输出。它显示了 Maven 处理的所有详细信息，这对于了解底层发生的事情非常有帮助，您还可以看到调试信息。

构建 和打包项目

构建 和打包 Maven 项目需要执行所需阶段，我们已在前面章节中讨论过。让我们从 第三章，创建和导入项目，其中我们使用原型生成，构建和打包 hello-project。在 默认生命周期 部分，打包阶段按以下顺序执行以下阶段：编译、测试和打包阶段。现在，我们将看到如何从 m2eclipse 调用打包阶段。以下步骤将确保这一点：

1. 右键点击 hello-project 并选择 运行。点击 运行配置，运行配置 窗口将出现。

2. 右键点击 Maven 构建 并选择 新建，如图所示：

3. 一旦出现启动配置窗口，填写如图所示的详细信息。对于 基本目录，点击 浏览工作区... 并从弹出列表中选择 hello-project：

4. 接下来，点击 应用 并使用 关闭 按钮关闭它。

5. 再次右键点击项目并选择 运行，然后点击 Maven 构建，如图所示：

6. 将出现一个窗口，如图所示，其中包含所有可用的运行配置：

7. 选择 hello-package 启动配置并点击 确定。它应该编译、运行测试、生成站点文档并在 target 目录中打包，如图所示：

运行 hello-project

由于上一章中的 hello-project 是一个 Java 应用程序，运行它与其他 Java 应用程序类似。右键单击项目，选择运行方式，然后点击Java 应用程序，选择主 JAVA 类，并点击确定。它将在控制台打印 Hello World!。

运行一个 Web 应用程序需要一些额外的步骤，我们将在第五章，为 Maven 项目增色中讨论这些步骤。

摘要

在本章中，你学习了 Maven 项目的清洁、站点和默认构建生命周期，并随后使用这些知识使应用程序打包和运行。

在下一章中，我们将构建一个 Web 应用程序，你将学习如何自定义 pom 文件以满足我们的需求。

第五章.为 Maven 项目增色

到目前为止，我们已经构建了基础，现在我们终于准备好发射火箭了。火箭！激动人心，不是吗？让我们将前几章的知识付诸实践；我们将使用 Maven 创建一个简单的 Web 应用程序，MyDistance，它允许用户在不同单位之间转换距离。在构建此应用程序的过程中，我们还将学习如何自定义项目信息并生成不同的工件。本章将涵盖以下主题：

• 创建 MyDistance 项目

• 修改项目信息

• 添加依赖项

• 添加资源

• 应用程序代码

  • 添加表单以获取输入

  • 添加 servlet

  • 添加实用类

• 运行应用程序

• 编写单元测试

• 运行单元测试

• 生成站点文档

• 生成单元测试—HTML 报告

• 生成 javadoc

创建 MyDistance 项目

要创建MyDistance应用程序，我们需要执行以下步骤：

1. 从菜单中，导航到文件 | 新建 | 其他...。出现一个新的项目向导窗口。在文本框中搜索maven，选择Maven 项目，然后点击下一步按钮，如下截图所示：

2. 出现了一个新 Maven 项目向导；选中使用默认工作区位置复选框，并确保创建简单项目（跳过存档选择）复选框未选中，如下截图所示：

3. 接下来，从新存档向导中选择一个存档。由于我们正在构建 Web 应用程序，在过滤器中搜索webapp，选择maven-archetype-webapp，然后点击下一步，如下截图所示：

4. 使用以下值指定 Maven 坐标，也称为技术术语中的组-工件-版本（GAV），然后点击完成：

   字段	值
   组 ID	com.packt.mvneclipse
   工件 ID	MyDistance
   版本	0.0.1-SNAPSHOT
   包名	com.packt.chpt5.mydistance

   执行上一步操作后，您的屏幕将显示如下截图：

   

   注意

   Maven 中的快照表示当前的开发副本，即代码的当前快照。Maven 在配置的间隔内，默认为 24 小时，在远程仓库中检查新的 SNAPSHOT 版本。有关 Maven 版本的更多信息，请参阅docs.oracle.com/middleware/1212/core/MAVEN/maven_version.htm。

5. Web 应用程序骨架将被创建，其结构如下截图所示：

如果您看到表示项目中有错误的红色交叉，请不要担心；我们将在即将到来的应用程序代码部分中了解更多关于它的信息。

修改项目信息

在我们深入代码的更多细节之前，让我们自定义项目信息。让我们添加有关组织、许可证和与之相关的开发者的信息。为此，让我们打开pom文件并添加以下代码：

<project >
…....<!-- Organization information --><organization> <name>Packt Publishing</name><url>www.packtpub.com</url></organization> <!-- License information  --><licenses><license><name>Apache 2</name><url>http://www.apache.org/licenses/LICENSE-2.0.txt</url><distribution>manual</distribution><comments>A Friendly license</comments></license></licenses><!-- Developers Information --><developers><developer><id>foo</id><name>Foo foo</name><email>foo@foo.com</email><url>http://www.foofoo.net</url><organization>Packt</organization><organizationUrl>http://packtpub.com</organizationUrl><roles><role>developer</role></roles><timezone>-8</timezone></developer></developers>
.......
</project>

注意

有关 Maven 模型的详细信息，请访问maven.apache.org/ref/3.2.1/maven-model/maven.html。

添加依赖项

我们的项目是一个简单的 Web 应用程序，为了开始，它将需要 JUnit 作为测试的依赖项，以及log4j用于日志记录。随着我们进一步进展，我们将逐步添加更多依赖项；本节的想法是展示如何在pom文件中添加依赖项。如果我们查看我们的pom文件，我们可以看到 JUnit 已经作为依赖项存在；因此，让我们通过添加以下代码片段将log4j作为依赖项添加：

<project>
…....
<dependencies>
…
<!-- For logging purpose --><dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.17</version></dependency>
</dependencies>
…....
</project>

完整的pom文件将如下所示：

<project  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.packt.mvneclipse</groupId><artifactId>MyDistance</artifactId><packaging>war</packaging><version>0.0.1-SNAPSHOT</version><name>MyDistance Maven Webapp</name><url>http://maven.apache.org</url><!-- Organization information --><organization><name>Packt Publishing</name><url>www.packtpub.com</url></organization><!-- License information  --><licenses><license><name>Apache 2</name><url>http://www.apache.org/licenses/LICENSE-2.0.txt</url><distribution>manual</distribution><comments>A Friendly license</comments></license></licenses><!-- Developers Information --><developers><developer><id>foo</id><name>Foo foo</name><email>foo@foo.com</email><url>http://www.foofoo.net</url><organization>Packt</organization><organizationUrl>http://packtpub.com</organizationUrl><roles><role>developer</role></roles><timezone>-8</timezone></developer></developers><dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>3.8.1</version><scope>test</scope></dependency><!-- For logging purpose --><dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.17</version></dependency></dependencies><build><finalName>MyDistance</finalName></build>
</project>

添加资源

我们将使用log4j将日志记录到文件或控制台。log4j通过log4j属性文件进行配置。现在让我们创建属性文件。为此，导航到src/main/resources，右键单击资源并选择新建 | 其他...；出现一个新向导。在过滤器部分搜索file，选择文件，然后点击下一步，如下面的截图所示：

接下来，出现一个文件资源窗口；输入文件名为log4j.properties，并确保父文件夹是MyDistance/src/main/resources，然后点击完成，如下面的截图所示：

注意

资源放置在src/main/resources文件夹中。

一旦文件创建完成，请添加以下代码片段来设置log4j的不同属性。它将模式布局附加到控制台以分割信息，并将日志写入Mydistance.log文件，并设置为DEBUG级别，如下面的代码所示：

#log4j Properties log4j.rootLogger=DEBUG, consoleAppender, fileAppenderlog4j.appender.consoleAppender=org.apache.log4j.ConsoleAppenderlog4j.appender.consoleAppender.layout=org.apache.log4j.PatternLayoutlog4j.appender.consoleAppender.layout.ConversionPattern=[%t] %-5p  %c{1} %x - %m%nlog4j.appender.fileAppender=org.apache.log4j.RollingFileAppenderlog4j.appender.fileAppender.layout=org.apache.log4j.PatternLayoutlog4j.appender.fileAppender.layout.ConversionPattern=[%t] %-5p  %c{1} %x - %m%nlog4j.appender.fileAppender.File=Mydistance.log

有关log4j的更多信息，请参阅logging.apache.org/log4j/1.2/。

应用程序代码

应用程序故意创建在 JSP 或 servlets 中，以保持简单并避免熟悉其他框架来理解示例。在我们深入研究应用程序代码的基本知识之前，让我们解决在创建 MyDistance 项目部分的第 5 步中 Eclipse 抱怨的错误。在pom文件中添加以下依赖项，错误应该会消失：

<!-- Include servlet  API --><dependency><groupId>javax.servlet</groupId><artifactId>javax.servlet-api</artifactId><version>3.1.0</version><scope>provided</scope></dependency>

在添加 Servlet部分稍后编写 servlet 时，也需要这个依赖项。

注意

范围已提供，这意味着容器将提供此依赖项，Maven 不会将其包含在此项目的输出或 war 文件中。我们已在第四章中更详细地讨论了范围，构建和运行项目。

应用程序将需要以下附加文件：

• index.jsp：这是一个带有表单的 JSP 文件，允许用户输入距离、其单位和所需的转换单位

• DistanceServlet：这是一个处理表单输入的 servlet

• ConversionUtil：这是一个实用工具类，它有一个方法用于在不同单位之间进行转换

添加获取输入的表单

在src/main/webapp下打开index.jsp文件，并添加以下代码以获取距离、其单位和转换单位作为输入。表单包括一个输入框、两个单选按钮用于选择单位以及一个按钮来启动转换，如下面的代码所示：

<body>
<h2>MyDistance Utility</h2><form><table><tr><td><input type="text" id="mydistance" name='distance' placeholder="My Distance In"></td><td> <input type="radio" name="distin" id="distin" value="km">KM<br><input type="radio" name="distin" id="distin" value="m">Metre</td></tr><tr></tr><tr></tr><tr></tr><tr> <td> <label for="convert">Convert To</label></td><td> <input type="radio" name="convertto" id="convertto" value="yd">Yard<br><input type="radio" name="convertto" id="convertto" value="mi">Miles</td></tr><tr><td><input type="button" id="submit" value='Convert'></td></tr></table><div id="convertvalue"> </div></form>
</body>

如果愿意，你可以添加 CSS 样式来使 UI 更加美观。前面的裸骨文件会产生类似以下的结果：

我们想使用 Ajax（jQuery Ajax）计算值并在其下方显示相应的结果。为此，添加以下代码片段：

<head><script src="img/jquery-latest.js"></script><script>$(document).ready(function() {$('#submit').click(function(event) {var mydistance=$('#mydistance').val();var mydistanceIn=$('[name=distin]:checked').val();var convertTo=$('[name=convertto]:checked').val();if(mydistanceIn==convertTo){alert("Cannot have same unit");return false;}console.log(mydistance+mydistanceIn+convertTo);$.get('mydistance',{distance:mydistance,distIn:mydistanceIn,convert:convertTo},function(responseText) { $('#convertvalue').text(responseText);});});});</script>
</head>

添加 servlet

在添加任何 Java 文件之前，在src/main下创建一个名为java的文件夹，因为 Maven 会在该目录中查找 Java 文件（所有 Java 文件都应该位于其中）。在com.packt.chpt5.mydistance包中添加DistanceServlet servlet。servlet 获取请求参数，提取它，并调用实用工具类中的相应转换方法。servlet 看起来如下所示：

public class DistanceServlet extends HttpServlet {private static final long serialVersionUID = 1L;static Logger log=Logger.getLogger(DistanceServlet.class);public void doGet(HttpServletRequest req, HttpServletResponse resp)throws ServletException, IOException {double convertVal = 0;double distanceProvided =Double.parseDouble(req.getParameter("distance"));String distanceIn=req.getParameter("distIn");String convertTo=req.getParameter("convert");log.debug("Request Parameters ==>"+"Distance-"+distanceProvided+distanceIn+" Conversion Unit- "+convertTo );ConversionUtil conversion= new ConversionUtil();if(distanceIn.equals("km") && convertTo.equals("yd")){convertVal=conversion.convertkmToYard(distanceProvided);}if(distanceIn.equals("m") && convertTo.equals("yd")){convertVal=conversion.convertMtoYard(distanceProvided);}if(distanceIn.equals("km") && convertTo.equals("mi")){convertVal=conversion.convertKMToMile(distanceProvided);}if(distanceIn.equals("m") && convertTo.equals("mi")){convertVal=conversion.convertMToMile(distanceProvided);}resp.setContentType("text/html");PrintWriter out = resp.getWriter();out.print("The converted value is "+convertVal);out.flush();out.close();}}

在src/main/webapp/WEB-INF下的web.xml文件中添加以下行：

<web-app><display-name>MyDistance Calculator</display-name><servlet><servlet-name>mydistance</servlet-name><servlet-class>com.packt.chpt5.mydistance.DistanceServlet</servlet-class><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>mydistance</servlet-name> <url-pattern>/mydistance</url-pattern></servlet-mapping>
</web-app>

添加实用工具类

在com.packt.chpt5.mydistance.util包中添加一个名为ConversionUtil的实用工具类。实用工具类包含执行不同距离单位转换的方法。将以下代码添加到实用工具类中：

public double convertKMToMile(double distance){return (distance*0.62137);
}
public double convertkmToYard(double distance){return distance*1093.6;
}public double convertMToMile(double distance){return (distance/1000)*0.62137 ;
}
public double convertMtoYard(double distance){return (distance/1000)*1093.6;
}

运行应用程序

现在我们已经完成了编码。让我们运行代码并看看它的工作情况。该项目是一个 Web 应用程序，因此它需要一个 servlet 容器来运行。我们将在这里使用 Tomcat 容器。为 Tomcat 添加以下构建插件，该插件可以从 Maven 中实际托管 Tomcat 实例，无需安装：

    <build>
….<plugins><plugin><groupId>org.apache.tomcat.maven</groupId><artifactId>tomcat7-maven-plugin</artifactId><version>2.1</version></plugin></plugins></build>

这将从存储库下载所有依赖项。下载完成后，右键单击项目，选择运行方式 | 运行配置...，在配置窗口中创建配置，指定目标为tomcat7:run，然后单击运行，如图所示：

注意

Tomcat 插件具有run目标，它编译并运行应用程序。

同样，我们可以在任何其他容器中添加任何其他容器并运行应用程序。运行的应用程序将在http://localhost:8080/MyDistance/处可用，如下面的截图所示（显示了一个示例转换）：

编写单元测试

编写单元测试是软件开发中的良好实践的一部分。Maven 的test阶段执行单元测试并生成相应的报告。在本节中，我们将学习如何为我们的实用工具类ConversionUtil编写简单的单元测试，在下一节中，我们将看到如何执行它并生成报告。

所有单元测试类都应该放在src/test/java下。在MyDistance项目中创建相应的文件夹。一旦文件夹就位，右键单击它并导航到新建 | 其他...。一旦出现向导窗口，在过滤器部分输入junit，选择JUnit 测试用例，然后点击下一步，如下面的截图所示：

在接下来的窗口中，通过填写以下详细信息来定义单元测试类，然后点击下一步，如下面的截图所示：

字段	值
源文件夹	MyDistance/src/test/java
包	com.packt.chpt5.mydistance.util
名称	ConvertionUtilTest
测试中的类	com.packt.chpt5.mydistance.util.ConversionUtil

将显示一个选择测试方法的窗口，将生成如下截图所示的存根。确保ConversionUtil类的所有方法都被选中，然后按照以下方式点击完成：

将生成带有测试方法存根的ConversionUtilTest测试类。按照以下方式编辑类的代码：

private ConversionUtil conversion;@Overrideprotected void setUp() throws Exception {super.setUp();conversion= new ConversionUtil();}public void testConvertKmToMile() {double actual=conversion.convertKMToMile(4);assertEquals(2.48548,actual,0.001);}public void testConvertkmToYard() {double actual=conversion.convertkmToYard(4);assertEquals(4374.45,actual,0.10);}public void testConvertMToMile() {double actual=conversion.convertMToMile(4000);assertEquals(2.48548,actual,0.001);}public void testConvertMtoYard() {double actual=conversion.convertMtoYard(4000);assertEquals(4374.45,actual,0.10);}@Overrideprotected void tearDown() throws Exception {super.tearDown();conversion = null;}

关于 JUnit 测试用例的更多信息，请参阅junit.org/.

运行单元测试

在 Maven 中运行单元测试只需指定测试阶段。要执行上一节中编写的单元测试，右键单击MyDistance项目，选择运行方式，然后点击Maven 测试。它将对类运行单元测试，并在/target/surefire-reports/文件夹中生成报告，如下面的截图所示：

您可以在txt和xml格式中查看单元测试执行的结果。

生成站点文档

Maven 的一个核心特性是它简化了构件和站点文档的生成。要生成站点文档，请在pom文件中添加以下依赖项：

<reporting><plugins><!--  Reporting -document generation --><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-plugin-plugin</artifactId><version>3.3</version></plugin><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-project-info-reports-plugin</artifactId><version>2.7</version></plugin></plugins></reporting>

在添加前面的依赖项后，以站点为目标运行项目，即在运行配置窗口中，将目标指定为site，如下面的截图所示：

点击运行按钮，文档将被生成。Maven 控制台的输出摘录如下所示：

[INFO] Generating "About" report    --- maven-project-info-reports-plugin:2.7
[INFO] Generating "Plugin Management" report    --- maven-project-info-reports-plugin:2.7
[INFO] Generating "Distribution Management" report    --- maven-project-info-reports-plugin:2.7
[INFO] Generating "Dependency Information" report    --- maven-project-info-reports-plugin:2.7
[INFO] Generating "Source Repository" report    --- maven-project-info-reports-plugin:2.7
[INFO] Generating "Mailing Lists" report    --- maven-project-info-reports-plugin:2.7
[INFO] Generating "Issue Tracking" report    --- maven-project-info-reports-plugin:2.7
[INFO] Generating "Continuous Integration" report    --- maven-project-info-reports-plugin:2.7
[INFO] Generating "Project Plugins" report    --- maven-project-info-reports-plugin:2.7
[INFO] Generating "Project License" report    --- maven-project-info-reports-plugin:2.7
[INFO] Generating "Project Team" report    --- maven-project-info-reports-plugin:2.7
[INFO] Generating "Project Summary" report    --- maven-project-info-reports-plugin:2.7
[INFO] Generating "Dependencies" report    --- maven-project-info-reports-plugin:2.7
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

文档将在target/site目录中生成，文件夹的扩展形式如下所示：

每种类型的细节都有一个 HTML 文件，从project-info、project reports、project summary、license、plugin等等，而index.html是链接每个文档的起点。以下截图显示了项目摘要页面：

关于网站和网站插件的更多信息，请参阅maven.apache.org/guides/mini/guide-site.html和maven.apache.org/plugins/maven-site-plugin/。

生成单元测试 - HTML 报告

在上一节中，我们运行了单元测试，结果以txt和xml格式生成。通常，开发者需要生成更易读的报告。实际上，报告应该是网站文档的一部分，以便更好地协作，并在一个地方提供信息。要生成 HTML 报告并将其作为网站文档的一部分，请在pom文件中的reporting元素下作为plugin添加依赖项，如下所示：

<reporting><plugins>
…...
<!-- For HTML test report generation --><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-surefire-report-plugin</artifactId><version>2.17</version></plugin>
…...</plugins>
</reporting>

在上述代码添加后，从上一节运行site阶段。测试报告可以通过在index.html中的导航到项目文档 | 项目报告 | Surefire 报告来获取，如下面的截图所示：

生成 javadoc

我们经常需要生成代码库的 API 文档。拥有 API 文档可以增加协作、理解、迁移，并且知识转移变得方便。要生成 javadoc，请在reporting元素中添加以下依赖项，如下所示：

<reporting><plugins>…...<!-- For Javadoc generation--><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-javadoc-plugin</artifactId><version>2.9.1</version></plugin> </plugins>
</reporting>

在对pom文件进行上述更改后，从上一节运行site阶段。API 将在target/site目录下的apidocs和testapidocs文件夹中生成。这可以在index.html文件中导航，在项目报告标题下，有JavaDocs和测试 JavaDocs标签，以及Surefire-Reports，如下面的截图所示：

摘要

干得好！我们已经开发了MyDistance，一个距离转换实用程序网络应用程序。在开发过程中，我们学习了添加依赖项、编写单元测试、执行它们、生成网站文档以及为它们生成 javadoc。在下一章中，我们将学习关于 Maven 的多模块项目。

第六章：创建多模块项目

现在我们已经发射了火箭，让我们更深入地探索它。在本章中，我们将以前一章的MyDistance应用程序为基础，将其作为一个多模块 Maven 项目进行开发，并学习如何创建多模块项目、构建和运行它们。本章涵盖的主题如下：

• 简介

• 创建父项目—POM

• 创建核心模块

• 创建 webapp 模块

• 构建多模块项目

简介

软件架构将模块化定义为系统组件可能被分离和重新组合的程度。在软件工程中，模块化指的是软件/应用程序可以被划分为多个模块以实现业务目标的程度。模块化提高了可管理和可重用性。随着软件变得越来越复杂，模块化是当务之急。

多模块项目由许多适应模块化的模块组成。一个多模块项目通过一个引用一个或多个.sub模块的父/master POM 来识别。

一个多模块项目由以下内容组成：

• 父项目 POM：这粘合并引用了项目中的所有其他模块

• 模块：这包括服务于应用程序不同功能的子模块，并构成了应用程序

父 POM 是你可以将公共依赖放在一个地方，并让其他模块继承它的地方，即模块的 POM 继承。通常，JUnit 或 log4j 这样的通用依赖是 POM 继承的候选者。

Maven 处理多模块项目的机制被称为reactor。Maven 核心的 reactor 具有以下功能：

• 收集所有要构建的模块

• 将项目（模块）排序到当前的构建顺序中

• 按顺序构建排序后的项目

项目模块通过指定每个模块的<module> </module>标签被包含在<modules> </modules>标签内。同样，父模块通过指定 Maven 坐标被包含在<parent> </parent>标签内。

现在，为了说明，我们将从第五章的MyDistance应用程序，为 Maven 项目增色，将其作为一个多模块项目进行开发。项目的模块如下：

• Distance-main: 这是父项目，也称为父 POM，它将项目的不同模块（如distance-core和distance-webapp）粘合并引用

• distance-core: 此模块提供了一个简单的距离转换实用工具类

• distance-webapp: 这是一个可以输入依赖于distance-core模块的单位进行转换并响应结果的 Web 界面

在接下来的章节中，我们将深入了解前面的模块。

创建父项目 – POM

建立多模块项目的第一步是设置父 POM。为此，请按照以下步骤操作：

1. 转到文件 | 新建并点击Maven 项目。或者，转到文件 | 新建并点击其他...。在选择向导屏幕中，通过搜索框搜索maven，选择Maven 项目，然后点击下一步按钮，如图所示：

2. 将出现新建 Maven 项目向导；确保勾选复选框创建简单项目（跳过存档选择），如图所示，然后点击下一步：

3. 将出现新建 Maven 项目配置向导；根据截图填写详细信息，然后点击完成：

   确保从下拉菜单中选择打包类型为 POM：

   字段	值
   组 ID	com.packt.mvneclipse
   工件 ID	Distance-main
   版本	0.0.1-SNAPSHOT
   打包	pom

4. 将创建相应的项目，最终屏幕将如下所示：

现在我们已经设置了父 POM。

创建核心模块

MyDistance的核心模块将包含一个可以将不同单位之间的值进行转换的类，即从千米/米到码/英里。让我们将这个核心模块命名为distance-core。要创建核心模块，请执行以下步骤：

1. 转到文件 | 新建并点击其他…。在选择向导屏幕中，通过搜索框搜索maven，选择Maven 模块，然后点击下一步按钮，如图所示：

2. 将出现新建 Maven 模块向导；确保勾选复选框创建简单项目（跳过存档选择），提供模块名称为distance-core，并浏览选择父项目为Distance-main，如图所示：

3. 在配置项目Maven 模块向导中，填写以下截图后的表格中的详细信息，然后点击完成：

   字段	值
   组 ID	com.packt.mvneclipse
   版本	0.0.1-SNAPSHOT
   打包	jar

   由于核心模块仅包含一个 Java 类，并且可以作为应用程序 Web 模块的库使用，因此打包类型为jar。

4. distance-core模块将被创建，POM 的内容将如下所示：

   <project   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><parent><groupId>com.packt.mvneclipse</groupId><artifactId>Distance-main</artifactId><version>0.0.1-SNAPSHOT</version></parent><artifactId>distance-core</artifactId></project>
   

   注意

   请注意，模块的父级被包含在<parent></parent>标签中。此外，对于模块，groupId和version标签将不会出现，因为我们已经在配置 Maven 模块向导中指定了相同的groupId和version。我们在创建模块时在前面的代码中做了这件事。

   在任何时候，如果我们想更改或添加groupId/version/artifactId，我们都可以始终编辑pom.xml文件，因为它是一个 XML 文件。

5. 核心模块由一个执行跨距离单位转换的类文件组成。现在让我们添加一个类；在项目上右键单击，导航到新建，选择包，并指定包名为com.packt.chpt6.mydistance.util。

6. 在前面的包中创建一个名为ConversionUtil的类。如果你还记得，我们在第五章，为 Maven 项目增色中创建了此类。因此，复制此类的全部内容并保存。

7. 现在让我们放置一个单元测试类。在src/test/java中创建一个包，名为com.packt.chpt6.mydistance.util。将类ConversionUtilTest添加到相应的包中。参考第五章，为 Maven 项目增色，其中我们创建了此测试类；复制此类的全部内容并保存。结果src结构将如下所示：创建核心模块

你可能会注意到我们有一些错误，这些错误是由于TestCase类没有被解析。为了解决这个错误，将jUnit作为依赖项添加到父模块，即pom.xml文件中，如下所示：

    <dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>3.8.1</version><scope>test</scope></dependency> 

注意

通常，JUnit 和 log4j 依赖项，即跨模块的通用依赖项，被放置在父 POM 的一个地方，并且模块继承它们。

创建一个名为ConversionUtil的类。

webapp 模块有一个表单的 JSP 文件，用于接受输入。它还有一个接受请求参数并使用核心模块执行转换并提供响应的 servlet。现在让我们通过以下步骤来查看如何放置 webapp 模块：

1. 导航到文件 | 新建，然后点击其他...；在选择向导屏幕中，通过搜索框搜索maven，选择Maven 模块，并点击以下截图所示的下一步按钮：创建 webapp 模块

2. 在接下来的新 Maven 模块窗口中，将模块名称设置为distance-webapp，并浏览选择父模块为Distance-main。创建 webapp 模块

3. 在选择存档类型窗口中，通过搜索框搜索webapp，选择maven-archetype-webapp，然后点击下一步继续，如下所示：创建 webapp 模块

4. 在新建 Maven 模块窗口中，填写以下表格中提供的详细信息，然后单击完成，如下表所示的截图所示：

   字段	值
   Group Id	com.packt.mvneclipse
   版本	0.0.1-SNAPSHOT
   Package	com.packt.chpt6.mydistance

   

5. 将创建 webapp 模块，生成的结构将如下截图所示：

6. 现在如果我们查看父项目的结构，我们可能会注意到它对每个模块都有一个引用，如下面的截图所示：

7. 此外，如果我们注意查看父项目的 pom.xml 文件，我们会看到模块是如何添加到 <module> 标签中的，如下所示：

   <modules><module>distance-core</module><module>distance-webapp</module>
   </modules>
   

8. 打开 webapp 模块的 pom.xml 文件，并添加 log4j、servlet 和 Tomcat 的依赖项，如下所示；这也在第五章，为 Maven 项目添加风味中进行了更详细的讨论：

       <!-- Include servlet  API --><dependency><groupId>javax.servlet</groupId><artifactId>javax.servlet-api</artifactId><version>3.1.0</version><scope>provided</scope></dependency><!-- For logging purpose could be put in parent POM for modules to inherit  --><dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.17</version></dependency><!--  For tomcat  
   <plugins><plugin><groupId>org.apache.tomcat.maven</groupId><artifactId>tomcat7-maven-plugin</artifactId><version>2.1</version></plugin></plugins>
   

9. 此外，由于 webapp 使用它进行转换，因此请添加 distance-core 作为依赖项，如下所示：

     <dependency><groupId>com.packt.mvneclipse</groupId><artifactId>distance-core</artifactId><version>0.0.1-SNAPSHOT</version><scope>compile</scope></dependency>
   

10. 将 log4j.properties 文件添加到 resources 文件夹。请参阅第五章中的添加资源部分，为 Maven 项目添加风味。

11. 添加表单以获取输入并添加 servlet（请参阅第五章中的添加获取输入的表单和添加 Servlet部分，为 Maven 项目添加风味）。

构建多模块项目

现在我们已经完成了模块代码的编写，让我们构建项目。在父项目（在这种情况下为 Distance-main）上右键单击，选择运行，然后单击Maven 测试。这应该会编译并运行单元测试。控制台输出的摘录如下：

[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------------
[INFO] Reactor Build Order:
[INFO] 
[INFO] Distance-main
[INFO] distance-core
[INFO] distance-webapp Maven Webapp
[INFO] 
[INFO] Using the builder org.apache.maven.lifecycle.internal.builder.singlethreaded.SingleThreadedBuilder with a thread count of 1
[INFO] 
[INFO] ------------------------------------------------------------------------
[INFO] Building Distance-main 0.0.1-SNAPSHOT
[INFO] ---------------------------------------------------------
[INFO] ------------------------------------------------------------------------
[INFO] Building distance-core 0.0.1-SNAPSHOT
[INFO] ----------------------------------------------------------
------------------------------------------------------T E S T S
-------------------------------------------------------
Running com.packt.chpt6.mydistance.util.ConversionUtilTest
Tests run: 4, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.009 secResults :Tests run: 4, Failures: 0, Errors: 0, Skipped: 0[INFO] 
[INFO] ------------------------------------------------------------------------
[INFO] Building distance-webapp Maven Webapp 0.0.1-SNAPSHOT
[INFO] ---------------------------------------------------------
[INFO] ------------------------------------------------------------------------
[INFO] Reactor Summary:
[INFO] 
[INFO] Distance-main ..................................... SUCCESS [  0.002 s]
[INFO] distance-core ..................................... SUCCESS [  2.250 s]
[INFO] distance-webapp Maven Webapp ...................... SUCCESS [  0.161 s]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

指称为反应器的机制知道构建项目的顺序。现在再次，在Distance-main上右键单击，选择运行，然后单击Maven install以在本地仓库中安装模块。

注意

如果有任何更改发生，请始终确保通过运行选项运行 Maven clean 来清理项目；或者，您可以使用 Maven install 重新安装项目。

运行应用程序

要运行应用程序，在以下截图中突出显示的父项目的 webapp 模块上右键单击，选择运行，然后单击运行配置...。在运行配置窗口中，指定目标为 tomcat7:run，然后单击运行按钮。Web 应用程序将在 http://localhost:8080/distance-webapp/ 运行；将浏览器指向此位置并执行转换：

摘要

在本章中，我们学习了如何创建一个多模块项目，然后构建和运行应用程序。在下一章中，我们将提前窥视 m2eclipse，并学习如何对其进行自定义。

第七章.一瞥 m2eclipse

我们即将结束这次旅程；现在在这一章中，我们将探讨 m2eclipse 中的其他附加功能，熟悉基于表单的 POM 编辑器，并了解存储库。

本章涵盖的主题如下：

• m2eclipse 中的其他功能

• 基于表单的 POM 编辑器

• 分析项目依赖项

• 与存储库一起工作

• m2eclipse 首选项

m2eclipse 中的其他功能

为了理解 m2eclipse 的其他功能，必须按照以下步骤操作。在 Maven 项目上右键单击，然后导航到Maven菜单项。然后，你可以看到以下截图所示的可用功能：

如果你看到截图，可用的功能如下：

• 添加依赖

• 添加插件

• 新 Maven 模块项目

• 下载 JavaDoc

• 下载源代码

• 更新项目

• 禁用工作空间解析

• 禁用 Maven 属性

同样，在Maven 依赖项上右键单击，然后导航到Maven菜单项。以下截图显示了可见的功能：

可用的功能如下：

• 下载 JavaDoc

• 下载源代码

• 排除 Maven 工件

• 打开 POM

• 打开 JavaDoc

• 从 SCM 导入项目

在接下来的部分中，我们将共同讨论这些功能。

添加依赖

它允许我们向 Maven 项目添加依赖项。以下是这个功能的截图：

到目前为止，我们一直在编辑pom.xml文件并向其中添加依赖项。添加依赖项是使用图形界面实现相同目标的另一种方法。当你使用此选项时，你需要知道的信息更少，也就是说，知道artifactId/groupId就足以在存储库中搜索并选择合适的项。在先前的方法中，你需要知道完整的 Maven 坐标才能添加依赖项；因此，后者是节省时间的方法。

添加插件

与添加依赖类似，添加插件允许你通过图形界面添加插件。这需要我们拥有最少的信息来搜索存储库并添加插件。以下是这个功能的截图：

新 Maven 模块项目

在第六章中，创建多模块项目，我们创建了一个多模块项目并学习了如何创建模块项目。这是调用相同的添加模块向导创建模块的另一种方法。以下是这个窗口的截图，它与导航到新建 | 其他 | Maven 模块并右键单击项目时获得的截图相同（如我们在上一章中看到的）：

下载 JavaDoc

下载 JavaDoc用于将项目（如果存在于中央仓库）的 javadoc 下载到本地仓库。例如，在Maven 依赖项下右键单击log4j-1.2.17.jar文件并单击下载 JavaDoc，如下截图所示。javadoc 将与其他构件一起下载到本地仓库，位于$HOME/.m2/repository/log4j/log4j/1.2.17/作为log4j-1.2.17-javadoc.jar位置：

下载源代码

如果中央仓库有对应项目的源代码构件，我们可以使用此选项将其下载到本地仓库，并在 Eclipse 环境中使用它。这在调试复杂问题时非常有用，尤其是当我们需要深入依赖项的代码时。例如，log4j的源代码将被下载到$HOME/.m2/repository/log4j/log4j/1.2.17/作为log4j-1.2.17-javadoc.jar位置。下载源代码后，右键单击log4j-1.2.17.jar文件并单击属性，如下截图所示：

属性窗口出现；Java 源代码附件导航按钮显示附加源代码位置，如下截图所示：

注意，我们还可以通过在左侧面板上单击Javadoc 位置导航按钮来找到 javadoc 位置。

打开 Javadoc

当我们想要浏览相应项目的 javadoc 时，我们使用此选项。javadoc 作为单独的标签在编辑区域打开，如下截图所示为log4j文档：

打开 POM

在任何时刻，如果需要查看依赖项的 POM 文件，我们可以使用此选项。依赖项的相应 POM 文件在工作区的编辑区域打开。以下截图显示了编辑区域中的log4j POM 文件，这是我们第四章中构建的MyDistance应用程序的依赖项，构建和运行项目：

更新项目

有时候，我们有一个 Java 项目，我们希望将其转换为 Maven 项目。我们可以通过在项目上右键单击，导航到配置|转换为 Maven 项目，并添加 POM 文件来完成此操作。现在，更新项目用于从其依赖项和资源更新项目。如果你在工作区中有多个 Maven 项目，并且项目相互依赖，那么更新项目也非常方便。然后，在你构建（mvn install）一个项目后，你可以在其他项目上执行更新项目以获取新的构件。更新选项如下截图所示：

注意

选择离线将不会检查中央仓库以获取更新。

禁用工作区解析

想象一个场景，项目 A 依赖于项目 B，并且它们位于同一个工作区中，通常在多模块项目中。现在，如果禁用了工作区解析，为了使项目 A 成功构建并且项目 B 的工件在本地仓库中，则需要项目 B。然而，如果启用了工作区解析，依赖项将使用 Eclipse 工作区进行解析，并且不需要本地仓库中的工件。

禁用 Maven 依赖项

它禁用了项目的 Maven 方面，即 Maven 依赖项从构建路径中移除。在这种情况下，我们可能需要从构建窗口手动将 JAR 包包含到类路径中。

从 SCM 导入项目（s）

它允许您将依赖项的源代码拉取到您的 Eclipse 工作区中。换句话说，它允许您基于该依赖项的源代码创建一个新的 Maven 项目。源代码将从定义在依赖项 POM 中的 源代码管理（SCM）系统中拉取。如果依赖项 POM 没有提及 SCM，则此选项不起作用。请确保您已为相应的 SCMs 安装了适当的 m2e 连接器。我们已在 第三章 中讨论了导入和安装 Subversion m2e 连接器，创建和导入项目。

基于表单的 POM 编辑器

m2eclipse 提供了使用基于表单的 POM 编辑器编辑 pom 文件的功能。在早期章节中，我们玩转了 XML 标签并编辑了 pom 文件。在直接编辑 XML 文件时，需要了解标签知识，并且用户很可能犯一些错误。然而，基于表单的编辑器减少了简单错误的可能性，并简化了 pom 文件的编辑，即使没有或只有很少的 XML 知识。我更喜欢玩转 XML 标签并使用该选项，但你可以自由选择你的选项。基于表单的编辑器在以下屏幕截图中显示，并具有五个选项卡：概览、依赖项、依赖项层次结构、有效 POM 和 pom.xml：

概览

概览提供了项目的一般信息。它包括以下部分，并提供了如下所示的信息：

• 工件

• 父级

• 项目

• 模块

• 属性

• 组织

• 源代码管理（SCM）

• 问题管理

• 持续集成

您可以更改此表单中的任何信息，这将反映在 XML 文件中。我们将在下一节讨论 依赖项 和 依赖项层次结构 选项卡。

分析项目依赖

POM 编辑器有一个 依赖项 选项卡，它提供了依赖项的概览以及管理项目依赖项的选项。依赖项 选项卡有两个部分，如下面的屏幕截图所示：

它显示了项目左侧的所有依赖项。我们还可以使用 依赖项 部分的 添加 按钮将依赖项添加到项目中。管理 按钮允许您选择将管理相应依赖项的 POM，以下截图显示了此操作：

如窗口顶部非常清楚地所述，管理的依赖项版本信息将移动到管理它的 POM 中。例如，让我们选择通过 Distance-main POM 来管理 distance-webapp 的 log4j 依赖项。在列表中选择 log4j，然后在右侧列表中选择 Distance-main，并点击以下截图所示的 确定：

在 log4j 文件被管理后，其右侧出现“管理”一词，如下面的截图所示：

如果我们在 XML 文件中看到其效果，我们可以看到来自 distance-webapp POM 的版本信息被移动，并作为依赖项添加到 Distance-main POM 中，如下面的代码所示：

<dependencyManagement><dependencies><dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.17</version></dependency></dependencies>
</dependencyManagement>

实现相同功能的另一种方法是使用右侧的 依赖管理 部分。依赖层次选项卡包含两个部分：依赖层次和已解析依赖项，如下所示：

左侧的 依赖层次 部分提供了依赖项的树视图。树的第一个级别是项目的直接依赖项，然后每个后续级别显示每个依赖项的依赖项。前面的截图是 distance-webapp 模块，其中我们有两个直接依赖项，这些依赖项没有进一步的依赖项，因此树结构不可见。然而，对于大型项目和大型直接依赖项，我们可以轻松地可视化它。jar 图标表示它来自 Maven 仓库，而打开文件夹图标表示它在 Eclipse 工作空间中存在。

右侧的 已解析依赖项 部分显示了所有已解析依赖项的列表，即应用所有冲突和作用域后的结果依赖项。它给出了解析链传播和到达 已解析依赖项 的路线的一般概念。点击任何已解析依赖项，它将在 依赖层次 部分显示依赖链。

关于依赖项的更多信息，请参阅books.sonatype.com/m2eclipse-book/reference/dependencies-sect-analyze-depend.html。

与仓库一起工作

要浏览仓库，请转到 窗口 | 显示视图 并点击以下所示的 其他...：

接下来，出现显示视图窗口。搜索maven repository，如下面的截图所示，然后点击Maven 仓库：

Maven 仓库视图由以下类型组成：

• 本地仓库

• 全局仓库

• 项目仓库

• 自定义仓库

有兴趣的仓库是本地、全局和项目仓库。

本地仓库

它显示了本地仓库的工件，我们可以深入查看其 POM 内容。它还包括 Eclipse 工作空间项目。以下是本地仓库的截图：

全局仓库

它引用中央仓库的工件。我们可以浏览中央仓库的工件并查看其 POM。右键单击全局仓库，它提供了从中央仓库重新索引、构建完整索引、最小索引和更新索引的能力。以下截图显示了全局仓库：

项目仓库

pom.xml file:

<repositories><repository><id>project-based-repository</id><name>Project-specific jars</name><url>file:///${basedir}/libs</url></repository>
<repositories>

通过单击窗口右上角的两个循环箭头刷新Maven 仓库窗口。我们可以在以下方式中看到项目仓库中的相应引用：

m2eclipse 首选项

要打开 m2eclipse 首选项，导航到窗口 | 首选项。在首选项窗口中，在过滤器文本框中搜索maven，如下所示：

Maven

点击下面的截图所示的Maven；它允许我们为 Maven 设置以下选项：

• 离线：此选项不会检查中央仓库的更新

• 调试输出：此选项将 Maven 设置为调试模式

• 下载工件源：此选项将源代码下载到本地仓库，如 JAR

• 下载工件 Javadoc：此选项将 javadoc 下载到本地仓库

• 启动时更新 Maven 项目：此选项更新 Maven 项目的依赖项

• 隐藏物理嵌套模块的文件夹（实验性）：此选项处于实验模式，隐藏多模块项目的嵌套文件夹

发现

发现用于发现可用的 m2e 连接器。请参阅第三章中的检出 Maven 项目部分，创建和导入项目，了解我们如何使用此功能。

原型

原型允许我们添加、删除和编辑 Maven 原型目录，如下面的截图所示：

有关原型的更多信息，请参阅maven.apache.org/archetype/index.html。

用户界面和用户设置

用户界面 允许我们设置 XML 文件选项，如下面的截图所示：

settings.xml 文件包含用于定义配置 Maven 执行的值的元素，例如 pom.xml 文件。settings 文件位于 $ {M2_HOME}/settings.xml，其中 M2_HOME 是 {USER_HOME}/.m2。在 第三章 的 本地仓库 部分中，创建和导入项目，我们使用此文件设置除默认仓库之外的备用本地仓库。

用户设置 允许我们使用自定义设置文件并重新索引本地仓库，如下面的截图所示：

更多关于设置的信息请参阅 maven.apache.org/settings.html#Servers。

安装

安装 显示 Maven 安装并允许我们选择要使用的 Maven。我们使用它来设置 设置 Maven 以使用 部分的 第二章 中的外部 Maven 安装；请参阅它以获取更多详细信息。

警告

警告允许我们启用/禁用跨父-子 POM 的重复组 ID 和版本的警告。在撰写本文时，尽管此选项已启用，但 m2eclipse 仍然会抱怨重复；希望这个功能将在未来的新版本中正常工作。

模板

模板显示了 Maven 所使用的所有模板的列表。它还提供了一个选项来添加新模板、编辑、删除、导入和导出模板，如下面的截图所示：

生命周期映射

生命周期映射 允许我们自定义 m2eclipse 使用的 Maven 项目的项目构建生命周期。在撰写本书时，此功能仍然是实验性的；因此，我们将限制对其的讨论。

更多信息请参阅 wiki.eclipse.org/M2E_plugin_execution_not_covered。

摘要

在本章中，你了解了 m2eclipse 中可用的其他附加功能，并熟悉了仓库、基于表单的 POM 编辑器和 m2eclipse 首选项。因此，在这本书中，你学习了 Maven 概念；m2eclipse 和功能；以及创建、构建和运行 Maven 项目的便捷性。