手记

Maven入门指南

liefsoft_cloud
2019-10-21 16:53:30浏览 1951

Maven入门指南

本指南旨在第一次为使用Maven的人员提供参考，但也打算作为一本包含公共用例的独立参考和解决方案的工具书。对于新用户，建议您按顺序浏览该材料。对于更熟悉Maven的用户，本指南致力于为手头的需求提供一个快速解决方案。现在假设您已经在本地计算机上下载了Maven并安装了Maven。如果您没有这样做，请参考下载和安装说明（ Download and Installation）。

好的，现在安装了Maven，我们准备好了。在开始我们的示例之前，我们将非常简单地介绍Maven是什么，以及它如何帮助您完成日常工作和与团队成员协作。当然，Maven将为小型项目工作，但是Maven在帮助团队更有效地操作方面表现出色，它允许团队成员将精力集中在项目的涉众需要什么上。您可以将构建基础设施留给Maven！

Maven是什么？

乍一看，Maven看起来可能有很多东西，但简而言之，Maven是一种尝试将模式应用于项目的构建基础结构，以便通过在使用最佳实践中提供清晰的路径来促进理解和生产力。Maven本质上是一个项目管理和理解工具，因此提供了一种帮助管理的方法：

  • 构建
  • 文档
  • 报告
  • 依赖
  • SCMs
  • 版本
  • 发布

如果您想了解更多关于Maven的背景信息，可以查看Maven的哲学（ The Philosophy of Maven）和Maven的历史（ The History of Maven）。现在，让我们继续讨论用户如何从使用Maven中获益。

Maven如何使我的开发过程受益？

Maven可以通过使用标准约定和实践来加快开发周期，同时帮助您获得更高的效率，从而为您的构建过程提供好处。

现在我们已经介绍了一些Maven的历史和目的，让我们进入一些实际的例子，让您开始使用Maven！

如何配置Maven？

Maven的默认值通常是足够的，但是如果您需要更改缓存位置或使用HTTP代理，则需要创建配置。有关更多信息，请参见配置Maven指南（Guide to Configuring Maven）。

如何进行我的第一个Maven项目？

我们将直接跳到创建您的第一个Maven项目！为了创建我们的第一个Maven项目，我们将使用Maven的原型机制。原型（archetype ）被定义为一种原始的模式或模型，所有其他同类的东西都是从这个模式或模型中制造出来的。在Maven中，原型是一个项目的模板，该模板与一些用户输入相结合，生成一个适合用户需求的Maven项目。我们现在将向您展示原型机制是如何工作的，但是如果您想了解更多关于原型的信息，请参考我们对原型的介绍（ Introduction to Archetypes）。

继续创建你的第一个项目！为了创建最简单的Maven项目，从命令行执行以下命令：

mvn -B archetype:generate \
  -DarchetypeGroupId=org.apache.maven.archetypes \
  -DgroupId=com.mycompany.app \
  -DartifactId=my-app

执行此命令后，您将注意到发生了一些事情。首先，您将注意到已经为新项目创建了一个名为my-app的目录，并且这个目录包含一个名为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.0
                      http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.mycompany.app</groupId>
  <artifactId>my-app</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>Maven Quick Start Archetype</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

pom.xml包含该项目的项目对象模型(POM)。POM是Maven中的基本工作单元。记住这一点很重要，因为Maven本质上是以项目为中心的，因为一切都围绕着项目的概念。简而言之，POM包含关于您的项目的每一个重要信息，本质上是一站式消费，用于查找与您的项目相关的任何内容。理解POM很重要，鼓励新用户参考POM简介（Introduction to the POM）。

这是一个非常简单的POM，但仍然显示每个POM包含的关键元素，因此让我们遍历其中的每一个元素，让您熟悉POM要点：

  • project 这是所有Maven pom.xml文件中的顶级元素。
  • modelVersion 此元素指示POM使用的对象模型的版本。模型本身的版本变化非常少，但如果Maven开发人员认为有必要更改模型，则必须这样做，以确保使用的稳定性。
  • groupId 此元素指示创建项目的组织或组的唯一标识符。groupId是项目的关键标识符之一，通常基于组织的完全限定域名。例如，org.apache.maven.plugins是所有Maven插件的指定groupId。
  • artifactId 此元素指示由此项目生成的项目的唯一名称。项目的主要框架通常是JAR文件。像源包这样的次要构件也使用artifactId作为其最终名称的一部分。Maven生成的典型框架将具有-.表单(例如myapp-1.0.jar)。
  • packaging 此元素指示此项目将使用的包类型(例如JAR、WAR、EAR等)。这不仅意味着产生的项目是JAR、WAR或EAR，而且还可以指示要作为构建过程的一部分使用的特定生命周期。(生命周期是我们将在指南中进一步讨论的一个主题。现在，请记住，项目的指定打包可以在定制构建生命周期中发挥作用。)packaging的默认值是JAR，因此您不必为大多数项目指定此值。
  • version 此元素指示项目生成的版本。Maven对帮助您进行版本管理有很大帮助，您经常会看到版本中的SNAPSHOT指示符，这表明项目处于开发状态。我们将在本指南中讨论 snapshots的使用以及它们是如何工作的。
  • name 此元素指示用于项目的显示名称。这经常用于Maven生成的文档中。
  • url 此元素指示在何处可以找到项目的站点。这经常用于Maven生成的文档中。
  • description 此元素提供了项目的基本说明。这经常用于Maven生成的文档中。

