美文网首页
Maven入门指南

Maven入门指南

作者: liefsoft | 来源:发表于2019-10-21 17:04 被阅读0次

    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生成的典型框架将具有<artifactId>-<version>.<extension>表单(例如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.xmlpom.properties文件。这些都是标准的,在Maven中生成一个JAR。如果选择,可以创建自己的清单,但如果不选择,Maven将默认生成清单。(还可以修改默认清单中的条目。我们稍后再谈这个问题。) pom.xmlpom.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>
    

    您会注意到,我们必须添加以前没有的buildresourcesresource元素。此外,我们还必须明确声明资源位于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.xmlproperties节点中定义它,并获得同样的效果(请注意,我也不需要对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.versionuser.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, testruntime这样的值。有关可以为依赖项指定的所有内容的详细信息,请参阅项目描述符指南(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始终可以被定位,即使通过在存储库中查找该项目,该项目也是独立于其父项目的。

    相关文章

      网友评论

          本文标题:Maven入门指南

          本文链接:https://www.haomeiwen.com/subject/ziatvctx.html