精华内容
下载资源
问答
  • Maven-POM

    2020-08-24 13:21:44
    Maven坐标 POM关系 相依性 依赖性版本需求规范 版本订购规格 版本顺序测试 排除 继承 超级POM 依赖性管理 聚合(或多模块) 继承.聚合 特性 生成设置 房 BaseBuild元素集 资源 插件 插件管理 ...

    POM参考

    1. 导言
      1. 什么是战俘?
      2. 快速概述
    2. 基础
      1. Maven坐标
      2. POM关系
        1. 相依性
          1. 依赖性版本需求规范
          2. 版本订购规格
          3. 版本顺序测试
          4. 排除
        2. 继承
          1. 超级POM
          2. 依赖性管理
        3. 聚合(或多模块)
          1. 继承.聚合
      3. 特性
    3. 生成设置
      1. 建房
        1. BaseBuild元素集
          1. 资源
          2. 插件
          3. 插件管理
        2. 构建元素集
          1. 目录
          2. 扩展
      2. 报告
        1. 报表集
    4. 更多项目信息
      1. 许可证
      2. 组织
      3. 开发商
      4. 投稿人
    5. 环境设置
      1. 问题管理
      2. 持续集成管理
      3. 邮寄名单
      4. 供应链管理
      5. 先决条件
      6. 储存库
      7. 插件库
      8. 配送管理
        1. 储存库
        2. 场地分布
        3. 搬迁
      9. 剖面图
        1. 活化
        2. BaseBuild元素集*(重新审查)*
    6. 最终

    导言

    什么是战俘?

    POM代表“项目对象模型”。它是保存在名为pom.xml。当Maven人员在场时,谈论一个项目是在哲学意义上,而不仅仅是一组包含代码的文件。项目包含配置文件,以及所涉及的开发人员和他们所扮演的角色、缺陷跟踪系统、组织和许可证、项目所在位置的URL、项目的依赖关系,以及为代码生命发挥作用的所有其他小部件。这是一个一站式的商店,所有与项目有关的东西.事实上,在Maven世界中,一个项目根本不需要包含任何代码,只需要包含一个pom.xml.

    快速概述

    这是POM项目元素直接下的元素列表。注意modelVersion包含4.0.0。这是目前唯一支持的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>   <!-- The Basics -->  <groupId>...</groupId>  <artifactId>...</artifactId>  <version>...</version>  <packaging>...</packaging>  <dependencies>...</dependencies>  <parent>...</parent>  <dependencyManagement>...</dependencyManagement>  <modules>...</modules>  <properties>...</properties>   <!-- Build Settings -->  <build>...</build>  <reporting>...</reporting>   <!-- More Project Information -->  <name>...</name>  <description>...</description>  <url>...</url>  <inceptionYear>...</inceptionYear>  <licenses>...</licenses>  <organization>...</organization>  <developers>...</developers>  <contributors>...</contributors>   <!-- Environment Settings -->  <issueManagement>...</issueManagement>  <ciManagement>...</ciManagement>  <mailingLists>...</mailingLists>  <scm>...</scm>  <prerequisites>...</prerequisites>  <repositories>...</repositories>  <pluginRepositories>...</pluginRepositories>  <distributionManagement>...</distributionManagement>  <profiles>...</profiles></project>
    

    基础

    POM包含有关项目的所有必要信息,以及在构建过程中使用的插件配置。它是“谁”、“什么”和“何处”的声明性表现,而构建生命周期是“何时”和“如何”。这并不是说POM不能影响生命周期的流程-它可以。例如,通过配置maven-antrun-plugin,可以将ApacheAnt任务嵌入POM中。然而,这最终是一项宣言。鉴于build.xml精确地告诉Ant在运行时应该做什么(过程),POM声明它的配置(声明性)。如果某些外部力量导致生命周期跳过Ant插件的执行,它不会阻止执行的插件执行它们的魔力。这与build.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>org.codehaus.mojo</groupId>  <artifactId>my-project</artifactId>  <version>1.0</version></project>
    

    Maven坐标

    上面定义的POM是Maven允许的最小值。groupId:artifactId:version都是必需的字段(但是,如果是从父级继承的话,不需要显式地定义groupId和version–稍后将详细介绍它们)。这三个字段很像一个地址和时间戳。这标志着存储库中的特定位置,就像Maven项目的坐标系统一样:

    • 这在一个组织或项目中通常是独一无二的。例如,所有核心Maven工件都会(很好,应该)生活在groupId下面org.apache.maven。组ID不一定使用点表示法,例如junit项目。注意,点标记的groupId不必与项目包含的包结构相对应。然而,这是一个很好的做法。当存储在存储库中时,组的作用就像Java打包结构在操作系统中所做的那样。点被OS特定的目录分隔符(如Unix中的‘/’)所取代,后者成为基本存储库中的相对目录结构。在给出的示例中,org.codehaus.mojo组位于目录中。$M2_REPO/org/codehaus/mojo.
    • ArfactId:artifactId通常是项目的名称。虽然groupId很重要,但小组中的人在讨论中很少提到groupId(它们通常都是相同的ID,例如莫若豪斯项目组:org.codehaus.mojo)。它和groupId一起创建了一个键,将该项目与世界上的每个其他项目分离开来(至少,它应该:)。与groupId一起,artifactId完全定义了存储库中工件的生活区。就上述项目而言,my-project住在$M2_REPO/org/codehaus/mojo/my-project.
    • 版本这是命名难题的最后一块。groupId:artifactId表示单个项目,但它们不能描述我们正在讨论的项目的具体体现。我们想要junit:junit2018年(4.12版)还是2007年(3.8.2版)?简而言之:代码更改,这些更改应该是版本化的,并且这个元素使这些版本保持一致。它还被用于工件的存储库中,以将版本彼此分离。my-project版本1.0文件位于目录结构中$M2_REPO/org/codehaus/mojo/my-project/1.0.

    上面给出的三个元素指向一个特定版本的项目,让Maven知道我们正在处理,而且什么时候在它的软件生命周期中,我们需要它们。

    包装

    现在我们有了地址结构groupId:artifactId:version,还有一个标准标签可以给我们一个真正完整的标签。什么这是项目的包装。在我们的例子中,org.codehaus.mojo:my-project:1.0上面定义的将被打包为jar。我们可以把它变成war通过声明不同的包装:

    <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">  ...  <packaging>war</packaging>  ...</project>
    

    当没有声明任何打包时,Maven假设打包是默认的:jar。有效的类型是Plexus角色提示(阅读更多关于Plexus的角色和角色提示的说明)。org.apache.maven.lifecycle.mapping.LifecycleMapping。当前的核心包装值是:pom, jar, maven-plugin, ejb, war, ear, rar。这些定义了在特定包结构的每个相应构建生命周期阶段执行的默认目标列表:默认生命周期引用的插件绑定关于细节。

    POM关系

    Maven的一个强大方面是它对项目关系的处理:这包括依赖关系(和传递依赖)、继承和聚合(多模块项目)。

    依赖关系管理有一个悠久的传统,除了最琐碎的项目之外,任何事情都是复杂的混乱。*“Jarmageddon”当依赖树变得庞大和复杂时,很快就会发生。“罐子地狱”*接下来,如果一个系统上的依赖关系版本与所给出的错误版本或类似命名的JAR之间的冲突版本所开发的版本不等效。

    Maven通过一个通用的本地存储库解决了这两个问题,从该存储库可以正确地链接项目、版本和所有内容。

    相依性

    POM的基石是依赖性名单。大多数项目依赖于其他项目来正确构建和运行。如果Maven为您所做的就是管理这个列表,那么您已经收获了很多。Maven下载并链接编译上的依赖项以及其他需要它们的目标。作为额外的奖励,Maven引入了这些依赖项(传递依赖项)的依赖项,允许您的列表只关注项目所需的依赖项。

    <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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <dependencies>    <dependency>      <groupId>junit</groupId>      <artifactId>junit</artifactId>      <version>4.12</version>      <type>jar</type>      <scope>test</scope>      <optional>true</optional>    </dependency>    ...  </dependencies>  ...</project>
    
    • 群ArfactId版本:

      你会经常看到这些元素。这个三位一体用于及时计算特定项目的Maven坐标,并将其划分为该项目的依赖关系。此计算的目的是选择一个与所有依赖声明匹配的版本(由于传递依赖关系,同一工件可以有多个依赖声明)。这些价值应该是:

      • , ArfactId直接对应依赖关系的坐标,
      • 版本a依赖型版本需求规范*,用于计算依赖项的有效版本。

      由于依赖关系是由Maven坐标描述的,您可能会想:“这意味着我的项目只能依赖于Maven工件!”答案是,“当然,但这是一件好事。”这迫使您完全依赖Maven可以管理的依赖项。

      不幸的是,有时无法从中央Maven存储库下载项目。例如,一个项目可能依赖于一个JAR,该JAR拥有一个封闭的源许可证,从而阻止它位于中央存储库中。处理此场景有三种方法。

      1. 使用安装插件在本地安装依赖项。该方法是最简单的推荐方法。例如:

        mvn install:install-file -Dfile=non-maven-proj.jar -DgroupId=some.group -DartifactId=non-maven-proj -Dversion=1 -Dpackaging=jar
        

        请注意,仍然需要一个地址,只有这次使用命令行和安装插件才能为您创建一个具有给定地址的POM。

      2. 创建自己的存储库并将其部署到那里。对于拥有内部网的公司来说,这是一种最受欢迎的方法,并且需要能够使每个人保持同步。有一个名为Maven的目标deploy:deploy-fileinstall:install-file目标(阅读插件的目标页面以获得更多信息)。

      3. 将依赖范围设置为system并定义systemPath。然而,我们不建议这样做,但这会导致我们解释以下要素:

    • 分类器:

      分类器区分从同一个POM构建但内容不同的工件。它是一些可选的任意字符串–如果存在的话–就在版本号后面附加到工件名称。

      作为这个元素的一个动机,考虑一个项目,它提供了一个针对Java 11的工件,但同时也提供了一个仍然支持Java1.8的工件。第一个工件可以配备分类器。jdk11第二个jdk8以便客户端可以选择使用哪一个。

      分类器的另一个常见用例是将次要工件附加到项目的主要工件上。如果浏览Maven中央存储库,您将注意到sourcesjavadoc用于部署项目源代码和API文档以及打包的类文件。

    • 类型:
      对应于所选的依赖类型。这默认为jar。虽然它通常表示依赖项的文件名上的扩展名,但情况并不总是这样:类型可以映射到不同的扩展和分类器。这种类型通常与所使用的包装相对应,尽管也并非总是如此。以下是一些例子jar, ejb-clienttest-jar*见默认工件处理程序为了一份名单。新类型可以由设置为extensions为真,所以这不是一个完整的列表。

    • 范围:

      此元素引用手头任务的类路径(编译和运行时、测试等)。以及如何限制依赖的传递性。有五个范围可用:

      • 编译-这是默认范围,如果没有指定,则使用。编译依赖项在所有类路径中都可用。此外,这些依赖项被传播到依赖项目。
      • 提供-这非常类似于编译,但表示您希望JDK或容器在运行时提供它。它只能在编译和测试类路径上使用,而不是传递性的。
      • 运行时-此范围表示编译时不需要依赖项,而是执行所需的依赖项。它位于运行时和测试类路径中,而不是编译类路径中。
      • 试验-这个范围表明,正常使用应用程序不需要依赖项,而且只能在测试编译和执行阶段使用。这不是传递性的。
      • 系统-这一范围类似于provided但您必须提供包含它的JAR。工件总是可用的,不在存储库中查找。
    • 系统路径:
      使用如果依赖项scopesystem。否则,如果设置此元素,则生成将失败。路径必须是绝对的,因此建议使用属性来指定特定于机器的路径(更多信息)。properties),例如${java.home}/lib。因为假定安装了系统作用域依赖项。先验,Maven不检查项目的存储库,而是检查以确保文件存在。如果没有,Maven会失败,建议您手动下载并安装它。

    • 任选:

      当此项目本身是依赖项时,标记依赖项可选。例如,想象一个项目

      A
      

      这取决于项目

      B
      

      若要编译可能在运行时不使用的部分代码,则可能不需要项目。

      B
      

      所有项目。所以如果计划

      X
      

      添加项目

      A
      

      作为自己的依赖项,则Maven不需要安装项目。

      B
      

      完全没有。象征性地,如果

      =>
      

      表示所需的依赖项,以及

      -->
      

      表示可选的,尽管

      A=>B
      

      可能是建A时的情况

      X=>A-->B
      

      当建造

      X
      

      .

      在最短的时间内,optional让其他项目知道,当您使用此项目时,您不需要此依赖项才能正确工作。

    依赖性版本需求规范

    相依性version元素定义版本需求,用于计算依赖版本。软需求可以被其他依赖关系图中发现的相同工件的不同版本所取代。硬需求强制执行一个或多个版本,并覆盖软需求。如果没有满足该工件的所有硬需求的依赖版本,则构建失败。

    版本要求有以下语法:

    • 1.0*1.0的软要求。如果依赖树中前面没有出现其他版本,请使用1.0。

    • [1.0]对1.0的严格要求。使用1.0,只使用1.0。

    • (,1.0]任何版本都需要<=1.0。

    • [1.2,1.3]*对1.2和1.3之间任何版本的严格要求。

    • [1.0,2.0)::1.0<=x<2.0;任何版本在1.0包含性和2.0排他性之间的硬要求。

    • [1.5,)*任何大于或等于1.5版本的硬性要求。

    • (,1.0],[1.2,)*任何版本小于或等于1.0或大于或等于1.2但不等于1.1的硬性要求。多个要求用逗号分隔。

    • (,1.1),(1.1,)
      

      对任何版本(1.1除外)的严格要求;例如,因为1.1有一个严重的漏洞。

      Maven选择每个项目的最高版本,以满足该项目依赖项的所有硬需求。如果没有任何版本满足所有硬需求,则构建失败。

    版本订购规格:

    如果版本字符串在语法上是正确的语义版本控制1.0.0版本号,在几乎所有情况下,版本比较都遵循该规范中概述的优先级规则。这些版本是常见的字母数字ASCII字符串,如2.15.2-alpha。更准确地说,如果要比较的两个版本号与语义版本规范中的BNF语法中的“有效Sverver”生成相匹配,则这是正确的。Maven不考虑该规范所暗示的任何语义。

    重要这只适用于语义版本控制1.0.0*。Maven版本顺序算法与语义版本控制不兼容。2.0.0。特别是,Maven并不是特例加号或考虑构建标识符。

    当版本字符串不遵循语义版本控制时,需要一组更复杂的规则。Maven坐标在点之间被拆分成标记(‘.)、连字符(‘)-)和数字与字符之间的转换。分隔符将被记录下来,并将对订单产生影响。数字和字符之间的转换相当于连字符。空令牌被替换为“0“.这给出了版本号(数字标记)和版本限定符(非数字标记)的序列,其中”.“或”-“前缀。

    分裂和替换实例:

    • 1-1.foo-bar1baz-.1 -> 1-1.foo-bar-1-baz-0.1

    然后,从版本的末尾开始,尾随的“NULL”值(0, "", “final”, "ga“)被裁剪。此过程将在每个剩馀的连字符处从头开始重复。

    修剪示例:

    • 1.0.0 -> 1
    • 1.ga -> 1
    • 1.final -> 1
    • 1.0 -> 1
    • 1. -> 1
    • 1- -> 1
    • 1.0.0-foo.0.0 -> 1-foo
    • 1.0.0-0.0.0 -> 1

    版本顺序是lexicographical order在这个前缀标记序列上,较短的标记填充了足够多的“NULL”值,并具有匹配的前缀,其长度与长的相同。填充的“NULL”值依赖于其他版本的前缀:0表示‘.’、“for‘-’。前缀令牌顺序是:

    • 如果前缀相同,则比较令牌:

      • 数字符号具有自然顺序。

      • 非数字(“限定符”)标记按字母顺序排列,但以下标记按此顺序排在第一位:

        alpha” < “beta” < “milestone” < “rc” = “cr” < “snapshot” < “” = “final” = “ga” < “sp

        • alpha", "beta“和”milestone“限定符可以分别缩短为”a“,”b“和”m“,当直接后面跟着一个数字。
    • 其他“.qualifier" < “-qualifier” < “-number” < “.number

    最终结果实例:

    • 1” < "1.1“(数字填充)

    • 1-snapshot” < “1” < "1-sp“(限定符填充)

    • 1-foo2” < "1-foo10“(正确地自动”切换“为数字顺序)

    • 1.foo” < “1-foo” < “1-1” < “1.1

    • 1.ga” = “1-ga” = “1-0” = “1.0” = "1“(移除尾随的”空“值)

    • 1-sp” > “1-ga

    • 1-sp.1” > “1-ga.1

    • 1-sp-1” < “1-ga-1” = "1-1“(在每个连字符处尾随”NULL“值)

    • "

      1-a1
      

      " = "

      1-alpha-1
      

      "

      注意:与某些设计文档中的声明相反,对于版本顺序,快照与版本或任何其他限定符没有区别。

    版本顺序测试:

    Maven发行版包括一个检查版本顺序的工具。它被用来产生前几段中的例子。有疑问的时候可以自己操作。你可以这样运行:

    java -jar ${MAVEN_HOME}/lib/maven-artifact-3.3.9.jar [versions...]
    

    例子:

    $ java -jar ./lib/maven-artifact-3.3.9.jar  1 2 1.1
    Display parameters as parsed by Maven (in canonical form) and comparison result:
    1. 1 == 1
       1 < 2
    2. 2 == 2
       2 > 1.1
    3. 1.1 == 1.1
    
    排除

    排除告诉Maven不要包含指定的项目,该项目是该依赖项的依赖项(换句话说,它的传递依赖项)。例如,maven-embedder要求maven-core,我们不希望使用它或它的依赖项,然后将其添加为exclusion.

    <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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <dependencies>    <dependency>      <groupId>org.apache.maven</groupId>      <artifactId>maven-embedder</artifactId>      <version>2.0</version>      <exclusions>        <exclusion>          <groupId>org.apache.maven</groupId>          <artifactId>maven-core</artifactId>        </exclusion>      </exclusions>    </dependency>    ...  </dependencies>  ...</project>
    

    有时还可以剪短依赖项的传递依赖关系。依赖项可能有错误指定的作用域,或者与项目中的其他依赖项冲突的依赖项。使用通配符排除可以方便地排除所有依赖项的传递依赖项。在下面的情况中,您可能正在使用maven-Embedder,并且您希望管理您自己使用的依赖关系,因此您可以剪辑所有传递的依赖关系:

    <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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <dependencies>    <dependency>      <groupId>org.apache.maven</groupId>      <artifactId>maven-embedder</artifactId>      <version>3.1.0</version>      <exclusions>        <exclusion>          <groupId>*</groupId>          <artifactId>*</artifactId>        </exclusion>      </exclusions>    </dependency>    ...  </dependencies>  ...</project>
    
    • 排除*不适用条款包含一个或多个exclusion元素,每个元素都包含groupIdartifactId表示要排除的依赖关系。不像optional可以安装或不安装和使用的,exclusions主动从依赖树中删除自身。

    继承

    Maven为构建管理带来的一个强大的补充是项目继承的概念。虽然在构建系统(如Ant继承)中可以模拟,但Maven在项目对象模型中使项目继承显式化。

    <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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  <modelVersion>4.0.0</modelVersion>   <groupId>org.codehaus.mojo</groupId>  <artifactId>my-parent</artifactId>  <version>2.0</version>  <packaging>pom</packaging></project>
    

    这个packaging所需的类型pom父母聚集(多模块)项目。这些类型定义了绑定到一组生命周期阶段的目标。例如,如果打包是jar,然后package阶段将执行jar:jar进球。现在,我们可以向父POM添加值,它将由其子级继承。父POM的大多数元素由其子元素继承,包括:

    • 版本
    • 描述
    • URL
    • 开学年
    • 组织
    • 许可证
    • 开发商
    • 投稿人
    • 邮递员
    • 供应链管理
    • 问题管理
    • 信息管理
    • 特性
    • 依赖管理
    • 相依性
    • 储存库
    • PluginRepository
    • 建房
      • 具有匹配ID的插件执行
      • 插件配置
      • 等。
    • 报告
    • 剖面图

    值得注意的是not继承的包括:

    • ArfactId
    • 名字
    • 先决条件
    <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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  <modelVersion>4.0.0</modelVersion>   <parent>    <groupId>org.codehaus.mojo</groupId>    <artifactId>my-parent</artifactId>    <version>2.0</version>    <relativePath>../my-parent</relativePath>  </parent>   <artifactId>my-project</artifactId></project>
    

    注意relativePath元素。它不是必需的,但可以用作Maven的一个表示符,以便在搜索本地和远程存储库之前,首先搜索该项目的父级路径。

    若要查看运行中的继承,只需查看ASF马文家长的。

    超级POM

    类似于面向对象编程中对象的继承,扩展父POM的POMS从父对象继承某些值。此外,正如Java对象最终继承自java.lang.Object,所有ProjectObject模型都继承自基本超级POM。下面的片段是Maven 3.5.4的超级POM。

    <project>  <modelVersion>4.0.0</modelVersion>   <repositories>    <repository>      <id>central</id>      <name>Central Repository</name>      <url>https://repo.maven.apache.org/maven2</url>      <layout>default</layout>      <snapshots>        <enabled>false</enabled>      </snapshots>    </repository>  </repositories>   <pluginRepositories>    <pluginRepository>      <id>central</id>      <name>Central Repository</name>      <url>https://repo.maven.apache.org/maven2</url>      <layout>default</layout>      <snapshots>        <enabled>false</enabled>      </snapshots>      <releases>        <updatePolicy>never</updatePolicy>      </releases>    </pluginRepository>  </pluginRepositories>   <build>    <directory>${project.basedir}/target</directory>    <outputDirectory>${project.build.directory}/classes</outputDirectory>    <finalName>${project.artifactId}-${project.version}</finalName>    <testOutputDirectory>${project.build.directory}/test-classes</testOutputDirectory>    <sourceDirectory>${project.basedir}/src/main/java</sourceDirectory>    <scriptSourceDirectory>${project.basedir}/src/main/scripts</scriptSourceDirectory>    <testSourceDirectory>${project.basedir}/src/test/java</testSourceDirectory>    <resources>      <resource>        <directory>${project.basedir}/src/main/resources</directory>      </resource>    </resources>    <testResources>      <testResource>        <directory>${project.basedir}/src/test/resources</directory>      </testResource>    </testResources>    <pluginManagement>      <!-- NOTE: These plugins will be removed from future versions of the super POM -->      <!-- They are kept for the moment as they are very unlikely to conflict with lifecycle mappings (MNG-4453) -->      <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.8</version>        </plugin>        <plugin>          <artifactId>maven-release-plugin</artifactId>          <version>2.5.3</version>        </plugin>      </plugins>    </pluginManagement>  </build>   <reporting>    <outputDirectory>${project.build.directory}/site</outputDirectory>  </reporting>   <profiles>    <!-- NOTE: The release profile will be removed from future versions of the super POM -->    <profile>      <id>release-profile</id>       <activation>        <property>          <name>performRelease</name>          <value>true</value>        </property>      </activation>       <build>        <plugins>          <plugin>            <inherited>true</inherited>            <artifactId>maven-source-plugin</artifactId>            <executions>              <execution>                <id>attach-sources</id>                <goals>                  <goal>jar-no-fork</goal>                </goals>              </execution>            </executions>          </plugin>          <plugin>            <inherited>true</inherited>            <artifactId>maven-javadoc-plugin</artifactId>            <executions>              <execution>                <id>attach-javadocs</id>                <goals>                  <goal>jar</goal>                </goals>              </execution>            </executions>          </plugin>          <plugin>            <inherited>true</inherited>            <artifactId>maven-deploy-plugin</artifactId>            <configuration>              <updateReleaseInfo>true</updateReleaseInfo>            </configuration>          </plugin>        </plugins>      </build>    </profile>  </profiles> </project>
    

    您可以看看超级POM是如何通过创建最小值来影响您的项目对象模型的。pom.xml并在命令行上执行:mvn help:effective-pom

    依赖性管理

    除了继承某些顶级元素外,父级元素还具有为子Poms和传递依赖项配置值的元素。其中一个要素是dependencyManagement.

    • 依赖管理

      POM用于帮助管理其所有子级的依赖信息。如果

      my-parent
      

      项目用途

      dependencyManagement
      

      若要定义依赖项,请执行以下操作

      junit:junit:4.12
      

      ,则从此继承的Poms可以设置它们的依赖项,从而使

      groupId
      

      =

      junit
      

      artifactId
      

      =

      junit
      

      只有和Maven将填写

      version
      

      由父母设定。这种方法的好处是显而易见的。依赖关系详细信息可以设置在一个中心位置,该位置传播到所有继承的POMS。

      请注意,来自传递依赖项的工件的版本和范围也由依赖关系管理部分的版本规范控制。这会导致意想不到的后果。假设您的项目使用两个依赖项,dep1dep2. dep2反过来也使用dep1,并且需要一个特定的最低版本才能运行。如果你用dependencyManagement若要指定旧版本,dep2将被迫使用旧版本,并失败。因此,您必须小心检查整个依赖树以避免此问题;mvn dependency:tree是有帮助的。

    聚集(或多模块)

    带有模块的项目称为多模块或聚合器项目。模块是该POM列出的项目,并作为一个组执行。一个pom打包项目可以将一组项目的构建作为模块列出,这些模块是指向这些项目的目录或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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  <modelVersion>4.0.0</modelVersion>   <groupId>org.codehaus.mojo</groupId>  <artifactId>my-parent</artifactId>  <version>2.0</version>  <packaging>pom</packaging>   <modules>    <module>my-project</module>    <module>another-project</module>    <module>third-project/pom-example.xml</module>  </modules></project>
    

    在列出模块时,不需要自己考虑模块间的依赖关系;也就是说,POM给出的模块排序并不重要。Maven将对模块进行拓扑排序,以便始终在依赖模块之前构建依赖项。

    若要查看活动中的聚合,请查看马文Maven核心插件基地警察。

    最后说明继承.聚合

    继承和聚合创建了一个很好的动态,通过单一的、高级别的POM来控制构建。您经常会看到项目既是父项目又是聚合器。例如,整个Maven核心运行在一个单一的基本POM中。org.apache.maven:maven,因此构建Maven项目可以通过一个命令执行:mvn compile。但是,聚合器项目和父项目都是POM项目,它们不一样,不应该混淆。POM项目可以从它聚合的任何模块继承(但不一定有)。相反,POM项目可能聚合不继承的项目。

    特性

    属性是理解POM基础知识的最后一部分。Maven属性是值占位符,类似于Ant中的属性。它们的值可以在POM中的任何地方使用表示法访问。${X},在哪里X是财产。或者插件可以将它们用作默认值,例如:

    <project>  ...  <properties>    <maven.compiler.source>1.7</maven.compiler.source>    <maven.compiler.target>1.7</maven.compiler.target>    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>  </properties>  ...</project>
    

    它们有五种不同的风格:

    1. env.X
      

      *以“env”作为变量的前缀。将返回shell的环境变量。例如,

      ${env.PATH}
      

      包含PATH环境变量。

      *注:*虽然环境变量本身在Windows上是不区分大小写的,但是查找属性是区分大小写的.换句话说,当Windowsshell返回相同的值时,%PATH%%Path%,Maven区分${env.PATH}${env.Path}. **环境变量的名称被标准化为所有大写。**为了可靠。

    2. project.x*点(.)POM中的标注路径将包含相应元素的值。例如:<project><version>1.0</version></project>是通过${project.version}.

    3. settings.x*点(.)中的缺口路径。settings.xml将包含相应元素的值。例如:<settings><offline>false</offline></settings>是通过${settings.offline}.

    4. Java系统属性:通过java.lang.System.getProperties()作为POM属性可用,如${java.home}.

    5. x*设置在<properties />元素在POM中。价值<properties><someVar>value</someVar></properties>可用作${someVar}.

    生成设置

    除了上面给出的POM的基本知识之外,在声明POM的基本能力之前,还必须理解另外两个元素。他们是build元素,它处理诸如声明项目的目录结构和管理插件;以及reporting元素,它在很大程度上反映了用于报告目的的构建元素。

    建房

    根据POM4.0.0 XSD,build元素在概念上分为两个部分:BaseBuild类型,它包含两种类型所共有的元素集。build元素(在project中的构建元素profiles,下面介绍);Build类型,其中包含BaseBuild为顶层定义设置更多元素。让我们首先分析两者之间的共同因素。

    注:这些不同 build 元素可以表示为“项目构建”和“配置文件构建”。

    <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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <!-- "Project Build" contains more elements than just the BaseBuild set -->  <build>...</build>   <profiles>    <profile>      <!-- "Profile Build" contains a subset of "Project Build"s elements -->      <build>...</build>    </profile>  </profiles></project>
    

    这个BaseBuild元素集

    BaseBuild与听起来完全相同:两者之间的基本元素集。buildPOM中的元素。

    <build>
      <defaultGoal>install</defaultGoal>
      <directory>${basedir}/target</directory>
      <finalName>${artifactId}-${version}</finalName>
      <filters>
        <filter>filters/filter1.properties</filter>
      </filters>
      ...
    </build>
    
    • 违约目标如果没有给出执行的默认目标或阶段。如果给定了目标,则应该按照命令行中的情况定义它(如jar:jar)。如果定义了一个阶段(例如安装),同样的情况也是如此。

    • 目录这是构建将转储其文件的目录,或者,用Maven的说法,它是构建的目标。它恰如其分地默认为${basedir}/target.

    • FinalName*这是捆绑项目最终生成时的名称(例如,没有文件扩展名):my-project-1.0.jar)。默认为${artifactId}-${version}。然而,术语“finalName”是一种用词不当的说法,因为构建捆绑项目的插件完全有权忽略/修改这个名称(但它们通常不会)。例如,如果maven-jar-plugin配置为给JAR一个classifiertest,则上面定义的实际JAR将构建为my-project-1.0-test.jar.

    • 滤光器

      *界定

      *.properties
      

      包含应用于接受其设置的资源的属性列表的文件(见下文)。换句话说,“

      name=value
      

      “在筛选器文件中定义的对替换

      ${name}
      

      构建资源中的字符串。上面的示例定义了

      filter1.properties
      

      文件在

      filters/
      

      目录。Maven的默认筛选目录是

      ${basedir}/src/main/filters/
      

      .

      要更全面地了解过滤器是什么以及它们可以做什么,请看一下快速启动指南.

    资源

    另一个特点build元素指定项目中存在资源的位置。资源不是(通常)代码。它们不是编译的,而是要捆绑在项目中的项,或者是出于其他各种原因使用的,例如代码生成。

    例如,Plexus项目需要一个configuration.xml文件(它指定容器的组件配置)驻留在META-INF/plexus目录。虽然我们可以很容易地把这个文件放在src/main/resources/META-INF/plexus,我们希望为Plexus提供自己的目录src/main/plexus。为了使JAR插件能够正确地捆绑资源,您应该指定类似于以下内容的资源:

    <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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  <build>    ...    <resources>      <resource>        <targetPath>META-INF/plexus</targetPath>        <filtering>false</filtering>        <directory>${basedir}/src/main/plexus</directory>        <includes>          <include>configuration.xml</include>        </includes>        <excludes>          <exclude>**/*.properties</exclude>        </excludes>      </resource>    </resources>    <testResources>      ...    </testResources>    ...  </build></project>
    
    • 资源*是资源元素的列表,每个元素描述与此项目相关的文件的内容和位置。
    • 目标路径指定从生成中放置资源集的目录结构。目标路径默认为基目录。将打包在JAR中的资源的一个共同指定的目标路径是meta-INF。
    • 过滤*是truefalse,表示是否对此资源启用筛选。注意,那个过滤器*.properties不必定义文件才能进行筛选–资源也可以使用默认情况下在POM中定义的属性(如${project.version}),这些属性使用“-D”标志传递到命令行(例如,“-Dname=value“)或由属性元素显式定义。过滤器文件已在上面讨论过。
    • 目录该元素的值定义了资源的位置。构建的默认目录是${basedir}/src/main/resources.
    • 包括::一组文件模式,它使用*作为通配符指定要包含的文件作为该指定目录下的资源。
    • 不包括*与includes,但指定要忽略哪些文件。在冲突中includeexclude, exclude赢了。
    • 测试资源*testResources元素块包含testResource元素。它们的定义类似于resource元素,但在测试阶段自然使用。一个不同之处是,项目的默认测试资源目录(SuperPOM定义)是${basedir}/src/test/resources。没有部署测试资源。
    插件
    <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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  <build>    ...    <plugins>      <plugin>        <groupId>org.apache.maven.plugins</groupId>        <artifactId>maven-jar-plugin</artifactId>        <version>2.6</version>        <extensions>false</extensions>        <inherited>true</inherited>        <configuration>          <classifier>test</classifier>        </configuration>        <dependencies>...</dependencies>        <executions>...</executions>      </plugin>    </plugins>  </build></project>
    

    超过标准坐标groupId:artifactId:version,有些元素可以配置插件,或者与插件进行交互。

    • 扩展: truefalse,是否加载此插件的扩展。这在默认情况下是假的。扩展将在本文档后面讨论。

    • 继承: truefalse,此插件配置是否适用于继承此插件的POMS。默认值是true.

    • 配置

      这是针对单个插件的。在不深入讨论插件工作机制的情况下,只需在这里指定插件Mojo可能期望的任何属性(它们是JavaMojobean中的getter和setter)。在上面的示例中,我们将分类器属性设置为在

      maven-jar-plugin
      

      值得注意的是,所有配置元素,无论它们在POM中,都是为了将值传递给另一个底层系统,例如插件。

      configuration
      

      元素从来不被POM模式显式地要求,但是插件目标完全有权要求配置值。

      如果您的POM声明了一个父级,那么它将继承从构建/插件插件管理父级的部分。

      为了举例说明,请考虑来自父POM的以下片段:

      <plugin><groupId>my.group</groupId><artifactId>my-plugin</artifactId><configuration>  <items>    <item>parent-1</item>    <item>parent-2</item>  </items>  <properties>    <parentKey>parent</parentKey>  </properties></configuration></plugin>
      

      并考虑使用该父程序作为父程序的项目的以下插件配置:

      <plugin><groupId>my.group</groupId><artifactId>my-plugin</artifactId><configuration>  <items>    <item>child-1</item>  </items>  <properties>    <childKey>child</childKey>  </properties></configuration>
      

      默认行为是合并配置元素名称。如果子POM具有特定元素,则该值将成为有效值。如果子POM没有元素,但父元素有,则父值成为有效值。请注意,这纯粹是对XML的操作;不涉及插件本身的代码或配置。只涉及要素,而不是其价值。

      将这些规则应用到示例中,Maven提出:

      <plugin><groupId>my.group</groupId><artifactId>my-plugin</artifactId><configuration>  <items>    <item>child-1</item>  </items>  <properties>    <childKey>child</childKey>    <parentKey>parent</parentKey>  </properties></configuration>
      

      控件的子部件添加属性,从而控制子Poms如何从父Poms继承配置。配置元素。属性是combine.childrencombine.self。在子POM中使用这些属性来控制Maven如何将来自父程序的插件配置与子配置中的显式配置结合起来。

      下面是两个属性的说明的子配置:

      <configuration>  <items combine.children="append">    <!-- combine.children="merge" is the default -->    <item>child-1</item>  </items>  <properties combine.self="override">    <!-- combine.self="merge" is the default -->    <childKey>child</childKey>  </properties></configuration>
      

      现在,有效的结果如下:

      <configuration>  <items combine.children="append">    <item>parent-1</item>    <item>parent-2</item>    <item>child-1</item>  </items>  <properties combine.self="override">    <childKey>child</childKey>  </properties></configuration>
      

      **子类=“附加”按顺序将父元素和子元素连接在一起。Self=“重写”,另一方面,完全抑制父配置。你不能同时使用Self=“重写”子类=“附加”**在元素上;如果您尝试,覆盖会占上风。

      请注意,这些属性只适用于在其上声明的配置元素,而不是传播到嵌套元素。的内容项目来自子POM的元素是一个复杂的结构,而不是文本,它的子元素将仍然受制于默认的合并策略,除非它们本身被标记为属性。

      组合.*属性是从父级继承到子级的。在将这些属性添加到父POM时要小心,因为这可能会影响子或大子POMS。

    • 相依性依赖关系在POM中可以看到很多,并且是所有插件元素块下的一个元素。依赖项的结构和功能与基础构建下的结构和功能相同。本例中的主要区别在于,它们现在不是作为项目的依赖项应用,而是作为它们所处插件的依赖项应用。它的强大功能是修改插件的依赖列表,可能是通过以下方式删除未使用的运行时依赖项。exclusions,或者通过更改所需依赖项的版本。见上文在相依性想了解更多信息。

    • 处决

      重要的是要记住,一个插件可能有多个目标。每个目标可能有单独的配置,甚至可能将插件的目标绑定到完全不同的阶段。

      executions
      

      配置

      execution
      

      插件的目标。

      例如,假设您希望绑定antrun:run目标verify相位。我们希望任务回显构建目录,并避免通过设置将此配置传递给其子配置(假设它是父配置)。inheritedfalse。你会得到一个execution就像这样:

      <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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <build>    <plugins>      <plugin>        <artifactId>maven-antrun-plugin</artifactId>        <version>1.1</version>        <executions>          <execution>            <id>echodir</id>            <goals>              <goal>run</goal>            </goals>            <phase>verify</phase>            <inherited>false</inherited>            <configuration>              <tasks>                <echo>Build Dir: ${project.build.directory}</echo>              </tasks>            </configuration>          </execution>        </executions>       </plugin>    </plugins>  </build></project>
      
    • ID*不言自明。它指定了其他所有执行块之间的执行块。当运行阶段时,它将以下列形式显示:[plugin:goal execution: id]。在本例中:[antrun:run execution: echodir]

    • 目标与所有多元POM元素一样,它包含一个单数元素列表。在本例中,插件列表goals中指定的execution封锁。

    • 相位*这是目标清单将要执行的阶段。这是一个非常强大的选项,允许将任何目标绑定到构建生命周期的任何阶段,从而改变Maven的默认行为。

    • 继承*就像inherited元素,将其设置为false将阻止Maven将此执行传递给其子元素。此元素仅对父Poms有意义。

    • 配置:和上面一样,但是将配置限制在这个特定的目标列表上,而不是插件下的所有目标。

    插件管理
    • 插件管理*是一个元素,可以看到的是边插件。PluginManagement以同样的方式包含插件元素,只不过它不是为这个特定的项目构建配置插件信息,而是为了配置从这个项目中继承的项目构建。但是,这只会配置实际上在子级的plugins元素或当前POM中引用的插件。孩子们完全有权推翻pluginManagement定义。
    <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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <build>    ...    <pluginManagement>      <plugins>        <plugin>          <groupId>org.apache.maven.plugins</groupId>          <artifactId>maven-jar-plugin</artifactId>          <version>2.6</version>          <executions>            <execution>              <id>pre-process-classes</id>              <phase>compile</phase>              <goals>                <goal>jar</goal>              </goals>              <configuration>                <classifier>pre-process</classifier>              </configuration>            </execution>          </executions>        </plugin>      </plugins>    </pluginManagement>    ...  </build></project>
    

    如果我们将这些规范添加到plugins元素中,它们将只适用于单个POM。但是,如果我们在pluginManagement元素,则此POM所有继承的波姆斯添加maven-jar-plugin到构建时,将获得pre-process-classes执行死刑。所以,与其把上面的烂摊子包括在每个孩子身上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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <build>    ...    <plugins>      <plugin>        <groupId>org.apache.maven.plugins</groupId>        <artifactId>maven-jar-plugin</artifactId>      </plugin>    </plugins>    ...  </build></project>
    

    这个构建元素集

    这个BuildXSD中的类型表示那些仅用于“项目构建”的元素。尽管有额外的元素(6个),但实际上只有两组项目构建中缺少的元素:目录和扩展。

    目录

    目录元素集位于父构建元素中,它为整个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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <build>    <sourceDirectory>${basedir}/src/main/java</sourceDirectory>    <scriptSourceDirectory>${basedir}/src/main/scripts</scriptSourceDirectory>    <testSourceDirectory>${basedir}/src/test/java</testSourceDirectory>    <outputDirectory>${basedir}/target/classes</outputDirectory>    <testOutputDirectory>${basedir}/target/test-classes</testOutputDirectory>    ...  </build></project>
    

    如果*Directory元素设置为绝对路径(当其属性展开时),然后使用该目录。否则,它是相对于基本构建目录:${basedir}. 请注意, scriptSourceDirectory 在Maven中没有使用,并且已经过时。.

    扩展

    扩展是要在此构建中使用的工件列表。它们将包含在正在运行的构建的类路径中。它们可以启用构建过程的扩展(例如为货车传输机制添加ftp提供程序),以及使插件激活,从而对构建生命周期进行更改。简而言之,扩展是在构建过程中激活的工件。这些扩展不必实际执行任何操作,也不必包含一个Mojo。因此,扩展对于指定公共插件接口的多个实现中的一个是很好的。

    <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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <build>    ...    <extensions>      <extension>        <groupId>org.apache.maven.wagon</groupId>        <artifactId>wagon-ftp</artifactId>        <version>1.0-alpha-3</version>      </extension>    </extensions>    ...  </build></project>
    

    报告

    报告包含专门对应于site生成阶段某些Maven插件可以生成在Reporting元素下定义和配置的报告,例如:生成Javadoc报告。就像构建元素配置插件的能力一样,报告命令也具有相同的功能。显着的区别在于,报告不是对执行块内的插件目标进行细粒度控制,而是在执行块内配置目标。reportSet元素。更微妙的区别是一个插件configurationreporting元素作为build插件configuration,尽管相反的情况并非如此(abuild插件configuration不影响reporting插件)。

    可能是reporting元素,对于理解build元素是布尔值。excludeDefaults元素。此元素向站点生成器表示,以排除默认情况下通常生成的报表。当通过site构建周期项目信息节放置在左侧菜单中,其中包含大量的报表,如项目组报告或相依性名单报告。这些报告目标是由maven-project-info-reports-plugin。与任何其他插件一样,它也可能被抑制在以下,更详细的方式,有效地关闭项目-信息报告。

    <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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <reporting>    <outputDirectory>${basedir}/target/site</outputDirectory>    <plugins>      <plugin>        <artifactId>maven-project-info-reports-plugin</artifactId>        <version>2.0.1</version>        <reportSets>          <reportSet></reportSet>        </reportSets>      </plugin>    </plugins>  </reporting>  ...</project>
    

    另一个区别是outputDirectory元素下plugin。在报告的情况下,输出目录是${basedir}/target/site默认情况下。

    报表集

    重要的是要记住,一个单独的插件可能有多个目标。每个目标可能有一个单独的配置。报表集配置报表插件目标的执行。这听起来像似曾相识吗?关于Build‘s也是这么说的execution元素的不同之处:不能将报表绑定到另一个阶段。抱歉的。

    例如,假设您想配置javadoc:javadoc目标链接到“Http://java.sun.com/j2se/1.5.0/docs/api/“,但只有javadoc目标(不是目标)maven-javadoc-plugin:jar)。我们还希望将此配置传递给它的子程序,并设置inherited敬真。这个reportSet如下所示:

    <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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <reporting>    <plugins>      <plugin>        ...        <reportSets>          <reportSet>            <id>sunlink</id>            <reports>              <report>javadoc</report>            </reports>            <inherited>true</inherited>            <configuration>              <links>                <link>http://java.sun.com/j2se/1.5.0/docs/api/</link>              </links>            </configuration>          </reportSet>        </reportSets>      </plugin>    </plugins>  </reporting>  ...</project>
    

    在构建之间executions和报告reportSets,现在应该清楚它们存在的原因。从最简单的意义上讲,它们在配置上进行了深入研究。POM不仅必须有配置插件的方法,而且还必须配置这些插件的各个目标。这就是这些元素出现的地方,给了POM最终的粒度来控制它的构建命运。

    更多项目信息

    尽管上面的信息足以让我们更好地掌握POM创作,但是有更多的元素可以使开发人员的生活更加轻松。这些元素中有许多与站点生成相关,但与所有POM声明一样,它们可以用于任何东西,这取决于某些插件如何使用它。以下是最简单的要素:

    • 名字*项目往往有会话名称,而不是artifactId。Sun工程师并没有把他们的项目称为“java-1.5”,而只是称之为“Tiger”。这里是设置这个值的地方。
    • 描述一个项目的描述总是很好。虽然这不应该取代正式的文档,但是对POM的任何读者进行快速评论总是有帮助的。
    • URL与名称一样,URL也不是必需的。然而,对于项目用户来说,这是一个很好的姿态,这样他们就可以知道项目所在的位置了。
    • 开学年这是另一个很好的文档点。它至少会帮助你记住你生命中的最后几年在哪里度过的。

    许可证

    <licenses>  <license>    <name>Apache License, Version 2.0</name>    <url>https://www.apache.org/licenses/LICENSE-2.0.txt</url>    <distribution>repo</distribution>    <comments>A business-friendly OSS license</comments>  </license></licenses>
    

    许可证是定义如何和何时使用项目(或项目的一部分)的法律文件。请注意,项目只应列出可直接应用于此项目的许可证,而不应列出应用于该项目的依赖项的许可证。目前,除了在生成的站点上显示这些文档之外,Maven几乎不处理这些文档。但是,有关于对不同类型的许可证进行演示的说法,迫使用户接受某些类型(非开源)项目的许可协议。

    • 名字, URL评论意见不言自明,以前曾以其他身份遇到过。使用SPDX标识符作为许可证名字*是推荐的。第四个许可证元素是:
    • 分布*这说明了如何合法分配该项目。这两个声明的方法是repo(可以从Maven存储库下载)或手动(必须手动安装)。

    组织

    大多数项目都是由某种组织(企业、私人团体等)管理的。这里是设置最基本信息的地方。

    <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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <organization>    <name>Codehaus Mojo</name>    <url>http://mojo.codehaus.org</url>  </organization></project>
    

    开发商

    所有项目都由某个人在某个时候创建的文件组成。就像围绕一个项目的其他系统一样,因此,参与项目的人员在项目中有一定的利害关系。开发人员可能是项目核心开发的成员。请注意,虽然一个组织可能有许多开发人员(程序员)作为成员,但将他们全部列为开发人员并不是很好的形式,而只有那些直接负责代码的开发人员。一个好的经验法则是,如果不应该联系项目的人,他们不需要在这里列出。

    <project xmlns="http://maven.apache.org/POM/4.0.0"  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <developers>    <developer>      <id>jdoe</id>      <name>John Doe</name>      <email>jdoe@example.com</email>      <url>http://www.example.com/jdoe</url>      <organization>ACME</organization>      <organizationUrl>http://www.example.com</organizationUrl>      <roles>        <role>architect</role>        <role>developer</role>      </roles>      <timezone>America/New_York</timezone>      <properties>        <picUrl>http://www.example.com/jdoe/pic</picUrl>      </properties>    </developer>  </developers>  ...</project>
    
    • ID, 名字, 电子邮件::它们对应于开发人员的ID(可能是一个组织中唯一的ID)、开发人员的姓名和电子邮件地址。
    • 组织, 组织Url正如您可能猜到的,这些分别是开发人员的组织名称和URL。
    • 角色*arole应指定负责人员的标准操作。就像一个人可以戴很多帽子一样,一个人可以承担多重责任。roles.
    • 时区*有效的时区ID(如America/New_YorkEurope/Berlin,或以小时(和分数)为单位的与开发人员居住的世界协调时的数字相抵,例如,-5+1。时区ID是高度首选的,因为它们不受DST和时区移动的影响。参考IANA中的正式时区数据库和列表维基百科.
    • 特性这个元素是关于这个人的任何其他属性的去处。例如,指向个人图像或即时信使句柄的链接。不同的插件可能使用这些属性,也可能只是针对其他阅读POM的开发人员。

    投稿人

    贡献者就像开发人员一样,在项目的生命周期中扮演辅助角色。可能是贡献者发送了一个bug修复程序,或者添加了一些重要的文档。一个健康的开源项目可能比开发人员有更多的贡献者。

    <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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <contributors>    <contributor>      <name>Noelle</name>      <email>some.name@gmail.com</email>      <url>http://noellemarie.com</url>      <organization>Noelle Marie</organization>      <organizationUrl>http://noellemarie.com</organizationUrl>      <roles>        <role>tester</role>      </roles>      <timezone>America/Vancouver</timezone>      <properties>        <gtalk>some.name@gmail.com</gtalk>      </properties>    </contributor>  </contributors>  ...</project>
    

    贡献者包含的元素集与开发人员所包含的元素集相同。id元素。

    环境设置

    问题管理

    这定义了缺陷跟踪系统(布奇拉, TestTrack, ClearQuest(等)使用。尽管没有什么可以阻止插件将这些信息用于某些事情,但它主要用于生成项目文档。

    <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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <issueManagement>    <system>Bugzilla</system>    <url>http://127.0.0.1/bugzilla/</url>  </issueManagement>  ...</project>
    

    持续集成管理

    在过去的几年中,基于触发器或时间(例如每小时或每天)的持续集成构建系统比人工构建更受欢迎。随着构建系统变得更加标准化,运行这些构建的系统也变得更加标准化。尽管大多数配置都是根据所使用的特定程序(连续进程、巡航控制等)进行的,但在POM中可能会发生一些配置。Maven捕获了通知程序元素集中的一些重复设置。通知器是将特定的构建状态通知给人们的方式。在下面的示例中,此POM正在设置一个类型为mail(意思是电子邮件),并将电子邮件地址配置为在指定的触发器上使用。sendOnError, sendOnFailure,而不是sendOnSuccesssendOnWarning.

    <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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <ciManagement>    <system>continuum</system>    <url>http://127.0.0.1:8080/continuum</url>    <notifiers>      <notifier>        <type>mail</type>        <sendOnError>true</sendOnError>        <sendOnFailure>true</sendOnFailure>        <sendOnSuccess>false</sendOnSuccess>        <sendOnWarning>false</sendOnWarning>        <configuration><address>continuum@127.0.0.1</address></configuration>      </notifier>    </notifiers>  </ciManagement>  ...</project>
    

    邮寄名单

    邮件列表是一个很好的工具,可以与人们保持项目的联系。大多数邮件列表都是针对开发人员和用户的。

    <project xmlns="http://maven.apache.org/POM/4.0.0"  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <mailingLists>    <mailingList>      <name>User List</name>      <subscribe>user-subscribe@127.0.0.1</subscribe>      <unsubscribe>user-unsubscribe@127.0.0.1</unsubscribe>      <post>user@127.0.0.1</post>      <archive>http://127.0.0.1/user/</archive>      <otherArchives>        <otherArchive>http://base.google.com/base/1/127.0.0.1</otherArchive>      </otherArchives>    </mailingList>  </mailingLists>  ...</project>
    
    • 订阅, 取消订阅:元素指定用于执行相对操作以订阅上面的用户列表的电子邮件地址,用户将发送电子邮件到用户订阅@127.0.0.1。
    • 档案馆此元素指定旧邮件列表电子邮件存档的url(如果存在的话)。如果有镜像档案,则可以在“其他档案”下指定。
    • 用于将邮件发送到邮件列表的电子邮件地址。请注意,并非所有邮件列表都能够发布到(例如构建失败列表)。

    供应链管理

    SCM(SoftwareConfigurationManagement,也称源代码/控制管理或简单地说是版本控制)是任何健康项目的组成部分。如果您的Maven项目使用了SCM系统(确实如此,不是吗?)然后在这里,您可以将这些信息放到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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <scm>    <connection>scm:svn:http://127.0.0.1/svn/my-project</connection>    <developerConnection>scm:svn:https://127.0.0.1/svn/my-project</developerConnection>    <tag>HEAD</tag>    <url>http://127.0.0.1/websvn/my-project</url>  </scm>  ...</project>
    
    • 连接

      ,

      DeveloperConnection

      两个连接元素传达了一个是如何通过Maven连接到版本控制系统的。如果连接需要读取访问权限,Maven才能找到源代码(例如,更新),developerConnection则需要提供写访问权限的连接。Maven项目产生了另一个名为Maven SCM的项目,它为任何希望实现它的SCM创建一个公共API。最受欢迎的是cvs和subversion,但是其他支持的列表越来越多。

      SCMS

      。所有SCM连接都是通过一个通用的URL结构进行的。

      scm:[provider]:[provider_specific]
      

      其中提供者是SCM系统的类型。例如,连接到CVS存储库可能如下所示:

      scm:cvs:pserver:127.0.0.1:/cvs/root:my-project
      
    • 标签指定此项目所处的标记。Head(意思是SCM根)应该是默认的。

    • URL*可公开浏览的存储库。例如,通过ViewCVS。

    先决条件

    为了正确执行POM,POM可能有某些先决条件。例如,在Maven 2.0.3中可能存在使用sftp部署所需的修复。

    在Maven 3中,使用Maven执行器插件requireMavenVersion规则或其他规则来检查其他方面。

    在Maven 2中,这里给出了构建的先决条件:如果这些条件没有得到满足,Maven甚至在启动之前就会失败构建。POM4.0中唯一作为先决条件存在的元素是maven元素的最小版本号。它是用Maven 2检查的,在Maven 3中就不再是了。

    <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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <prerequisites>    <maven>2.0.6</maven>  </prerequisites>  ...</project>
    

    储存库

    存储库是遵循Maven存储库目录布局的工件的集合。为了成为Maven存储库工件,POM文件必须驻留在结构中。$BASE_REPO/groupId/artifactId/version/artifactId-version.pom. $BASE_REPO可以是本地的(文件结构)或远程的(基本URL);其余的布局将是相同的。存储库作为收集和存储工件的场所存在。每当项目依赖于工件时,Maven将首先尝试使用指定工件的本地副本。如果本地存储库中不存在该工件,则它将尝试从远程存储库下载。POM中的存储库元素指定要搜索的备用存储库。

    存储库是Maven社区最强大的特性之一。默认情况下,Maven在Https://repo.maven.apache.org/maven2/。其他的存储库可以在pu.xml`positories‘元素中配置。

    <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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <repositories>    <repository>      <releases>        <enabled>false</enabled>        <updatePolicy>always</updatePolicy>        <checksumPolicy>warn</checksumPolicy>      </releases>      <snapshots>        <enabled>true</enabled>        <updatePolicy>never</updatePolicy>        <checksumPolicy>fail</checksumPolicy>      </snapshots>      <name>Nexus Snapshots</name>      <id>snapshots-repo</id>      <url>https://oss.sonatype.org/content/repositories/snapshots</url>      <layout>default</layout>    </repository>  </repositories>  <pluginRepositories>    ...  </pluginRepositories>  ...</project>
    
    • 释放, 快照这些是针对每种类型的工件、发行版或快照的策略。有了这两个集合,POM就可以在一个存储库中独立于另一个类型修改每个类型的策略。例如,您可能会决定只启用快照下载,可能是为了开发目的。
    • 启用: truefalse是否为相应类型启用了此存储库(releasessnapshots).
    • 更新策略*此元素指定应尝试多久更新一次。Maven将比较本地POM的时间戳(存储在存储库的maven-元数据文件中)和远程。选择如下:always, daily(违约),interval:X(其中X是整数,以分钟为单位)或never.
    • 校验和策略当Maven将文件部署到存储库时,它还会部署相应的校验和文件。你的选择是ignore, fail,或warn关于丢失或不正确的校验和。
    • 布局在以上对存储库的描述中,提到它们都遵循一个共同的布局。这基本上是正确的。Maven 2引入的布局是Maven 2和3所使用的存储库的默认布局;然而,Maven 1.x有不同的布局。使用此元素指定哪个元素是defaultlegacy.

    插件库

    存储库包含两种主要类型的工件。第一个是用作其他工件的依赖关系的工件。这些是驻留在中央内部的大部分工件。另一种类型的工件是插件。Maven插件本身就是一种特殊的工件类型。正因为如此,插件存储库可能会与其他存储库分离(尽管,我还没有听到令人信服的理由来这么做)。在任何情况下,pluginRepositories元素块类似于repositories元素。这个pluginRepository每个元素都指定了Maven可以找到新插件的远程位置。

    配送管理

    分发管理的作用就像它听起来的那样:它管理工件的分发,并支持在整个构建过程中生成的文件。首先从最后一个元素开始:

    <project xmlns="http://maven.apache.org/POM/4.0.0"  xmlns:xsi="http://www.w3.org/001/XMLSchema-instance"  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <distributionManagement>    ...    <downloadUrl>http://mojo.codehaus.org/my-project</downloadUrl>    <status>deployed</status>  </distributionManagement>  ...</project>
    
    • 下载Url是另一个POM可以指向的存储库的URL,以便获取这个POM的工件。简单地说,我们告诉POM如何上传它(通过存储库/url),但是公众可以从哪里下载呢?这个元素回答了这个问题。

    • 地位

      警告!就像鸟巢里的小鸟一样,这种状态不应该被人类的手碰触!这样做的原因是,Maven将在将项目传输到存储库时设置项目的状态。其有效类型如下。

      • *无特殊地位。这是POM的默认设置。
      • 转换存储库的管理人员将此POM从早期版本转换为Maven 2。
      • 合伙人该工件已与合作伙伴存储库同步。
      • 部署到目前为止最常见的状态,这意味着这个工件是从Maven 2或3实例中部署的。这就是当您使用命令行部署阶段手动部署时得到的结果。
      • 查证该项目已得到核实,应视为已完成。

    储存库

    存储库元素在POM中指定Maven可以下载远程构件供当前项目使用的位置和方式,而DistributionManagement则指定在部署该项目时该项目将在何处(以及如何)到达远程存储库。如果没有定义快照存储库,则存储库元素将用于快照分发。

    <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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <distributionManagement>    <repository>      <uniqueVersion>false</uniqueVersion>      <id>corp1</id>      <name>Corporate Repository</name>      <url>scp://repo/maven2</url>      <layout>default</layout>    </repository>    <snapshotRepository>      <uniqueVersion>true</uniqueVersion>      <id>propSnap</id>      <name>Propellors Snapshots</name>      <url>sftp://propellers.net/maven</url>      <layout>legacy</layout>    </snapshotRepository>    ...  </distributionManagement>  ...</project>
    
    • ID, 名字*id用于在许多存储库中唯一地标识此存储库,并且name是人类可读的形式。
    • UniqueVersion*唯一的版本需要truefalse值来表示部署到此存储库的工件是应该获得唯一生成的版本号,还是使用定义为地址一部分的版本号。
    • URL这是存储库元素的核心。它指定了用于将构建的工件(以及POM文件和校验和数据)传输到存储库的位置和传输协议。
    • 布局这些类型和用途与存储库元素中定义的布局元素相同。他们是defaultlegacy.

    场地分布

    不仅仅是分发到存储库,distributionManagement负责定义如何部署项目的站点和文档。

    <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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <distributionManagement>    ...    <site>      <id>mojo.website</id>      <name>Mojo Website</name>      <url>scp://beaver.codehaus.org/home/projects/mojo/public_html/</url>    </site>    ...  </distributionManagement>  ...</project>
    
    • ID, 名字, URL*这些要素与上述distributionManagement repository元素。

    搬迁

    <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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <distributionManagement>    ...    <relocation>      <groupId>org.apache</groupId>      <artifactId>my-project</artifactId>      <version>1.0</version>      <message>We have moved the Project under Apache</message>    </relocation>    ...  </distributionManagement>  ...</project>
    

    项目不是静态的;它们是有生命的东西(或死亡的东西,视情况而定)。一个常见的事情发生在项目的增长,是他们被迫搬到更合适的地方。例如,当您的下一个非常成功的开源项目在apache的保护伞下运行时,最好给用户一个提示,以便将该项目重命名为org.apache:my-project:1.0。除了指定新地址外,提供解释原因的信息也是很好的形式。

    剖面图

    POM4.0的一个新特性是项目能够根据正在构建的环境更改设置。一个profile元素既包含可选的激活(配置文件触发器),也包含如果已激活该配置文件将对POM进行的一组更改。例如,为测试环境构建的项目可能指向与最终部署不同的数据库。也可以根据所使用的JDK版本从不同的存储库中提取依赖项。概况的内容如下:

    <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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <profiles>    <profile>      <id>test</id>      <activation>...</activation>      <build>...</build>      <modules>...</modules>      <repositories>...</repositories>      <pluginRepositories>...</pluginRepositories>      <dependencies>...</dependencies>      <reporting>...</reporting>      <dependencyManagement>...</dependencyManagement>      <distributionManagement>...</distributionManagement>    </profile>  </profiles></project>
    

    活化

    激活是配置文件的关键。配置文件的功能来自于它仅在某些情况下修改基本POM的能力。这些情况通过activation元素。

    <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                      https://maven.apache.org/xsd/maven-4.0.0.xsd">  ...  <profiles>    <profile>      <id>test</id>      <activation>        <activeByDefault>false</activeByDefault>        <jdk>1.5</jdk>        <os>          <name>Windows XP</name>          <family>Windows</family>          <arch>x86</arch>          <version>5.1.2600</version>        </os>        <property>          <name>sparrow-type</name>          <value>African</value>        </property>        <file>          <exists>${basedir}/file2.properties</exists>          <missing>${basedir}/file1.properties</missing>        </file>      </activation>      ...    </profile>  </profiles></project>
    

    在Maven 3.2.2之前,当满足了一个或多个指定条件时,激活就会发生。当遇到第一个正结果时,处理停止,配置文件被标记为活动。自从Maven 3.2.2激活发生时,所有指定的条件都满足了。

    • JDK: activation中具有内置的以Java为中心的签入。jdk元素。如果测试在与给定前缀匹配的JDK版本号下运行,这将激活。在上面的例子中,1.5.0_06会匹配的。也支持范围。见Maven-forcer-plugin有关支持范围的详细信息。
    • OS*os元素可以定义上面所示的某些操作系统特定属性。见maven-forcer-pluginsRequireOS规则有关OS值的详细信息。
    • 财产*profile如果Maven检测到一个属性(该值可以通过${name})name=value一对。
    • 档案*最后,给定的文件名可能激活profileexistence文件,或者如果它是missing. *该元素的插值仅限于${basedir}、系统属性和请求属性。

    这个activation元素的唯一方法是profile可能会被激活。这个settings.xml档案activeProfile元素可能包含配置文件的id。之后,还可以通过命令行通过逗号分隔列表显式地激活它们。-P旗帜(如:-P codecoverage).

    若要查看哪个配置文件将在特定构建中激活,请使用 maven-help-plugin.

    mvn help:active-profiles
    

    BaseBuild元素集 (重新审查)

    如前所述,这两种类型的构建元素的原因在于配置配置文件不像在POM的顶层那样配置构建目录或扩展是没有意义的。在没有规则的环境中构建项目,一些值将保持不变,例如源代码的目录结构。如果您发现您的项目需要为不同的环境保留两组代码,那么仔细研究将项目重构为两个或多个单独的项目是明智的。

    最终

    Maven POM很大。然而,它的大小也证明了它的多功能性。至少可以说,将项目的所有方面抽象成单个工件的能力是强大的。关于每个项目的几十个不同的构建脚本和零散文档的时代已经过去了。和Maven组成Maven星系的其他恒星一样,POM是一个定义明确的构建生命周期,易于编写和维护插件、集中式存储库、系统范围的和基于用户的配置,以及越来越多的工具使开发人员的工作更容易维护复杂的项目–POM是一个庞大但明亮的中心。


    本指南的各个方面最初发表在Maven 2 Pom解开.

    展开全文
  • 今天尝试使用maven建web项目,纪录一下步骤。第一步: [选择MavenProject点击下一步 勾选第二项点击下一步 选择maven-archetype-webapp下一步 填写项目坐标,Finish,项目建好了 **在这里存在一些问题 ...

    今天尝试使用maven建web项目,纪录一下步骤。

    第一步:

    选择MavenProject点击下一步
    [选择MavenProject点击下一步
    勾选第二项点击下一步
    勾选第二项点击下一步
    选择maven-archetype-webapp下一步
    选择maven-archetype-webapp下一步
    这里写图片描述
    填写项目坐标,Finish,项目建好了
    这里写图片描述
    **在这里存在一些问题
    (1)有错,这是因为没有jsp和servlet的api
    (2)项目文件结构不对**

    第二步:

    解决这两个问题
    首先在pom.xml添加如下依赖

      <dependency>
            <groupId>javax.servlet.jsp</groupId>        
            <artifactId>jsp-api</artifactId>        
            <version>2.2.1-b03</version>        
            </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>        
            <artifactId>servlet-api</artifactId>        
            <version>3.0-alpha-1</version>      
        </dependency>
    
    
    

    然后在项目下新建
    src/main/java
    src/test/java
    src/test/resources
    三个文件夹 补齐缺失的文件结构
    可以看到报错消失了

    第三步

    修改jre
    在项目上右键 选择Build Path如图
    这里写图片描述
    点击edit
    这里写图片描述
    选择机器上装的java版本,我是1.8
    然后点project facets
    这里写图片描述
    先把Dynamic web module去掉 然后把java选成1.8版本Apply(一定要先apply否则Dynamic web module改不成3.0)
    然后在将Dynamic web module勾选上改成3.0,下面会有个
    further configuration available,点击
    这里写图片描述
    一定要打勾,否则会报错
    Apply -> OK
    还是会报错,错误信息
    web.xml is missing and is set to true

    第四步

    解决在pom.xml<build></build>添加
    <plugins>
    <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-war-plugin</artifactId>
    <configuration>
    <failOnMissingWebXml>false</failOnMissingWebXml>
    </configuration>
    </plugin>
    </plugins>

    错误消失
    然后把webcontent下的web.xml复制到myapps/web-inf下

    第五步

    把index.jsp修改如

    <html>
    <body>
    <h2>Hello World!</h2>
    <a herf="HelloServlet">Hello</a>
    </body>
    </html>

    然后新建个HelloServlet

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            // TODO Auto-generated method stub
            response.setContentType("text/html");
            response.setCharacterEncoding("GBK");
            PrintWriter out = response.getWriter();
    
            out.println("<html>");
            out.println("<head><title>hello</title></head>");
            out.println("<body><h1>HELLO</h1></body>");
    
            out.println("</html>");
        }

    在web.xml添加

    <servlet> 
        <servlet-name>HelloServlet</servlet-name> 
        <servlet-class>com.test.HelloServlet</servlet-class> 
        </servlet> 
    
       <servlet-mapping> 
        <servlet-name>HelloServlet</servlet-name> 
        <url-pattern>/HelloServlet</url-pattern> 
       </servlet-mapping> 

    第六步

    配置部署路径
    右键BuildPath选择Deployment Assembly
    这里写图片描述
    删掉webcontent 行
    新增 /src/main/webapps /行
    新增Maven Dependencies
    配置好如下
    这里写图片描述
    Apply->OK

    第七步

    运行 Run As
    Run on server
    效果图
    这里写图片描述
    大功告成!!!!

    展开全文
  • 1、打开eclipse,File-&gt;New-&gt;Other-&gt;Maven-&gt;Maven Project2、直接点击Next3、选择webapp的选项,点击Next4、填写group id和artifact id,点击Finish5、结束之后可以看到文件...在pom.xm...

    1、打开eclipse,File->New->Other->Maven->Maven Project

    2、直接点击Next

    3、选择webapp的选项,点击Next

    4、填写group id和artifact id,点击Finish

    5、结束之后可以看到文件的目录如下

    6、可以看到创建项目之后,目录中的index.jsp文件报错,这是因为没有加入servlet api,在pom.xml文件加入servlet api的依赖即可,具体坐标可以到 (http://mvnrepository.com/)查找

    7、因为maven项目一般规定含src/main/java,src/test/java,src/main/resources,src/test/resources四个source folder,但是eclipse只为我们创建了src/main/resources目录,所以需要手动添加其他三个文件。在添加的时候遇到如下文件已存在的情况,点击项目右键选择build Path,选中Source可以看到/src/main/java (missing)和/src/test/java (missing),将这两个文件Remove,即可开始创建需要的文件。


    8、创建好需要的目录之后,可以在source中看到文件的输出没有进行设置,这里需要将src/main/java,src/main/resources两个文件的输出设置到项目的target/classes目录下,src/test/java,src/test/resources两个文件的输出设置到项目的target/test-classes目录下,具体通过选中文件并点击edit进行设置。


    9、设置完文件之后可以看到文件的输出路径以及项目目录如下


    10、为项目添加tomcat插件,即在pom.xml文件中添加如下代码,tomcat插件的设置可以到(http://tomcat.apache.org/maven-plugin.html)网址下查看。其中configuration标签下是对tomcat容器的配置,包括端口(port),访问路径(path),编码(uriEncoding),tomcat名称(Server)的设置。executions标签下定义在什么动作下做什么操作,这里定义了maven在对项目进行package打包操作的时候启动tomcat。

    11、选择项目,Run As->Maven build ... 。


    12、在弹出的设置中,找到Goals,填写clean package(表示先清除项目编译文件,然后重新对项目进行打包),点击Run的时候maven就会自动帮我们下载tomcat插件并对项目进行部署以及启动。

    13、通过 localhost:8082 即可访问到启动的项目,当pom.xml中将path配置为/test,则需要通过 localhost:8082/test 进行访问。


    14、另外如果没有在pom.xml配置executions标签的时候,可以在Goals中填写 tomcat7:run 来启动tomcat容器。


    15、Goals中的其他配置如下:

    clean:清除之前编译打包的文件
    test:运行测试代码
    compile:编译项目
    package:对项目进行打包操作
    install:对项目进行打包并放到本地仓库

    tomcat7:deploy :部署一个web war包
    tomcat7:reload  :重新加载web war包
    tomcat7:start   :启动tomcat
    tomcat7:stop   :停止tomcat
    tomcat7:undeploy :停止一个war包
    tomcat7:run  :启动tomcat ,并运行当前项目

    展开全文
  • 1.在pom.xml中加入代码 dependency> groupId>javax.servletgroupId> artifactId>javax.servlet-apiartifactId> version>3.1.0version> dependency> 2.添加tomcat 项目(右键)-->build path--->Configure B

    1.在pom.xml中加入代码

    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
    </dependency>
    2.添加tomcat

    项目(右键)-->build path--->Configure Build Path--->Libraries--->Add Library--->Server Runtime--->选中添加的tomcat--->finished

    展开全文
  • 错误如下:Multiple annotations found at this line:- Failure to find org.apache.maven.plugins:maven-war-plugin:jar:3.1 in https://repo.maven.apache.org/maven2 was cached in thelocal repository, ...
  • pom.xml配置文件中添加上javax.servlet的相关依赖: javax.servlet servlet-api 2.5 provided 依赖tomcat类库: 项目右击—&gt;build path —&gt; configure build path — &gt;libraries ...
  • 1.我自己在本机上先了这个模块,相同名字的模块,因为一些原因删掉了,然后同事提交了这个module,我pull下来后,IDEA直接把我新模块的pom文件设置成了忽略状态。提示:这里填写问题的分析: 解决方案: file --...
  • 昨天看到有人问依赖管理的问题,所以就想... 1、首先一个root/pom.xml 主要作用就是配置一般项目都需要的基本信息。 如:编码,编译版本,生成eclipse项目时的编码,生成manifest描述,单元测试常用依赖,生成...
  • maven pom.xml packaging报错

    万次阅读 2017-04-01 11:19:18
    今天刚接触maven项目以后发现默认为jdk1.5,然后我删掉了那个,脑子一抽加了系统默认jre上去,然后报错了,代码一大堆  Execution default-testResources of goal org.apache.maven.plugins:maven-...
  • maven多module项目的引用问题

    万次阅读 热门讨论 2018-07-02 22:01:05
    问题描述:当一个多module的maven项目时,我们想要的效果是: 1. 当子项目引用父项目时,我们可以根据需要引用其他子项目,而不是全部其他子项目. 1. 当别的项目引用我们这个父项目时,应该引用了全部子项目. 那我们...
  • 首先用netbeans建立maven普通工程,主要就是pom.xml文件的配置,下面是配置清单,要使用相应log实现取消注释即可。 [code="java"] 4.0.0 com.mycompany slf4j jar 1.0-SNAPSHOT slf4j ...
  • 1.创建主项目   1.1创建simple project 1.2设置groupid 和 ...2.1创建 maven module,(注意主项目maven project) 2.2填写子项目名字,选择父项目为我们创建的主项目,这次别勾选create a simple pr...
  • 1. 找到整个项目maven仓库,我的是默认路径:D:\maven\repository ① 新建文件夹zidingyi(根据自己的想法自己命名) ② 在文件夹中再一个文件夹api,api中建文件夹sdk(这里也是自己命名,层级可以自己定义...
  • 用idea建maven项目搭建mybatis框架

    千次阅读 2017-06-29 16:39:36
     第二步: 在搭建好的maven项目中打开pom.xml,加载所需的jar包,配置如下:  <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:sch
  • maven开发web项目

    千次阅读 2018-07-15 19:35:03
    初步接受maven项目,创建maven项目1、选择新建,选择maven project2、选择workspace路径3、选择项目类型,一般用到的就两种,java项目和web项目java项目web项目4、好之后,可能会少几个目录资源目录,可以新建5、...
  • 不了maven的wep和quickstart项目 - Could not resolve archetype org.apache.maven.archetypes:maven-archetype-webapp:RELEASE from any of the configured repositories. Could not resolve ...
  • Maven POM 文件中的继承和聚合(Inheritance &amp;amp;amp;amp; Aggregation) 之前在 IDEA 里了一个项目专门用来学习,每个知识点都建立一个相应的模块,这样比较方便学习和查看。今天在建第二个模块的...
  • 使用maven新建java项目

    2019-11-24 18:48:47
    1、 平时新建java项目:使用maven 具体步骤: new->Project->选择:Maven下的Maven Project->next->maven-archetype-quickstart 1.1(默认)-...2、 Maven项目都是通过pom.xml进行管理的: 可以通过...
  • Maven项目搭建

    2020-07-29 12:14:19
    Maven项目搭建区间环境搭建把maven加入区间工厂加载项目搭建建maven项目配置maven项目问题项目修改web3.0配置pom.xml重新加载项目 区间环境搭建 把maven加入区间 像第二张图片一样勾上然后应用就????了 工厂加载 ...
  • SSM初入门 用IDEA创建一个maven项目 首先要配置好maven的环境 参考配置maven环境配置 Mavenpom.xml配置文件详解
  • 今天我自己搭建了一个 mavenweb项目pom.xml和spring-mvc.xml等都配置的正确,启动也不报错,但访问index.html就是报404,我把index.html放到/index.jsp中也不行,纳闷了,项目是刚搭额起来的,代码都没有写,就...
  • Maven变量

    2020-12-23 22:46:33
    ${basedir}表示项目根目录,即包含pom.xml文件的目录; ${version}表示项目版本; ${project.basedir}同${basedir}; ${project.baseUri}表示项目文件地址; ${maven.build.timestamp}表示项目构件开始时间; ${maven...
  • pom.xml配置完后,发现Plugins和Dependencies出错,有红色波浪线 对于Plugins,删除本地仓库的所有文件,一般在C:\Users\admin\.m2下,再次Reimport重新下载就可以 对于Dependencies,删除pom.xml中的Dependencies...
  • 父工程先一个空的maven项目,不做具体的业务开发。仅仅只是做依赖包的版本管理。直接新建项目NEW -->project–>maven–>maven Project,点击下一步,进入new maven Project的Select project name and ...
  • Eclipse 搭建 Maven 父子工程项目

    千次阅读 2019-05-20 17:03:10
    直接进入主题吧 介绍一下环境: Eclipse + JDK 1.8 首先创建一个 Maven 父工程:右键 New - Other - Maven - Maven Project ...注意看父工程的 pom 文件,这是没创建子工程之前的 pom 然后创建一个 Maven 子...
  • 前言 这是我个人学习和实践的经历,可以借鉴,但是不...每新导入或者创建一个项目需要配置maven的配置,查看自己的maven配置,找到自己的maven仓库,将这个jar包按照格式好层级关系和版本. pom中的依赖: <dependen
  • 利用IDEA创建基于 maven 的SpringMVC项目 一、一个空项目 二、添加Module 这时项目的目录为: 三、添加目录 1.java,resource 2.在WEB-INF文件夹下pages文件夹(存放jsp文件) 总体目录: 3.修改...
  • 1.新建项目(转自:http://www.cnblogs.com/wql025/p/5215570.html)创建一个...注意:Idea_Project是存放此项目的工作区间,mavenDemo_idea15为存放此项目的子目录。项目后,打开,点击Auto-Import下面为此项目的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 584
精华内容 233
关键字:

maven建pom项目