有关在POM中可用的元素的完整参考，请参考我们的POM指南（POM Reference）。现在让我们回到手头的项目。

在生成第一个项目的原型之后，您还会注意到已经创建了以下目录结构：

my-app
|-- pom.xml
`-- src
    |-- main
    |   `-- java
    |       `-- com
    |           `-- mycompany
    |               `-- app
    |                   `-- App.java
    `-- test
        `-- java
            `-- com
                `-- mycompany
                    `-- app
                        `-- AppTest.java

如您所见，从原型（archetype）创建的项目有一个POM、一个用于应用程序源的源代码树和一个用于测试源的源代码树。这是Maven项目的标准布局(应用程序源位于${basedir}/src/main/java，测试源位于${basedir}/src/test/java中，其中${basedir}表示包含pom.xml的目录)。

如果要手工创建Maven项目，我们建议使用这个目录结构。这是一个Maven约定，要了解更多有关它的信息，您可以阅读我们对标准目录布局的介绍(Introduction to the Standard Directory Layout)。

现在我们有了一个POM、一些应用程序源代码和一些您可能需要的测试源代码。

如何编译我的应用程序源代码？

通过archetype:generate切换到被创建pom.xml的目录并执行以下命令来编译应用程序源代码：

mvn compile

在执行此命令时，您应该看到输出如下所示：

[INFO] ----------------------------------------------------------------------------
[INFO] Building Maven Quick Start Archetype
[INFO]    task-segment: [compile]
[INFO] ----------------------------------------------------------------------------
[INFO] artifact org.apache.maven.plugins:maven-resources-plugin: \
  checking for updates from central
...
[INFO] artifact org.apache.maven.plugins:maven-compiler-plugin: \
  checking for updates from central
...
[INFO] [resources:resources]
...
[INFO] [compiler:compile]
Compiling 1 source file to <dir>/my-app/target/classes
[INFO] ----------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ----------------------------------------------------------------------------
[INFO] Total time: 3 minutes 54 seconds
[INFO] Finished at: Fri Sep 23 15:48:34 GMT-05:00 2005
[INFO] Final Memory: 2M/6M
[INFO] ----------------------------------------------------------------------------

当您第一次执行此命令(或任何其他命令)时，Maven将需要下载完成该命令所需的所有插件和相关依赖项。从Maven的干净安装来看，这可能需要相当长的时间(在上面的输出中，花费了将近4分钟)。如果您再次执行该命令，Maven现在将得到它所需的东西，因此它不需要下载任何新的内容，并且能够更快地执行该命令。

从输出中可以看到，编译后的类被放置在${basedir}/target/classes中，这是Maven使用的另一个标准约定。因此，如果您是一个敏锐的观察者，您会注意到通过使用标准约定，上面的POM非常小，并且您不必明确地告诉Maven您的源代码在哪里或输出应该去哪里。通过遵循标准的Maven约定，您可以在很小的努力下完成很多事情！作为一个偶然的比较，让我们来看看您在 Ant中可能需要做些什么来完成同样的 事情。

现在，这只是编译一个应用程序源代码树，所显示的Ant脚本与上面显示的POM大小基本相同。但是，我们将看到，我们还可以做更多的只是简单的POM！

如何编译测试源代码并运行单元测试？

现在您正在成功地编译您的应用程序的源代码，现在您已经获得了一些您想要编译和执行的单元测试(因为每个程序员总是编写和执行他们的单元测试轻推眨眼)。

执行以下命令：

mvn test

在执行此命令时，您应该看到输出如下所示：

[INFO] ----------------------------------------------------------------------------
[INFO] Building Maven Quick Start Archetype
[INFO]    task-segment: [test]
[INFO] ----------------------------------------------------------------------------
[INFO] artifact org.apache.maven.plugins:maven-surefire-plugin: \
  checking for updates from central
