Maven入门指南

2019-10-25 06:44:33来源：博客园阅读 ()

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始终可以被定位，即使通过在存储库中查找该项目，该项目也是独立于其父项目的。

原文链接:https://www.cnblogs.com/liefsoft/p/11714570.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：Java之路---Day06

下一篇：数据安全管理：RSA加密算法，签名验签流程详解

logstash系列-入门整理 2020-06-10
eclipse下创建Maven项目（包含webapp目录结构） 2020-06-09
Maven安装与配置 2020-06-09
Java 入门教程 2020-06-09
RocketMQ4.4 入门进阶+实战 2020-06-08

IDC资讯：主机资讯注册资讯托管资讯 vps资讯网站建设

网站运营：建站经验策划盈利搜索优化网站推广免费资源

网站联盟：联盟新闻联盟介绍联盟点评网赚技巧

行业资讯：搜索引擎网络游戏电子商务广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器安全防护

软件技巧：其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识：网络协议网络安全网络管理组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条

最新资讯

热门关注

热门标签