• Maven Dependency 机制

    依赖关系管理是Maven的核心功能。管理单个项目的依赖关系很容易。管理由数百个模块组成的多模块项目和应用程序的依赖关系是可能的。Maven在定义、创建和维护具有良好定义的类路径和库版本的可复制构建方面有很大帮助。

    一、传递依赖

    Maven通过自动包含可传递的依赖关系，避免了发现和指定您自己的依赖关系所需的库的需要。
    通过从指定的远程存储库中读取依赖项的项目文件，可以实现此功能。通常，这些项目的所有依赖项都会在项目中使用，项目从其父项或依赖项继承的任何依赖项也是如此，依此类推。
    可以从中收集依赖关系的级别数量没有限制。只有当发现循环依赖关系时，才会出现问题。
    有了可传递的依赖关系，包含库的图可以很快变大。因此，还有一些附加功能限制了所包含的依赖项：

    • 依赖项中介 - 这决定了在遇到多个版本作为依赖项时将选择哪个版本的项目。Maven选择了“最接近的定义”。也就是说，它使用依赖项树中与项目最近的依赖项的版本。您始终可以通过在项目的 POM 中显式声明版本来保证版本。请注意，如果两个依赖项版本在依赖项树中的深度相同，则第一个声明优先。
      • “最接近的定义”意味着使用的版本将是依赖项树中与您的项目最接近的版本。考虑以下依赖树：
    1.  A
    2.   ├── B
    3.   │   └── C
    4.   │       └── D 2.0
    5.   └── E
    6.       └── D 1.0

     在文本中，A、B和C的依赖项定义为A->B->C->D2.0和A->E->D1.0，然后在构建A时将使用D1.0，因为从A到D通过E的路径更短。您可以在a中显式地向D2.0添加依赖项，以强制使用D2.0，如下所示：

    1.   A
    2.   ├── B
    3.   │   └── C
    4.   │       └── D 2.0
    5.   ├── E
    6.   │   └── D 1.0
    7.   │
    8.   └── D 2.0
    • 依赖项管理-这允许项目作者在传递依赖项或未指定版本的依赖项中遇到工件时，直接指定要使用的工件版本。在上一节的例子中，一个依赖项被直接添加到a中，尽管a没有直接使用它。相反，a可以将D作为依赖项包含在其dependencyManagement部分中，并直接控制在何时或是否引用它时使用D的哪个版本。
    • 依赖关系范围-这允许您只包括适用于构建的当前阶段的依赖关系。下面将对此进行更详细的描述。
    • 排除的依赖项-如果项目X依赖于项目Y，而项目Y依赖于项目Z，则项目X的所有者可以使用“排除”元素将项目Z明确排除为依赖项。
    • 可选依赖项-如果项目Y依赖于项目Z，则项目Y的所有者可以使用“可选”元素将项目Z标记为可选依赖项。当项目X依赖于项目Y时，X将仅依赖于Y，而不依赖于Y的可选依赖项Z。然后，项目X的所有者可以根据自己的选择显式添加对Z的依赖项。（将可选依赖项视为“默认排除”可能会有所帮助)

    尽管可传递依赖项可以隐式地包括所需的依赖项，但显式指定源代码直接使用的依赖项是一种很好的做法。这种最佳实践证明了它的价值，尤其是当项目的依赖关系改变了它们的依赖关系时。
    例如，假设您的项目A指定了对另一个项目B的依赖项，而项目B指定了对项目C的依赖项。如果您直接在项目C中使用组件，而您没有在项目A中指定项目C，则当项目B突然更新/删除其对项目C的依赖时，可能会导致生成失败。
    直接指定依赖项的另一个原因是它为您的项目提供了更好的文档：只需读取项目中的POM文件，或者执行mvn-dependency:tree，就可以了解更多信息。
    Maven还提供了dependency:analyze插件分析依赖关系的目标：这有助于使这种最佳实践更容易实现。

    二、依赖范围

    依赖关系范围用于限制依赖关系的传递性，并确定依赖关系何时包含在类路径中。
    共有6个作用域：

    • compile

         这是默认范围，如果未指定，则使用。编译依赖项在项目的所有类路径中都可用。此外，这些依赖项将传播到依赖项目。

    • provided

      这很像编译，但表示您希望JDK或容器在运行时提供依赖关系。例如，当为Java Enterprise Edition构建web应用程序时，您需要将对Servlet API和相关Java EE API的依赖设置为所提供的范围，因为web容器提供了这些类。具有此作用域的依赖项被添加到用于编译和测试的类路径中，但不添加到运行时类路径中。它不可传递。

    • runtime

        此范围表示编译不需要依赖项，而是执行依赖项。Maven在运行时和测试类路径中包含一个具有此作用域的依赖项，但不包括编译类路径。

    • test

    此范围表示应用程序的正常使用不需要依赖项，仅适用于测试编译和执行阶段。此范围不可传递。通常，这个范围用于JUnit和Mockito等测试库。它也用于非测试库，如Apache Commons IO，如果这些库用于单元测试（src/test/java），但不用于模型代码（src/main/java）。

    • system

       这个作用域与提供的作用域类似，只是您必须提供显式包含它的JAR。工件总是可用的，并且不会在存储库中查找。

    • import

          只有部分中pom类型的依赖项才支持此作用域。它指示依赖项将被指定POM的部分中的有效依赖项列表所取代。由于它们被替换，具有导入范围的依赖项实际上并没有参与限制依赖项的传递性。

    每个作用域（导入除外）都以不同的方式影响可传递的依赖项，如下表所示。如果将依赖项设置为左列中的作用域，则该依赖项与顶行中作用域的可传递依赖项将导致主项目中的依赖项与交叉点处列出的作用域。如果没有列出作用域，则表示省略了依赖项。

    compile

    provided

    runtime

    test

    compile

    compile(*)

    -

    runtime

    -

    provided

    provided

    -

    provided

    -

    runtime

    runtime

    -

    runtime

    -

    test

    test

    -

    test

    -

    （*）注意：这应该是运行时范围，因此必须显式列出所有编译依赖项。但是，如果您所依赖的库从另一个库扩展了一个类，则两者在编译时都必须可用。由于这个原因，编译时依赖关系仍然是编译范围，即使它们是可传递的。

    三、依赖关系管理

    依赖关系管理部分是一种用于集中依赖关系信息的机制。当您有一组从公共父级继承的项目时，可以将有关依赖项的所有信息放在公共 POM 中，并对子 POM 中的项目进行更简单的引用。通过一些例子可以最好地说明这种机制。给定扩展同一父级的这两个 POM：

    项目A：

    1. <project>
    2.   ...
    3.   <dependencies>
    4.     <dependency>
    5.       <groupId>group-a</groupId>
    6.       <artifactId>artifact-a</artifactId>
    7.       <version>1.0</version>
    8.       <exclusions>
    9.         <exclusion>
    10.           <groupId>group-c</groupId>
    11.           <artifactId>excluded-artifact</artifactId>
    12.         </exclusion>
    13.       </exclusions>
    14.     </dependency>
    15.     <dependency>
    16.       <groupId>group-a</groupId>
    17.       <artifactId>artifact-b</artifactId>
    18.       <version>1.0</version>
    19.       <type>bar</type>
    20.       <scope>runtime</scope>
    21.     </dependency>
    22.   </dependencies>
    23. </project>

    项目B：

    1. <project>
    2.   ...
    3.   <dependencies>
    4.     <dependency>
    5.       <groupId>group-c</groupId>
    6.       <artifactId>artifact-b</artifactId>
    7.       <version>1.0</version>
    8.       <type>war</type>
    9.       <scope>runtime</scope>
    10.     </dependency>
    11.     <dependency>
    12.       <groupId>group-a</groupId>
    13.       <artifactId>artifact-b</artifactId>
    14.       <version>1.0</version>
    15.       <type>bar</type>
    16.       <scope>runtime</scope>
    17.     </dependency>
    18.   </dependencies>
    19. </project>

    这两个示例 POM 共享一个共同的依赖项，并且每个都有一个非平凡的依赖项。此信息可以像这样放入父 POM 中：

     

    1. <project>
    2.   ...
    3.   <dependencyManagement>
    4.     <dependencies>
    5.       <dependency>
    6.         <groupId>group-a</groupId>
    7.         <artifactId>artifact-a</artifactId>
    8.         <version>1.0</version>
    9.  
    10.         <exclusions>
    11.           <exclusion>
    12.             <groupId>group-c</groupId>
    13.             <artifactId>excluded-artifact</artifactId>
    14.           </exclusion>
    15.         </exclusions>
    16.  
    17.       </dependency>
    18.  
    19.       <dependency>
    20.         <groupId>group-c</groupId>
    21.         <artifactId>artifact-b</artifactId>
    22.         <version>1.0</version>
    23.         <type>war</type>
    24.         <scope>runtime</scope>
    25.       </dependency>
    26.  
    27.       <dependency>
    28.         <groupId>group-a</groupId>
    29.         <artifactId>artifact-b</artifactId>
    30.         <version>1.0</version>
    31.         <type>bar</type>
    32.         <scope>runtime</scope>
    33.       </dependency>
    34.     </dependencies>
    35.   </dependencyManagement>
    36. </project>
     

    然后，两个子 POM 变得更加简单：
     

    1. <project>
    2.   ...
    3.   <dependencies>
    4.     <dependency>
    5.       <groupId>group-a</groupId>
    6.       <artifactId>artifact-a</artifactId>
    7.     </dependency>
    8.  
    9.     <dependency>
    10.       <groupId>group-a</groupId>
    11.       <artifactId>artifact-b</artifactId>
    12.       <!-- This is not a jar dependency, so we must specify type. -->
    13.       <type>bar</type>
    14.     </dependency>
    15.   </dependencies>
    16. </project>
     

    1. <project>
    2.   ...
    3.   <dependencies>
    4.     <dependency>
    5.       <groupId>group-c</groupId>
    6.       <artifactId>artifact-b</artifactId>
    7.       <!-- This is not a jar dependency, so we must specify type. -->
    8.       <type>war</type>
    9.     </dependency>
    10.  
    11.     <dependency>
    12.       <groupId>group-a</groupId>
    13.       <artifactId>artifact-b</artifactId>
    14.       <!-- This is not a jar dependency, so we must specify type. -->
    15.       <type>bar</type>
    16.     </dependency>
    17.   </dependencies>
    18. </project>
     

     注意：在其中两个依赖引用中，我们必须指定元素。这是因为用于将依赖引用与dependencyManagement节匹配的最小信息集实际上是{groupId，artifactId，type，classifier}。在许多情况下，这些依赖关系将引用没有分类器的jar工件。这允许我们将标识集简写为{groupId，artifactId}，因为类型字段的默认值是jar，而默认分类器是null。
     依赖关系管理部分的第二个也是非常重要的用途是控制可传递依赖关系中使用的工件的版本。以这些项目为例：
     

    项目A：
     

    1. <project>
    2.  <modelVersion>4.0.0</modelVersion>
    3.  <groupId>maven</groupId>
    4.  <artifactId>A</artifactId>
    5.  <packaging>pom</packaging>
    6.  <name>A</name>
    7.  <version>1.0</version>
    8.  <dependencyManagement>
    9.    <dependencies>
    10.      <dependency>
    11.        <groupId>test</groupId>
    12.        <artifactId>a</artifactId>
    13.        <version>1.2</version>
    14.      </dependency>
    15.      <dependency>
    16.        <groupId>test</groupId>
    17.        <artifactId>b</artifactId>
    18.        <version>1.0</version>
    19.        <scope>compile</scope>
    20.      </dependency>
    21.      <dependency>
    22.        <groupId>test</groupId>
    23.        <artifactId>c</artifactId>
    24.        <version>1.0</version>
    25.        <scope>compile</scope>
    26.      </dependency>
    27.      <dependency>
    28.        <groupId>test</groupId>
    29.        <artifactId>d</artifactId>
    30.        <version>1.2</version>
    31.      </dependency>
    32.    </dependencies>
    33.  </dependencyManagement>
    34. </project>
     

    项目B：
     

    1. <project>
    2.   <parent>
    3.     <artifactId>A</artifactId>
    4.     <groupId>maven</groupId>
    5.     <version>1.0</version>
    6.   </parent>
    7.   <modelVersion>4.0.0</modelVersion>
    8.   <groupId>maven</groupId>
    9.   <artifactId>B</artifactId>
    10.   <packaging>pom</packaging>
    11.   <name>B</name>
    12.   <version>1.0</version>
    13.  
    14.   <dependencyManagement>
    15.     <dependencies>
    16.       <dependency>
    17.         <groupId>test</groupId>
    18.         <artifactId>d</artifactId>
    19.         <version>1.0</version>
    20.       </dependency>
    21.     </dependencies>
    22.   </dependencyManagement>
    23.  
    24.   <dependencies>
    25.     <dependency>
    26.       <groupId>test</groupId>
    27.       <artifactId>a</artifactId>
    28.       <version>1.0</version>
    29.       <scope>runtime</scope>
    30.     </dependency>
    31.     <dependency>
    32.       <groupId>test</groupId>
    33.       <artifactId>c</artifactId>
    34.       <scope>runtime</scope>
    35.     </dependency>
    36.   </dependencies>
    37. </project>
     

     当maven在项目B上运行时，无论POM中指定的版本是什么，都将使用工件a、B、c和d的1.0版本。
     

    • a和c都被声明为项目的依赖项，因此由于依赖项中介，使用1.0版本。两者都有运行时作用域，因为它是直接指定的。
    • b是在b的父级依赖关系管理部分中定义的，由于对于可传递依赖关系，依赖关系管理优先于依赖关系中介，因此如果在a或c的POM中引用它，将选择1.0版本。b也将具有编译范围。
    • 最后，由于d是在B的依赖关系管理部分中指定的，如果d是a或c的依赖关系（或传递依赖关系），则将选择1.0版本，这也是因为依赖关系管理优先于依赖关系中介，也因为当前POM的声明优先于其父声明。
     

    有关依赖项管理标记的引用信息可从项目描述符引用中获得。
     

    四、正在导入依赖项
     

    上一节中的示例描述了如何通过继承指定托管依赖项。然而，在较大的项目中，这可能是不可能实现的，因为一个项目只能从单亲继承。为了适应这种情况，项目可以从其他项目导入托管依赖项。这是通过将POM工件声明为范围为“import”的依赖项来实现的。
     

    Project B:
     

    1. <project>
    2.   <modelVersion>4.0.0</modelVersion>
    3.   <groupId>maven</groupId>
    4.   <artifactId>B</artifactId>
    5.   <packaging>pom</packaging>
    6.   <name>B</name>
    7.   <version>1.0</version>
    8.  
    9.   <dependencyManagement>
    10.     <dependencies>
    11.       <dependency>
    12.         <groupId>maven</groupId>
    13.         <artifactId>A</artifactId>
    14.         <version>1.0</version>
    15.         <type>pom</type>
    16.         <scope>import</scope>
    17.       </dependency>
    18.       <dependency>
    19.         <groupId>test</groupId>
    20.         <artifactId>d</artifactId>
    21.         <version>1.0</version>
    22.       </dependency>
    23.     </dependencies>
    24.   </dependencyManagement>
    25.  
    26.   <dependencies>
    27.     <dependency>
    28.       <groupId>test</groupId>
    29.       <artifactId>a</artifactId>
    30.       <version>1.0</version>
    31.       <scope>runtime</scope>
    32.     </dependency>
    33.     <dependency>
    34.       <groupId>test</groupId>
    35.       <artifactId>c</artifactId>
    36.       <scope>runtime</scope>
    37.     </dependency>
    38.   </dependencies>
    39. </project>
     

    假设A是前面例子中定义的POM，那么最终结果将是相同的。A的所有托管依赖项都将被合并到B中，除了d，因为它是在这个POM中定义的。
     

    Project X:
     

    1. <project>
    2.  <modelVersion>4.0.0</modelVersion>
    3.  <groupId>maven</groupId>
    4.  <artifactId>X</artifactId>
    5.  <packaging>pom</packaging>
    6.  <name>X</name>
    7.  <version>1.0</version>
    8.  
    9.  <dependencyManagement>
    10.    <dependencies>
    11.      <dependency>
    12.        <groupId>test</groupId>
    13.        <artifactId>a</artifactId>
    14.        <version>1.1</version>
    15.      </dependency>
    16.      <dependency>
    17.        <groupId>test</groupId>
    18.        <artifactId>b</artifactId>
    19.        <version>1.0</version>
    20.        <scope>compile</scope>
    21.      </dependency>
    22.    </dependencies>
    23.  </dependencyManagement>
    24. </project>
     

    Project Y: 
     

    1. <project>
    2.  <modelVersion>4.0.0</modelVersion>
    3.  <groupId>maven</groupId>
    4.  <artifactId>Y</artifactId>
    5.  <packaging>pom</packaging>
    6.  <name>Y</name>
    7.  <version>1.0</version>
    8.  
    9.  <dependencyManagement>
    10.    <dependencies>
    11.      <dependency>
    12.        <groupId>test</groupId>
    13.        <artifactId>a</artifactId>
    14.        <version>1.2</version>
    15.      </dependency>
    16.      <dependency>
    17.        <groupId>test</groupId>
    18.        <artifactId>c</artifactId>
    19.        <version>1.0</version>
    20.        <scope>compile</scope>
    21.      </dependency>
    22.    </dependencies>
    23.  </dependencyManagement>
    24. </project>
     

    Project Z: 
     

    1. <project>
    2.   <modelVersion>4.0.0</modelVersion>
    3.   <groupId>maven</groupId>
    4.   <artifactId>Z</artifactId>
    5.   <packaging>pom</packaging>
    6.   <name>Z</name>
    7.   <version>1.0</version>
    8.  
    9.   <dependencyManagement>
    10.     <dependencies>
    11.       <dependency>
    12.         <groupId>maven</groupId>
    13.         <artifactId>X</artifactId>
    14.         <version>1.0</version>
    15.         <type>pom</type>
    16.         <scope>import</scope>
    17.       </dependency>
    18.       <dependency>
    19.         <groupId>maven</groupId>
    20.         <artifactId>Y</artifactId>
    21.         <version>1.0</version>
    22.         <type>pom</type>
    23.         <scope>import</scope>
    24.       </dependency>
    25.     </dependencies>
    26.   </dependencyManagement>
    27. </project>
     

    在上面的示例中，Z从X和Y导入托管依赖项。然而，X和Y都包含依赖项a。这里，将使用a的1.1版本，因为X是首先声明的，而a不是在Z的dependencyManagement中声明的。
     这个过程是递归的。例如，如果X导入另一个POM Q，那么当Z被处理时，它将简单地显示出Q的所有托管依赖项都是在X中定义的。
     

    五、BOM表POM
     

    当用于定义通常是多项目构建的一部分的相关工件的“库”时，导入最有效。一个项目使用这些库中的一个或多个工件是相当常见的。然而，有时很难使用工件来保持项目中的版本与库中分发的版本同步。下面的模式说明了如何创建“BOM表”（BOM）以供其他项目使用。
     项目的根是BOM POM。它定义了将在库中创建的所有工件的版本。其他希望使用库的项目应该将此POM导入其POM的dependencyManagement部分。
     

    1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    2.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    3.   <modelVersion>4.0.0</modelVersion>
    4.   <groupId>com.test</groupId>
    5.   <artifactId>bom</artifactId>
    6.   <version>1.0.0</version>
    7.   <packaging>pom</packaging>
    8.   <properties>
    9.     <project1Version>1.0.0</project1Version>
    10.     <project2Version>1.0.0</project2Version>
    11.   </properties>
    12.  
    13.   <dependencyManagement>
    14.     <dependencies>
    15.       <dependency>
    16.         <groupId>com.test</groupId>
    17.         <artifactId>project1</artifactId>
    18.         <version>${project1Version}</version>
    19.       </dependency>
    20.       <dependency>
    21.         <groupId>com.test</groupId>
    22.         <artifactId>project2</artifactId>
    23.         <version>${project2Version}</version>
    24.       </dependency>
    25.     </dependencies>
    26.   </dependencyManagement>
    27.  
    28.   <modules>
    29.     <module>parent</module>
    30.   </modules>
    31. </project>
     

    父子项目将BOM POM作为其父项目。这是一个正常的多项目pom。
     

    1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    2.      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    3.   <modelVersion>4.0.0</modelVersion>
    4.   <parent>
    5.     <groupId>com.test</groupId>
    6.     <version>1.0.0</version>
    7.     <artifactId>bom</artifactId>
    8.   </parent>
    9.  
    10.   <groupId>com.test</groupId>
    11.   <artifactId>parent</artifactId>
    12.   <version>1.0.0</version>
    13.   <packaging>pom</packaging>
    14.  
    15.   <dependencyManagement>
    16.     <dependencies>
    17.       <dependency>
    18.         <groupId>log4j</groupId>
    19.         <artifactId>log4j</artifactId>
    20.         <version>1.2.12</version>
    21.       </dependency>
    22.       <dependency>
    23.         <groupId>commons-logging</groupId>
    24.         <artifactId>commons-logging</artifactId>
    25.         <version>1.1.1</version>
    26.       </dependency>
    27.     </dependencies>
    28.   </dependencyManagement>
    29.   <modules>
    30.     <module>project1</module>
    31.     <module>project2</module>
    32.   </modules>
    33. </project>
     

     接下来是实际的项目POM：
     

    1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    2.      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    3.   <modelVersion>4.0.0</modelVersion>
    4.   <parent>
    5.     <groupId>com.test</groupId>
    6.     <version>1.0.0</version>
    7.     <artifactId>parent</artifactId>
    8.   </parent>
    9.   <groupId>com.test</groupId>
    10.   <artifactId>project1</artifactId>
    11.   <version>${project1Version}</version>
    12.   <packaging>jar</packaging>
    13.  
    14.   <dependencies>
    15.     <dependency>
    16.       <groupId>log4j</groupId>
    17.       <artifactId>log4j</artifactId>
    18.     </dependency>
    19.   </dependencies>
    20. </project>
    21.  
    22. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    23.      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    24.   <modelVersion>4.0.0</modelVersion>
    25.   <parent>
    26.     <groupId>com.test</groupId>
    27.     <version>1.0.0</version>
    28.     <artifactId>parent</artifactId>
    29.   </parent>
    30.   <groupId>com.test</groupId>
    31.   <artifactId>project2</artifactId>
    32.   <version>${project2Version}</version>
    33.   <packaging>jar</packaging>
    34.  
    35.   <dependencies>
    36.     <dependency>
    37.       <groupId>commons-logging</groupId>
    38.       <artifactId>commons-logging</artifactId>
    39.     </dependency>
    40.   </dependencies>
    41. </project>
     

    下面的项目显示了现在如何在另一个项目中使用库，而不必指定依赖项目的版本：
     

    1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    2.      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    3.   <modelVersion>4.0.0</modelVersion>
    4.   <groupId>com.test</groupId>
    5.   <artifactId>use</artifactId>
    6.   <version>1.0.0</version>
    7.   <packaging>jar</packaging>
    8.  
    9.   <dependencyManagement>
    10.     <dependencies>
    11.       <dependency>
    12.         <groupId>com.test</groupId>
    13.         <artifactId>bom</artifactId>
    14.         <version>1.0.0</version>
    15.         <type>pom</type>
    16.         <scope>import</scope>
    17.       </dependency>
    18.     </dependencies>
    19.   </dependencyManagement>
    20.   <dependencies>
    21.     <dependency>
    22.       <groupId>com.test</groupId>
    23.       <artifactId>project1</artifactId>
    24.     </dependency>
    25.     <dependency>
    26.       <groupId>com.test</groupId>
    27.       <artifactId>project2</artifactId>
    28.     </dependency>
    29.   </dependencies>
    30. </project>
     

     最后，在创建导入依赖项的项目时，请注意以下事项：
     

    • 请勿尝试导入在当前POM的子模块中定义的POM。尝试这样做将导致构建失败，因为它将无法定位POM。
    • 切勿将导入POM的POM声明为目标POM的父级（或祖级等）。无法解析循环，将引发异常。
    • 当引用其POM具有可传递依赖性的工件时，项目需要将这些工件的版本指定为托管依赖性。不这样做会导致生成失败，因为工件可能没有指定版本。（在任何情况下，这都应该被视为最佳实践，因为它防止工件的版本从一个构建更改到下一个构建）。
     

    从Maven4.0开始，引入了一种新的特定BOM打包。它允许定义一个BOM表，该BOM表在利用较新的4.1.0模型的项目中不用作父级，同时仍然提供与Maven 3.X客户端和项目的完全兼容性。在安装/部署时，利用Maven 4的构建/消费者POM功能，将此BOM打包转换为更常见的POM打包。因此，这提供了与Maven 3.x的完全兼容性。
     

    1. <project xmlns="http://maven.apache.org/POM/4.1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    2.     xsi:schemaLocation="http://maven.apache.org/POM/4.1.0 http://maven.apache.org/xsd/maven-4.1.0.xsd">
    3.   <parent>
    4.     <groupId>com.test</groupId>
    5.     <version>1.0.0</version>
    6.     <artifactId>parent</artifactId>
    7.   </parent>
    8.   <groupId>com.test</groupId>
    9.   <artifactId>bom</artifactId>
    10.   <version>1.0.0</version>
    11.   <packaging>bom</packaging>
    12.   <properties>
    13.     <project1Version>1.0.0</project1Version>
    14.     <project2Version>1.0.0</project2Version>
    15.   </properties>
    16.   <dependencyManagement>
    17.     <dependencies>
    18.       <dependency>
    19.         <groupId>com.test</groupId>
    20.         <artifactId>project1</artifactId>
    21.         <version>${project1Version}</version>
    22.       </dependency>
    23.       <dependency>
    24.         <groupId>com.test</groupId>
    25.         <artifactId>project2</artifactId>
    26.         <version>${project2Version}</version>
    27.       </dependency>
    28.     </dependencies>
    29.   </dependencyManagement>
    30.  </project>
    
                
    
                    
    
                
    • 

                
  • 

                    相关阅读:
    
                    
关于gdb调试: 你的问题可能会在这里找到答案                            
    
计算机网络期末复习-Part2                            
    
【macOS】Win通过VNC远程控制Macbook                            
    
ESP8266-Arduino编程实例-LSM303 3D加速度计/磁力计驱动                            
    
Unity中Shader的Lambert光照的实现                            
    
VirtualLab Fusion中的参数耦合                            
    
RT-Thread STM32F407 PWM                            
    
linux-守护进程daemon                            
    
数字孪生与智慧城市：重塑未来城市生活的奇迹                            
    
vue3.0组合式api使用总结                            
    
                        
                
    • 
                
  • 
                    原文地址：https://blog.csdn.net/leesinbad/article/details/133862563
                
    •