...
[INFO] [resources:resources]
[INFO] [compiler:compile]
[INFO] Nothing to compile - all classes are up to date
[INFO] [resources:testResources]
[INFO] [compiler:testCompile]
Compiling 1 source file to C:\Test\Maven2\test\my-app\target\test-classes
...
[INFO] [surefire:test]
[INFO] Setting reports dir: C:\Test\Maven2\test\my-app\target/surefire-reports
 
-------------------------------------------------------
 T E S T S
-------------------------------------------------------
[surefire] Running com.mycompany.app.AppTest
[surefire] Tests run: 1, Failures: 0, Errors: 0, Time elapsed: 0 sec
 
Results :
[surefire] Tests run: 1, Failures: 0, Errors: 0
 
[INFO] ----------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ----------------------------------------------------------------------------
[INFO] Total time: 15 seconds
[INFO] Finished at: Thu Oct 06 08:12:17 MDT 2005
[INFO] Final Memory: 2M/8M
[INFO] ----------------------------------------------------------------------------

一些关于输出的注意事项：

  • Maven这次下载更多的依赖项。这些是执行测试所必需的依赖项和插件(它已经拥有编译所需的依赖项，不会再下载它们)。
  • 在编译和执行测试之前，Maven编译主代码(所有这些类都是最新的，因为我们自上次编译以来什么都没有改变)。

如果您只想编译测试源代码(但不想执行测试)，可以执行以下操作：

mvn test-compile

既然您可以编译您的应用程序源代码，编译您的测试，并执行测试，那么您将希望进入下一个逻辑步骤，因此您将询问…

如何创建JAR并将其安装在本地存储库中？

创建JAR文件是足够直接的，可以通过执行以下命令来完成：

mvn package

如果您查看项目的POM，您将注意到packaging元素设置为jar。Maven知道如何从上面的命令生成一个JAR文件(稍后我们将更多地讨论这一点)。现在您可以在${basedir}/target目录中查看一下，您将看到生成的JAR文件。

现在，您需要在本地存储库中安装您生成的项目(JAR文件)(${user.home}/.m2/repository是默认位置)。有关存储库的更多信息，您可以参考我们对存储库的介绍（Introduction to Repositories），但让我们继续安装我们的项目！为此，请执行以下命令：

mvn install

在执行此命令时，您将看到以下输出：

[INFO] ----------------------------------------------------------------------------
[INFO] Building Maven Quick Start Archetype
[INFO]    task-segment: [install]
[INFO] ----------------------------------------------------------------------------
[INFO] [resources:resources]
[INFO] [compiler:compile]
Compiling 1 source file to <dir>/my-app/target/classes
[INFO] [resources:testResources]
[INFO] [compiler:testCompile]
Compiling 1 source file to <dir>/my-app/target/test-classes
[INFO] [surefire:test]
[INFO] Setting reports dir: <dir>/my-app/target/surefire-reports
 
-------------------------------------------------------
 T E S T S
-------------------------------------------------------
[surefire] Running com.mycompany.app.AppTest
[surefire] Tests run: 1, Failures: 0, Errors: 0, Time elapsed: 0.001 sec
 
Results :
[surefire] Tests run: 1, Failures: 0, Errors: 0
 
[INFO] [jar:jar]
[INFO] Building jar: <dir>/my-app/target/my-app-1.0-SNAPSHOT.jar
[INFO] [install:install]
[INFO] Installing <dir>/my-app/target/my-app-1.0-SNAPSHOT.jar to \
   <local-repository>/com/mycompany/app/my-app/1.0-SNAPSHOT/my-app-1.0-SNAPSHOT.jar
[INFO] ----------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ----------------------------------------------------------------------------
[INFO] Total time: 5 seconds
[INFO] Finished at: Tue Oct 04 13:20:32 GMT-05:00 2005
[INFO] Final Memory: 3M/8M
[INFO] ----------------------------------------------------------------------------

注意，强制插件(它执行测试)查找包含在具有特定命名约定的文件中的测试。默认情况下，包括的测试如下：

  • **/*Test.java
  • **/Test*.java
  • **/*TestCase.java

默认情况排除如下：

  • **/Abstract*Test.java
  • **/Abstract*TestCase.java

您已经完成了设置、构建、测试、打包和安装典型Maven项目的过程。这可能是项目使用Maven所做的绝大部分工作，如果您已经注意到，到目前为止所能做的一切都是由一个18行文件驱动的，即项目的模型或POM。如果您查看一个典型的Ant构建文件，它提供了与我们迄今为止所实现的功能相同的功能，您会注意到它的大小已经是POM的两倍，而且我们才刚刚开始！您可以从Maven获得更多的功能，而不需要对我们目前的POM进行任何添加。要从我们的示例Ant构建文件（ build file ）中获得更多的功能，您必须不断地添加容易出错的内容。

你还能免费得到什么？有大量的Maven插件，即使是像我们上面这样简单的POM，也是可以开箱即用的。我们将在这里特别提到一个，因为它是Maven的一个被高度重视的特性：在没有任何工作的情况下，这个POM有足够的信息为您的项目生成一个网站！您很可能希望自定义Maven站点，但如果时间紧迫，则只需执行以下命令即可提供有关项目的基本信息：

mvn site

还有许多其他独立的目标也可以执行，例如：

mvn clean

这将在启动前删除包含所有生成数据的target目录，以使其是新的。

什么是SNAPSHOT版本？

注意，下面显示的pom.xml文件中version标记的值有后缀：-SNAPSHOT。

<project xmlns="http://maven.apache.org/POM/4.0.0"
  ...
  <groupId>...</groupId>
  <artifactId>my-app</artifactId>
  ...
  <version>1.0-SNAPSHOT</version>
  <name>Maven Quick Start Archetype</name>
  ...

SNAPSHOT是指开发分支的“最新”代码，并不保证代码是稳定的或不变的。相反，‘release’ 中的代码(任何没有后缀SNAPSHOT的版本值)都是不变的。

换句话说，SNAPSHOT版本是最后的 ‘release’ 版本之前的“开发”版本。SNAPSHOT比它的’release’ 版“旧”。

在发布过程中，x.y-SNAPSHOT的版本更改为x.y。发布过程中还将开发版本增加到 x.(y+1)-SNAPSHOT。例如，1.0-SNAPSHOT作为1.0版发布，新的开发版本为1.1-SNAPSHOT。

如何使用插件？

每当您想要自定义Maven项目的构建时，都是通过添加或重新配置插件来完成的。

**注意，对于Maven 1.0用户：**在Maven 1.0中，您应该将一些preGoal添加到maven.xml中，并将一些条目添加到project.properties中。在这里，有点不同。对于本例，我们将配置Java编译器以允许JDK5.0源代码。这就像将其添加到POM中一样简单：

...
<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>3.3</version>
      <configuration>
        <source>1.5</source>
        <target>1.5</target>
      </configuration>
    </plugin>
  </plugins>
</build>
...

您会注意到，Maven中的所有插件看起来都很像一个依赖项-而且在某些方面它们是依赖的。这个插件将被自动下载和使用-如果你要求的话包括一个特定的版本(默认的是使用最新的可用版本)。

configuration元素将给定的参数应用于编译器插件中的每个目标。在上面的例子中，编译器插件已经被用作构建过程的一部分，这只是改变了配置。还可以向流程中添加新的目标，并配置特定的目标。有关这方面的信息，请参阅构建生命周期介绍（Introduction to the Build Lifecycle）。

要了解插件的配置，您可以看到插件列表（Plugins List）并导航到您正在使用的插件和目标。有关如何配置插件可用参数的一般信息，请参阅配置插件指南（Guide to Configuring Plugins）。

如何将资源添加到我的JAR中？

另一个可以满足的常见用例是将资源打包到JAR文件中，它不需要对上面的POM进行更改。对于这个常见的任务，Maven再次依赖于 Standard Directory Layout，这意味着通过使用标准Maven约定，您可以将资源打包到JAR中，只需将这些资源放在标准目录结构中即可。

您可以在下面的示例中看到，我们添加了目录${basedir}/src/main/resources，我们希望将任何资源打包到JAR中。Maven使用的简单规则是：${basedir}/src/main/resources目录中的任何目录或文件都打包在JAR中，其结构与JAR底部的结构完全相同。

my-app
|-- pom.xml
`-- src
    |-- main
    |   |-- java
    |   |   `-- com
    |   |       `-- mycompany
    |   |           `-- app
    |   |               `-- App.java
    |   `-- resources
    |       `-- META-INF
    |           `-- application.properties
    `-- test
        `-- java
            `-- com
                `-- mycompany
                    `-- app
                        `-- AppTest.java

因此，在我们的示例中可以看到，我们在该目录中有一个META-INF目录和一个application.properties文件。如果您打开Maven为您创建的JAR并查看它，您将看到以下内容：

|-- META-INF
|   |-- MANIFEST.MF
|   |-- application.properties
|   `-- maven
|       `-- com.mycompany.app
|           `-- my-app
|               |-- pom.properties
|               `-- pom.xml
`-- com
    `-- mycompany
        `-- app
            `-- App.class

如您所见，${basedir}/src/main/resources的内容可以从JAR的里边找到，而application.properties文件位于META-INF目录中。您还会注意到一些其他文件，如META-INF/MANIFEST.MF，以及pom.xml和pom.properties文件。这些都是标准的，在Maven中生成一个JAR。如果选择，可以创建自己的清单，但如果不选择，Maven将默认生成清单。(还可以修改默认清单中的条目。我们稍后再谈这个问题。) pom.xml和pom.properties文件打包在JAR中，这样由Maven生成的每个项目都是自描述的，并允许您在需要时在自己的应用程序中使用元数据。一个简单的用途可能是检索应用程序的版本。对POM文件的操作将要求您使用一些Maven实用程序，但是可以使用标准的Java API来使用这些属性，如下所示：

#Generated by Maven
#Tue Oct 04 15:43:21 GMT-05:00 2005
version=1.0-SNAPSHOT
groupId=com.mycompany.app
artifactId=my-app

要将资源(resources)添加到单元测试的类路径中，您可以遵循与将资源添加到JAR中相同的模式，但将资源放在其中的目录是${basedir}/src/test/resources。此时，您将拥有一个类似于以下内容的项目目录结构：

my-app
|-- pom.xml
`-- src
    |-- main
    |   |-- java
    |   |   `-- com
    |   |       `-- mycompany
    |   |           `-- app
    |   |               `-- App.java
    |   `-- resources
    |       `-- META-INF
    |           |-- application.properties
    `-- test
        |-- java
        |   `-- com
        |       `-- mycompany
        |           `-- app
        |               `-- AppTest.java
        `-- resources
            `-- test.properties

在单元测试中，您可以使用以下代码片段来访问测试所需的资源：

...
 
// Retrieve resource
InputStream is = getClass().getResourceAsStream( "/test.properties" );
 
// Do something with the resource
 
...

如何过滤资源文件？

有时，资源文件需要包含只能在构建时提供的值。要在Maven中实现这一点，请使用语法${<Property name>}将包含该值的属性引用到您的资源文件中。该属性可以是在pom.xml中定义的值之一、在用户的setings.xml中定义的值、在外部属性文件中定义的属性或系统属性。

若要在复制时让Maven筛选资源，只需在你的pom.xml中将资源目录的filtering设置为true：

<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.app</groupId>
  <artifactId>my-app</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>
 
  <name>Maven Quick Start Archetype</name>
  <url>http://maven.apache.org</url>
 
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
 
  <build>
    <resources>
      <resource>
        <directory>src/main/resources</directory>
        <filtering>true</filtering>
      </resource>
    </resources>
  </build>
</project>

您会注意到，我们必须添加以前没有的build、resources和resource元素。此外，我们还必须明确声明资源位于src/main/resources目录中。所有这些信息以前都是以默认值的形式提供的，但是由于filtering的默认值为false，所以我们必须将其添加到pom.xml中，以便覆盖该默认值并将filtering设置为true。

要引用pom.xml中定义的属性，属性名称使用定义值的XML元素的名称，并允许“pom”作为项目(Root)元素的别名。所以${project.name}是指项目的名称，${project.version}是指项目的版本，${project.build.finalName}是指在打包构建项目时创建的文件的最终名称，等等。类似地，可以使用以“settings”开头的属性名称引用用户Setings.xml中的值(例如，${setings.localRepository}引用用户本地存储库的路径)。

为了继续我们的示例，让我们将两个属性添加到application.properties文件(我们将其放在src/main/resources目录中)，当资源被过滤时，它的值将被提供：

# application.properties
application.name=${project.name}
application.version=${project.version}

这样，您就可以执行以下命令(Process-Resources是复制和过滤资源的构建生命周期阶段)：

mvn process-resources

target/classes下的application.properties文件(最终将进入JAR)如下所示：

# application.properties
application.name=Maven Quick Start Archetype
application.version=1.0-SNAPSHOT

若要引用在外部文件中定义的属性，只需将对该外部文件的引用添加到pom.xml文件中即可。首先，让我们创建外部属性文件，并将其命名为src/main/filters/filter.properties：

# filter.properties
my.filter.value=hello!

接下来，我们将在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.0
                      http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
 
  <groupId>com.mycompany.app</groupId>
  <artifactId>my-app</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>
 
  <name>Maven Quick Start Archetype</name>
  <url>http://maven.apache.org</url>
 
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
 
  <build>
    <filters>
      <filter>src/main/filters/filter.properties</filter>
    </filters>
    <resources>
      <resource>
        <directory>src/main/resources</directory>
        <filtering>true</filtering>
      </resource>
    </resources>
  </build>
</project>

然后，如果我们在application.properties文件中添加对此属性的引用：

# application.properties
application.name=${project.name}
application.version=${project.version}
message=${my.filter.value}

下次执行mvn process-resources命令时，我们将把新的属性值放入application.properties中。作为在外部文件中定义my.filter.value属性的一种替代方法，您也可以在pom.xml的properties节点中定义它，并获得同样的效果(请注意，我也不需要对src/main/filters/filter.properties的引用)：

<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.app</groupId>
  <artifactId>my-app</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>
 
  <name>Maven Quick Start Archetype</name>
  <url>http://maven.apache.org</url>
 
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
 
  <build>
    <resources>
      <resource>
        <directory>src/main/resources</directory>
        <filtering>true</filtering>
      </resource>
    </resources>
  </build>
 
  <properties>
    <my.filter.value>hello</my.filter.value>
  </properties>
</project>

过滤资源也可以从系统属性中获得值；要么是内置到Java中的系统属性(比如java.version或user.home)，要么是使用标准Java-D参数在命令行上定义的属性。为了继续这个示例，让我们将application.properties文件更改为如下所示：

# application.properties
java.version=${java.version}
command.line.prop=${command.line.prop}

现在，当您执行以下命令(请注意命令行上的command.line.prop属性的定义)时，application.properties文件将包含来自系统属性的值。

mvn process-resources "-Dcommand.line.prop=hello again"

如何使用外部依赖项？

您可能已经注意到我们作为示例使用的POM中的dependencies元素。事实上，您一直在使用外部依赖项，但是这里我们将更详细地讨论这一点。关于更详细的介绍，请参阅我们对依赖机制的介绍（ Introduction to Dependency Mechanism）。

pom.xml的dependencies节点列出了我们的项目构建所需的所有外部依赖项(无论是在编译时、测试时、运行时还是其他什么时候都需要该依赖项)。现在，我们的项目只依赖于JUnit(为了清晰起见，我取出了所有的资源过滤工具)：

<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.app</groupId>
  <artifactId>my-app</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>
 
  <name>Maven Quick Start Archetype</name>
  <url>http://maven.apache.org</url>
 
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

对于每个外部依赖项，您至少需要定义4件事情：groupId, artifactId, version 和 scope。groupId、artifactId和version与构建该依赖项的pom.xml中提供的相同。scope元素指示项目如何使用该依赖项，并且可以是像compile, test和 runtime这样的值。有关可以为依赖项指定的所有内容的详细信息，请参阅项目描述符指南（Project Descriptor Reference）。

有关整个依赖机制的更多信息，请参见依赖机制介绍（Introduction to Dependency Mechanism）。

有了这些关于依赖项的信息，Maven将能够在构建项目时引用该依赖项。Maven从哪里引用依赖项？Maven在本地存储库中查找所有依赖项(${user.home}/.m2/repository是默认位置)。在上一节中，我们将项目(My-app-1.0-SNAPSHOT.jar)安装到本地存储库中。一旦安装在那里，另一个项目就可以将该jar引用为依赖项，只需将依赖信息添加到它的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.0
                      http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <groupId>com.mycompany.app</groupId>
  <artifactId>my-other-app</artifactId>
  ...
  <dependencies>
    ...
    <dependency>
      <groupId>com.mycompany.app</groupId>
      <artifactId>my-app</artifactId>
      <version>1.0-SNAPSHOT</version>
      <scope>compile</scope>
    </dependency>
  </dependencies>
</project>

其他地方构建的依赖关系呢？他们怎么进入我的本地存储库？每当项目引用本地存储库中不可用的依赖项时，Maven将依赖项从远程存储库下载到本地存储库中。在构建第一个项目时，您可能注意到Maven下载了很多东西(这些下载是用于构建项目的各种插件的依赖项)。默认情况下，可以在http://repo.maven.apache.org/maven2/上找到(并浏览)Maven使用的远程存储库。您还可以设置自己的远程存储库(可能是您公司的中央存储库)来代替默认远程存储库或除了默认远程存储库之外使用。有关存储库的更多信息，请参阅存储库介绍（Introduction to Repositorie）。

让我们将另一个依赖项添加到我们的项目中。假设我们在代码中添加了一些日志，并且需要将log4j作为依赖项添加。首先，我们需要知道log4j的groupId、artifactId和version是什么。Maven Central上的适当目录名为/maven2/log4j/log4j。该目录中有一个名为maven-metadata.xml的文件。下面是log4j的maven-metadata.xml如下所示：

<metadata>
  <groupId>log4j</groupId>
  <artifactId>log4j</artifactId>
  <version>1.1.3</version>
  <versioning>
    <versions>
      <version>1.1.3</version>
      <version>1.2.4</version>
      <version>1.2.5</version>
      <version>1.2.6</version>
      <version>1.2.7</version>
      <version>1.2.8</version>
      <version>1.2.11</version>
      <version>1.2.9</version>
      <version>1.2.12</version>
    </versions>
  </versioning>
</metadata>

从这个文件中，我们可以看到我们想要的groupId是“log4j”，而artifactId是“log4j”。我们看到许多不同的版本值可供选择；目前，我们只使用最新版本1.2.12(一些maven-metadata.xml文件也可能指定哪个版本是当前版本)。在maven-metadata.xml文件旁边，我们可以看到与log4j库的每个版本对应的目录。在这些文件中，我们将找到实际的JAR文件(例如log4j-1.2.12.jar)和一个pom文件(这是该依赖项的pom.xml，指示它可能拥有的任何进一步依赖项和其他信息)和另一个maven-metadata.xml文件。还有一个对应于这些文件的MD5文件，其中包含这些文件的MD5哈希值。您可以使用它对库进行身份验证，或者确定您可能已经使用的特定库的哪个版本。

既然我们已经知道了我们需要的信息，我们就可以将依赖项添加到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.0
                      http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
 
  <groupId>com.mycompany.app</groupId>
  <artifactId>my-app</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>
 
  <name>Maven Quick Start Archetype</name>
  <url>http://maven.apache.org</url>
 
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.12</version>
      <scope>compile</scope>
    </dependency>
  </dependencies>
</project>

现在，当我们编译项目(mvn compile)时，我们将看到Maven为我们下载log4j依赖项。

如何在远程存储库中部署JAR？

要将JAR部署到外部存储库，您必须在pom.xml中配置存储库url，并在settings.xml中配置连接到存储库的身份验证信息。

下面是一个使用scp和用户名/密码身份验证的示例：

<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.app</groupId>
  <artifactId>my-app</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>
 
  <name>Maven Quick Start Archetype</name>
  <url>http://maven.apache.org</url>
 
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.apache.codehaus.plexus</groupId>
      <artifactId>plexus-utils</artifactId>
      <version>1.0.4</version>
    </dependency>
  </dependencies>
 
  <build>
    <filters>
      <filter>src/main/filters/filters.properties</filter>
    </filters>
    <resources>
      <resource>
        <directory>src/main/resources</directory>
        <filtering>true</filtering>
      </resource>
    </resources>
  </build>
  <!--
   |
   |
   |
   -->
  <distributionManagement>
    <repository>
      <id>mycompany-repository</id>
      <name>MyCompany Repository</name>
      <url>scp://repository.mycompany.com/repository/maven2</url>
    </repository>
  </distributionManagement>
</project>

<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0
                      http://maven.apache.org/xsd/settings-1.0.0.xsd">
  ...
  <servers>
    <server>
      <id>mycompany-repository</id>
      <username>jvanzyl</username>
      <!-- Default value is ~/.ssh/id_dsa -->
      <privateKey>/path/to/identity</privateKey> (default is ~/.ssh/id_dsa)
      <passphrase>my_key_passphrase</passphrase>
    </server>
  </servers>
  ...
</settings>

请注意，如果连接到openssh ssh服务器，该服务器的参数“PasswordAuthentication”在sshd_conf中设置为“no”，则每次输入用户名/密码身份验证时都必须键入密码(尽管您可以使用另一个ssh客户机登录，输入用户名和密码)。在这种情况下，您可能希望切换到公钥身份验证。

在settings.xml中使用密码时应该小心。有关更多信息，请参见密码加密（Password Encryption）。

如何创建文档？

为了让您从Maven的文档系统开始，您可以使用原型机制为现有项目生成一个站点，使用以下命令：

mvn archetype:generate \
  -DarchetypeGroupId=org.apache.maven.archetypes \
  -DarchetypeArtifactId=maven-archetype-site \
  -DgroupId=com.mycompany.app \
  -DartifactId=my-app-site

现在转到指南中去创建一个站点（Guide to creating a site），学习如何为您的项目创建文档。

如何构建其他类型的项目？

注意，生命周期适用于任何项目类型。例如，回到基本目录中，我们可以创建一个简单的web应用程序：

mvn archetype:generate \
    -DarchetypeGroupId=org.apache.maven.archetypes \
    -DarchetypeArtifactId=maven-archetype-webapp \
    -DgroupId=com.mycompany.app \
    -DartifactId=my-webapp

请注意，所有这些都必须在一行上。这将创建一个名为my-webapp的目录，其中包含以下项目描述符：

<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.app</groupId>
  <artifactId>my-webapp</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>
 
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
 
  <build>
    <finalName>my-webapp</finalName>
  </build>
</project>

注意<packaging>元素-这告诉Maven构建为WAR。切换到webapp项目的目录并尝试：

mvn package

您将看到构建了target/my-webapp.war，并且执行了所有正常步骤。

如何同时构建多个项目？

Maven内置了处理多个模块的概念。在本节中，我们将展示如何构建上面的WAR，并在一个步骤中包含前面的JAR。

首先，我们需要在其他两个目录中添加一个父pom.xml文件，因此它应该如下所示：

+- pom.xml
+- my-app
| +- pom.xml
| +- src
|   +- main
|     +- java
+- my-webapp
| +- pom.xml
| +- src
|   +- main
|     +- webapp

您将要创建的POM文件应该包含以下内容：

<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.app</groupId>
  <artifactId>app</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>pom</packaging>
 
  <modules>
    <module>my-app</module>
    <module>my-webapp</module>
  </modules>
</project>

我们需要一个来自webapp的JAR依赖项，所以将其添加到my-webapp/pom.xml中：

 ...
  <dependencies>
    <dependency>
      <groupId>com.mycompany.app</groupId>
      <artifactId>my-app</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>
    ...
  </dependencies>

最后，将以下<parent>元素添加到子目录中的两个其他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.0
                      http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <parent>
    <groupId>com.mycompany.app</groupId>
    <artifactId>app</artifactId>
    <version>1.0-SNAPSHOT</version>
  </parent>
  ...

现在试试.。在顶层目录中，运行：

mvn verify

WAR现在已经在my-webapp/target/my-webapp.war中创建，并且JAR被包括在内：

$ jar tvf my-webapp/target/my-webapp-1.0-SNAPSHOT.war
   0 Fri Jun 24 10:59:56 EST 2005 META-INF/
 222 Fri Jun 24 10:59:54 EST 2005 META-INF/MANIFEST.MF
   0 Fri Jun 24 10:59:56 EST 2005 META-INF/maven/
   0 Fri Jun 24 10:59:56 EST 2005 META-INF/maven/com.mycompany.app/
   0 Fri Jun 24 10:59:56 EST 2005 META-INF/maven/com.mycompany.app/my-webapp/
3239 Fri Jun 24 10:59:56 EST 2005 META-INF/maven/com.mycompany.app/my-webapp/pom.xml
   0 Fri Jun 24 10:59:56 EST 2005 WEB-INF/
 215 Fri Jun 24 10:59:56 EST 2005 WEB-INF/web.xml
 123 Fri Jun 24 10:59:56 EST 2005 META-INF/maven/com.mycompany.app/my-webapp/pom.properties
  52 Fri Jun 24 10:59:56 EST 2005 index.jsp
   0 Fri Jun 24 10:59:56 EST 2005 WEB-INF/lib/
2713 Fri Jun 24 10:59:56 EST 2005 WEB-INF/lib/my-app-1.0-SNAPSHOT.jar

这是怎么回事？首先，创建的父POM(称为app)具有POM的打包和定义的模块列表。这告诉Maven在项目集上运行所有操作，而不是只运行当前的操作(要覆盖这种行为，可以使用--non-recursive命令行选项)。

接下来，我们告诉WAR，它需要my-app JAR。这做了几件事：它使它可以在类路径上访问WAR中的任何代码(在本例中没有)，它确保JAR总是在WAR之前构建的，并且它指示WAR插件将JAR包含在其库目录中。

您可能已经注意到junit-4.11.jar是一种依赖关系，但没有在WAR中结束。原因是<scope>test</scope>元素-它只是测试所必需的，因此不包括在web应用程序中，因为编译时依赖于my-app。

最后一步是包含父定义。这与您可能熟悉的Maven 1.0中的extend元素不同：这可以确保POM始终可以被定位，即使通过在存储库中查找该项目，该项目也是独立于其父项目的。

本文由博客一文多发平台 OpenWrite 发布！

相关标签
Java
0人推荐
随时随地看视频
慕课网APP

相关阅读

没做过大项目，但我会建大项目
maven一波流(7)——使用命令行或eclipse管理项目生命周期
JVM Advent Calendar：使用Gradle构建Monorepo项目
Java工程师学习指南 初级篇
IDEA创建Maven web项目（项目结构组织、文件编译及运行明细）