煮酒与君饮

这个屌丝很懒，什么也没留下！

热门标签

Maven项目管理学习记录_本地开发不同项目 maven管理

作者：煮酒与君饮 | 2024-08-07 12:57:06

踩

本地开发不同项目 maven管理

前瞻导读

不要下载最新版Maven，不要下载最新版Maven，不要下载最新版Maven，重要的事情说三遍，推荐下载与你所使用的IDEA发行时间较近的Maven，例如我所使用的是IntelliJ IDEA 2021.1.3 ，下载的Maven是apache-maven-3.8.2-bin.tar，点击这里查看不同Maven版本的发行时间。

1、Maven概述

1.1、为什么学Maven?

①不需要下载或寻找jar包

②能解决jar包版本冲突和依赖的问题

③Maven 能节省花费在编译、打包、部署、测试上的时间(一个功能开发完成后会经历编译、打包、部署、测试的流程，如果测试发现问题后开发人员将问题解决了又需要经历编译、打包、部署、测试的步骤，而Maven将编译、打包、部署、测试功能集成到一起，因此节省了时间)

(注意：这里的测试只能检测语法错误)

1.2、什么是Maven?

Maven工具是基于POM（Project Object Model，项目对象模型）模式实现的。在Maven中每个项目都相当于是一个对象，对象（项目）和对象（项目）之间是存在关系的。关系包含了：依赖、继承、聚合，实现Maven项目可以更加方便的实现导jar包、拆分项目等效果。

Maven 是跨平台的，这意味着无论是在 Windows 上，还是在 Linux 或者 Mac 上，都可以使用同样的命令。

Maven 还有一个优点，它能帮助我们标准化构建过程。在 Maven 之前，十个项目可能有十种构建方式。有了 Maven 之后，所有项目的构建命令都是标准化。

1.3、Maven的作用

①.Maven 统一集中管理所有的依赖包，不需要去寻找对应第三方组件用到的共同 jar，并且自动解决重复和冲突问题。

②.Maven 可以统一每个项目的构建过程，实现不同项目的兼容性管理。

③.Maven 作为一个开放的架构，提供了公共接口，方便同第三方插件集成。在开发过程中可以将自己需要的插件动态地集成到 Maven，从而扩展新的管理功能。

1.4、Maven工程类型

1、MPO工程

POM工程是逻辑工程。用在聚合工程中，或者父级工程用来做jar包的版本控制。

2、JAR工程

创建一个 Java Project，在打包时会将项目打成jar包。

3、WAR工程

创建一个Web Project，在打包时会将项目打成war包。

2、Maven的下载与安装

Maven是在JAVA语言的基础上开发的，因此也需要JDK的支持，通过如下命令查看自己是否已经安装好了JDK环境：

首先下载JDK18，下载自己电脑对应的版本，这里我选择下载Windows安装程序：

下载完成后安装到默认安装路径(记一下位置，待会儿配环境变量时需要用到)，安装时无脑下一步即可，接下来配置环境变量：右键此电脑 => 属性 => 高级系统设置 => 环境变量 => 在系统变量中点击新建名为JAVA_HOME的环境变量，值为刚才安装JDK的默认安装路径：

找到系统环境变量中的PATH,点击编辑(直接双击PATH效果一样)，在内容最前面添加%JAVA_HOME%\bin;

接下来验证我们的JDK环境变量是否配置成功：


# 首先通过快捷键 win + R 打开运行窗口，并在窗口中输入cmd，输完回车即可
 
# 查看是否存在JAVA_HOME的环境变量
echo %JAVA_HOME%
 
# 查看PATH中是否存在JAVA_HOME
echo %PATH%

如果在用户环境变量中也存在JAVA_HOME，需要将其删除，否则会显示用户环境变量中的JAVA_HOME路径，影响验证结果(即使JDK文件不存在也会显示用户环境变量中的JAVA_HOME路径)：

确认配置好JDK后，可以去Maven官网下载适合自己的后缀为bin.zip的压缩文件也可下载与我相同的Maven压缩文件apache-maven-3.8.2-bin.tarhttps://pan.baidu.com/s/1ittz-OJEHknIUZPopzJbaQ?pwd=3viv%C2%A0

将下载好的压缩包解压到一个英文目录下：

解压完Maven压缩包后再去配置环境变量：右键此电脑 => 属性 => 高级系统设置 => 环境变量 => 在系统变量中点击新建名为MAVEN_HOME的环境变量，值为刚才Maven解压的路径：

接下来将创建的MAVEN_HOME配置到PATH中，首先在系统变量中找到PATH并双击打开:

在新打开的窗口中点击新建 => 在新输入框中填入%MAVEN_HOME%\bin => 确认

配置完环境变量后打开cmd，输入mvn -v 查看Maven环境是否配置成功(出现下图信息说明配置成功)：

3、IDEA整合Maven

首先创建任意一个java工程，首先将IDEA内置的Maven替换成我们下载的Maven：

选择File => Settings => Build, Execution, Deployment => Build Tools => Maven

选择Maven home path 后的三个小点，在弹出的窗口中选择我们在第二章节解压好的Maven文件，选择完成后再点击Apply:

至此，已经整合了IDEA和Maven.

4、Maven仓库与配置

概述：Maven仓库是基于简单文件系统存储的，集中化管理Java API资源（构件）的一个服务。Maven采用坐标机制，仓库中的任何一个构件都有其唯一的坐标，根据这个坐标可以定义其在仓库中的唯一存储路径，任何 Maven项目使用任何一个构件的方式都是完全相同的，Maven 可以在某个位置统一存储所有的 Maven 项目共享的构件，这个统一的位置就是仓库，项目构建完毕后生成的构件也可以安装或者部署到仓库中，供其它项目使用。

坐标：坐标由三个部分构成，包括公司名，项目名和版本号，任何一个部分不同表示的就是不同的jar。

Group Id: 公司名，多用公司网址倒写比如：com.muxikeqi

Artifact Id: 项目名 b比如：mavenDemo

Version: 版本

对于Maven来说，仓库分为本地仓库和中央仓库。

4.1、中央仓库

概述：中央仓库是互联网上的服务器,是Maven提供的最大的仓库，里面拥有最全的jar包资源。默认是Maven自己的网络服务器，但是由于访问速度慢，一般都配置成国内的镜像中央仓库。

Maven中央仓库访问页面：Maven Repository: Search/Browse/Explore

阿里镜像：https://maven.aliyun.com

4.2、本地仓库

概述：本地仓库指用户电脑中的文件夹,该文件夹中包含了自己下载的构件(jar包)。文件夹结构为groupid分级的文件夹/artifactid文件夹/version文件夹/包含jar包。

4.3、仓库访问优先级

首先会访问本地仓库，在本地仓库无法获取资源的时候，直接访问中央仓库。并将中央仓库中的资源下载到本地仓库，这样下次在其它maven项目中使用该资源便可以从本地仓库中获取了。(中央仓库在国外，大陆访问速度较慢，建议使用国内的镜像仓库)

5、配置Maven

配置Maven是在maven安装包的解压目录（D:\bigDataStudy\Maven\apache-maven-3.9.6）下的conf/settings.xml文件中做以下配置(解压目录可能存在差异)：

5.1、配置本地仓库

首先配置本地仓库的存储位置，需要在windows的此电脑中提前准备好文件夹(如果文件路径与演示的不一样，请以自己准备的文件夹路径为准)：

<localRepository>D:\bigDataStudy\Maven\LocalWarehouse</localRepository>

修改完配置文件内容中的本地仓库后还要更改IDEA中本地仓库的位置(指定settings.xml配置文件路径和本地仓库路径)，进入File => New Projects Settings => Settings for New Projects... ,安装下图步骤完成配置，后期创建的Maven项目就不用再重复的手动配置了：

提示：Maven配置会出现还原的情况，将D:\bigDataStudy\Maven\apache-maven-3.8.2\conf\settings.xml复制一份，替换C:\Users\Administrator\.m2\settings.xml。

5.2、配置镜像仓库

找到settings.xml文件中的mirrors标签，将mirrors标签中的mirror标签的内容替换为如下内容：


<mirror>
 <!-- 指定镜像ID -->   
 <id>aliyunmaven</id>
 <!-- 匹配镜像仓库。-->
 <mirrorOf>*</mirrorOf>
 <!-- 指定镜像名称 -->
 <name>阿里云公共仓库</name>
 <!-- 指定镜像路径 -->
 <url>https://maven.aliyun.com/repository/public</url>
</mirror>

5.3、配置JDK

找到settings.xml文件中的profiles标签，在该标签中添加如下内容：


<profile>           
  <id>jdk-1.8</id>            
  <activation>                
    <activeByDefault>true</activeByDefault>             
    <jdk>1.8</jdk>          
  </activation>           
  <properties>            
    <maven.compiler.source>1.8</maven.compiler.source>                   
    <maven.compiler.target>1.8</maven.compiler.target>
    <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>            
  </properties>   
</profile>

6、Maven工程创建及其目录介绍

6.1、Maven工程创建

打开IDEA，选择File => New => project...

按照下图步骤进行操作：

为项目取名并设置好存储路径：

由于在第5章我们提前配置了Maven项目新建的相关配置，这里直接Finish即可：

创建Maven项目后，IDEA会默认打开pom.xml(Maven项目名)文件，不报错就证明创建成功了：

6.2、Maven目录介绍

src 包含了项目所有的源代码和资源文件以及测试代码。
src/main/java 这个目录下储存java源代码
src/main/resources 储存主要的资源文件。
src/test/java 存放测试代码。
target 编译后内容放置的文件夹。

pom.xml 是Maven的基础配置文件，也是Maven项目核心配置文件，用于配置项项目的基本信息，项目的继承关系，项目类型，依赖管理，依赖注入，插件管理，插件注入等。

--demo1 项目名

--.idea 项目的配置，自动生成的，不需要关注。

-- main 实际开发内容

--java 写包和java代码，此文件默认只编译.java文件

--resource 所有配置文件。最终编译把配置文件放入到classpath中。

--java 测试时使用，自己写测试类或junit工具等

pom.xml 整个maven项目所有配置内容。

在新建的Maven项目中是没有src/main/resources的，可以参考下面博文的介绍：

Intellij IDEA系列教材（十）- 基础 - idea 创建的 maven项目没有 resources目录_idea没有resource文件夹-CSDN博客文章浏览阅读339次，点赞11次，收藏10次。有时候 idea 创建的 maven 项目没有resources目录, 但是项目开发又需要，怎么办呢？接着右键点击 resources 目录，然后点击 Resources 就大功告成啦。然后菜单 -> File -> Project Structure。4. 点击 New Folder, 然后输入 resources。请按照一下步骤来手动添加 resources 目录。1. 点击左边的 Modules。2. 点击 Sources。3. 右键点击 main。_idea没有resource文件夹https://blog.csdn.net/Lan_ht/article/details/135284325

7、POM模型

7.1、依赖关系

概述：依赖关系就是依赖谁就是将谁的jar包添加到本项目中。(可以依赖中央仓库的jar，也可以依赖当前开发中其他项目打包后的jar包)

在项目的pom.xml文件中，根元素project下的 dependencies标签中配置依赖信息，依赖信息可以包含多个 dependence元素，以声明多个依赖。

每个依赖dependence标签都应该包含以下元素：groupId, artifactId, version : 依赖的基本坐标，对于任何一个依赖来说，基本坐标是最重要的， Maven根据坐标才能找到需要的依赖。

7.1.1、依赖的传递性

概述：依赖传递性是Maven2.0的新特性。如果某个项目依赖于一个A.jar包，而这个A.jar包又依赖于其他多个jar包，此时不需要自己去找其他所有jar依赖，只需加上直接依赖的A.jar包的坐标，Maven会隐式的把A.jar包间接依赖的库也加入到该项目中。

实操：接下来我们尝试通过pom.xml从中央仓库中下载Zookeeper依赖库并导入到本地仓库，首先进入中央仓库根据如下步骤操作找我们需要的jar包：

打开刚刚创建好的Maven项目中的pom.xml文件：

完成以上步骤后，我们就将中央仓库的zookeeper及其依赖包都下载到了本地仓库，找到本地仓库目录下的包名下的项目名目录下的文件，这些文件就是我们下载Zookeeper的相关依赖：

7.1.2、依赖相同资源的原则

7.1.2.1、第一原则：最短路径优先原则

概述：“最短路径优先”意味着项目依赖关系树中路径最短的版本会被使用。

举例：假设A、B、C之间的依赖关系是A => B => C => D(1.x)和A => E => D(2.x)，那么D(2.x)会被使用，因为A通过E到D的路径更短。

7.1.2.2、第二原则：最先声明原则

概述：当第一原则不能解决问题时将采用第二原则，在依赖路径长度相等的前提下，在POM中顺序最靠前的依赖声明优先被使用。

举例：假设A、B、C之间的依赖关系是A => B => Y(1.x)，A => C => Y(2.x)，Y(1.x)和Y(2.x)的依赖路径长度是一样的，此时使用第一原则就无法决定使用Y(1.x)还是Y(2.x)，根据从maven2.0.9开始使用的第二原则，在两个相同资源长度相同的情况下，由于Y(1.x)首先被声明，所以Y(1.x)被使用。

总结：第一原则和第二原则都用于解决相同资源版本冲突的问题。

7.1.3、排除依赖

概述：排除依赖通过在dependency标签中添加exclusions标签实现，exclusions标签包含多个exclusion标签，exclusion标签里面有groupId和artifactId两项基本元素。

实操：将org.apache.zookeeper:zookeeper:3.7.0下的log4j:log4j:1.2.17依赖排除：

首先打开IDEA中之前导入过zookeeper依赖库的项目，在dependency标签中添加如下配置：


<dependency>
      <groupId>org.apache.zookeeper</groupId>
      <artifactId>zookeeper</artifactId>
      <version>3.7.0</version>
      <exclusions>
        <exclusion>
          <groupId>log4j</groupId>
          <artifactId>log4j</artifactId>
        </exclusion>
      </exclusions>
</dependency>

参考流程如下图：

执行上图流程后结果如下：

通过观察能够发现要求删除的log4j:log4j:1.2.17依赖通过exclusion标签成功排除。

7.1.4、依赖范围

依赖范围由scope标签设置，其取值如下：

compile：默认依赖范围，表示该依赖在编译和运行时生效，在项目打包时会将该依赖包含进去。

provided：可以参与编译，测试，运行等周期，但是不会被打包到最终的artifact中。典型的例子是servlet-api在编译和测试项目的时候需要该依赖，但在项目打包的时候，由于servlet容器已经提供了servlet-api，就不需要Maven重复引入一遍servlet-api。

runtime：runtime的依赖范围在编译时不生效，只在运行时生效。典型的例子是JDBC驱动实现，项目主代码的编译只需要JDK提供的JDBC接口，只有在执行测试或者运行项目的时候才需要实现上述接口的具体JDBC驱动。

test：test依赖范围只在编译测试代码和运行测试的时候需要，应用的正常运行不需要此类依赖。典型的例子就是JUnit，它只有在编译测试代码及运行测试的时候才需要。

system：部分依赖的jar包不存在Maven坐标，可以将jar包下载到本地硬盘，通过system来引用。


<dependency>
 <groupId>junit</groupId>
 <artifactId>junit</artifactId>
 <version>4.11</version>
 <scope>test</scope>
</dependency>

7.1.5、依赖管理

概述：Maven通过依赖管理元素<dependencyManagement>集中管理依赖信息，如果有多个项目继承自同一个公有的父项目，此时可以将所有的依赖信息放在一个公共的POM文件中并在POM中引用该构件即可。

实操：新建一个Maven工程，通过<dependencyManagement>集中管理HDFS,Mapreduce,Yarn和zookeeper依赖库(依赖库从中央仓库或镜像仓库获取任意版本即可)。


# 从镜像仓库获取HDFS,Mapreduce和Yarn后的dependencies  
  <dependencies>
      <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.11</version>
        <scope>test</scope>
      </dependency>
 
      <!-- https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-hdfs -->
      <dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-hdfs</artifactId>
        <version>2.7.2</version>
        <scope>test</scope>
      </dependency>
 
      <!-- https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-yarn-api -->
      <dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-yarn-api</artifactId>
        <version>2.7.2</version>
      </dependency>
 
      <!-- https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-mapreduce-client-core -->
      <dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-mapreduce-client-core</artifactId>
        <version>2.7.3</version>
      </dependency>
 
      <!-- https://mvnrepository.com/artifact/org.apache.zookeeper/zookeeper -->
      <dependency>
        <groupId>org.apache.zookeeper</groupId>
        <artifactId>zookeeper</artifactId>
        <version>3.4.3</version>
        <type>pom</type>
      </dependency>
 
    </dependencies>

由于<dependencyManagement>中的<dependency>只包含groupId和artifactId信息，因此需要将版本信息声明在<properties>标签中：


 <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
    <junit.vertion>4.11</junit.vertion>
    <hadoop-hdfs.version>2.7.2</hadoop-hdfs.version>
    <hadoop-yarn-api.version>2.7.2</hadoop-yarn-api.version>
    <hadoop-mapreduce.version>2.7.3</hadoop-mapreduce.version>
    <zookeeper.version>3.4.3</zookeeper.version>
  </properties>

然后将dependency中的版本信息通过${定义在properties中的版本号}调用，最后将<dependencyManagement>管理整个dependencys即可，完整pom.xml文件内容如下：


<?xml version="1.0" encoding="UTF-8"?>
 
<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.example</groupId>
  <artifactId>demo2</artifactId>
  <version>1.0-SNAPSHOT</version>
 
  <name>demo2</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>
 
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
    <junit.vertion>4.11</junit.vertion>
    <hadoop-hdfs.version>2.7.2</hadoop-hdfs.version>
    <hadoop-yarn-api.version>2.7.2</hadoop-yarn-api.version>
    <hadoop-mapreduce.version>2.7.3</hadoop-mapreduce.version>
    <zookeeper.version>3.4.3</zookeeper.version>
  </properties>
 
  <dependencyManagement>
 
    <dependencies>
      <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.11</version>
        <scope>test</scope>
      </dependency>
 
      <!-- https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-hdfs -->
      <dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-hdfs</artifactId>
        <version>${hadoop-hdfs.version}</version>
        <scope>test</scope>
      </dependency>
 
      <!-- https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-yarn-api -->
      <dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-yarn-api</artifactId>
        <version>${hadoop-yarn-api.version}</version>
      </dependency>
 
      <!-- https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-mapreduce-client-core -->
      <dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-mapreduce-client-core</artifactId>
        <version>${hadoop-mapreduce.version}</version>
      </dependency>
 
      <!-- https://mvnrepository.com/artifact/org.apache.zookeeper/zookeeper -->
      <dependency>
        <groupId>org.apache.zookeeper</groupId>
        <artifactId>zookeeper</artifactId>
        <version>${zookeeper.version}</version>
        <type>pom</type>
      </dependency>
 
    </dependencies>
 
  </dependencyManagement>
 
 
  <build>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
        <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
        <plugin>
          <artifactId>maven-site-plugin</artifactId>
          <version>3.7.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-project-info-reports-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

再对pom.xml文件进行install操作即可。

7.2、继承关系

7.2.1、单继承

概述：Maven中的继承跟Java中的继承概念一样，需要有父项目以及子项目。我们可以将项目中的依赖和插件配置提取出来在父项目中集中定义，从而更方便的管理项目的依赖以及插件(注意父项目类型一定为POM类型)

实操：

首先创建一个名为parent的Maven工程，该项目用来管理所有的依赖库：

删除父项目的src目录(因为parent项目只管理所有依赖库，不做开发处理)：

接下来修改父项目parent的pom.xml文件，完整pom.xml内容如下（最重要的是将工程类型设置为POM）【这一步是父项目从镜像仓库中下载依赖库到本地】：


<?xml version="1.0" encoding="UTF-8"?>
 
<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.muxikeqi</groupId>
  <artifactId>parent</artifactId>
  <version>1.0-SNAPSHOT</version>
 
  <!-- 指定工程类型为POM -->
  <packaging>pom</packaging>
 
  <name>parent</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>
 
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
    <junit.vertion>4.11</junit.vertion>
    <hadoop-hdfs.version>2.7.2</hadoop-hdfs.version>
    <hadoop-yarn-api.version>2.7.2</hadoop-yarn-api.version>
    <hadoop-mapreduce.version>2.7.3</hadoop-mapreduce.version>
  </properties>
 
  <dependencyManagement>
 
    <dependencies>
      <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.11</version>
        <scope>test</scope>
      </dependency>
 
      <!-- https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-hdfs -->
      <dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-hdfs</artifactId>
        <version>${hadoop-hdfs.version}</version>
        <scope>test</scope>
      </dependency>
 
      <!-- https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-yarn-api -->
      <dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-yarn-api</artifactId>
        <version>${hadoop-yarn-api.version}</version>
      </dependency>
 
      <!-- https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-mapreduce-client-core -->
      <dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-mapreduce-client-core</artifactId>
        <version>${hadoop-mapreduce.version}</version>
      </dependency>
 
    </dependencies>
 
  </dependencyManagement>
 
  <build>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
        <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
        <plugin>
          <artifactId>maven-site-plugin</artifactId>
          <version>3.7.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-project-info-reports-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

配置完pom.xml文件后对父项目parent的pom.xml文件执行install操作，操作完成后父类就准备完成了：

接下来创建子工程：

创建好子项目后，来到parent项目，截取parent项目的坐标信息用于为子项目指定继承的父项目：

在子项目中通过parent标签指定父项目的坐标信息：


 <parent>
    <groupId>com.muxikeqi</groupId>
    <artifactId>parent</artifactId>
    <version>1.0-SNAPSHOT</version>
  </parent>

接下来操作子项目child继承父项目parent中的Mapreduce和Yarn，完整pom.xml文件内容如下：


<?xml version="1.0" encoding="UTF-8"?>
 
<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>
 
  <!-- 让当前项目继承parent项目 -->
  <parent>
    <groupId>com.muxikeqi</groupId>
    <artifactId>parent</artifactId>
    <version>1.0-SNAPSHOT</version>
  </parent>
 
  <groupId>com.extend_muxikeqi</groupId>
  <artifactId>child</artifactId>
  <version>1.0-SNAPSHOT</version>
 
  <name>child</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>
 
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>
 
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <scope>test</scope>
    </dependency>
 
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-yarn-api</artifactId>
    </dependency>
 
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-mapreduce-client-core</artifactId>
    </dependency>
  </dependencies>
 
  <build>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
        <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
        <plugin>
          <artifactId>maven-site-plugin</artifactId>
          <version>3.7.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-project-info-reports-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

需要注意的是，子类继承父类时只需指明groupId和artifactId，版本信息由父类管理。

继承的优点：

1、依赖或插件的统一管理（需要变更依赖(dependency)版本时，只需要修改父类的版本）。

2、代码简洁，子类中只需要指定继承的父类和继承的groupId与artifactId即可。

3、dependencyManagement采用“按需引入”原则，子类指定继承哪些依赖库就只继承指定的依赖库，并不会将dependencyManagement中所有的依赖库都继承下来。

7.2.2、多继承

概述：当一个项目需要从多个项目中继承时，我们可以在子项目中通过添加<dependencyManagement>标签来实现多继承。在子项目的中<dependencyManagement>中每个<dependency>标签就是一个父项目的定义，同时还需要添加<type>标签，值为pom，添加<scope>标签，值为import。

实操：首先创建一个父项目parent1：

由于这里的父项目只管理依赖库，因此这里将src目录删除：

接下来修改parent1的pom.xml文件，主要是为parent1从镜像仓库中引入hdfs，完整文件内容如：下(别忘了将父项目通过packaging指定为pom)：


<?xml version="1.0" encoding="UTF-8"?>
<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.example</groupId>
    <artifactId>parent1</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--  指定父项目为pom  -->
    <packaging>pom</packaging>
 
    <properties>
        <hadoop-hdfs.version>2.7.2</hadoop-hdfs.version>
    </properties>
 
    <dependencyManagement>
        <dependencies>
            <!-- https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-hdfs -->
            <dependency>
                <groupId>org.apache.hadoop</groupId>
                <artifactId>hadoop-hdfs</artifactId>
                <version>${hadoop-hdfs.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
 
</project>

编写完pom.xml文件后，在右侧的Maven窗口按以下顺序执行：compole => Run(绿色三角形图标) => install => Run(绿色三角形图标)

完成以上操作后，我们的父项目parent1就准备完成了：

接下来继续创建一个Maven父项目parent2：

和父项目parent1一样，删除src目录，在pom.xml文件中指定为pom，并从镜像仓库导入Mapreduce，再执行编译和安装操作，具体流程如下图：

完整pom.xml配置文件内容如下：


<?xml version="1.0" encoding="UTF-8"?>
<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.example</groupId>
    <artifactId>parent2</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
 
    <properties>
        <hadoop-mapreduce.version>2.7.3</hadoop-mapreduce.version>
    </properties>
 
    <dependencyManagement>
        <dependencies>
            <!-- https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-mapreduce-client-core -->
            <dependency>
                <groupId>org.apache.hadoop</groupId>
                <artifactId>hadoop-mapreduce-client-core</artifactId>
                <version>${hadoop-mapreduce.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
 
</project>

操作完以上步骤后，得到以下结果：

至此，实操练习需要的两个父项目就准备完毕了，接下来创建一个子项目来继承两个父项目：

创建完子项目后，首先来到项目parent1复制其坐标信息用于子项目中声明继承了哪一个项目：

来到子项目child的pom.xml文件中，按照下图流程来继承parent1的hdfs依赖库:

按照上图相同的步骤继承parent2的mapreduce依赖库，完整child项目的pom.xml内容如下：


<?xml version="1.0" encoding="UTF-8"?>
<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.example</groupId>
    <artifactId>child</artifactId>
    <version>1.0-SNAPSHOT</version>
 
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
 
    <!--  指定继承哪些项目  -->
    <dependencyManagement>
        <dependencies>
 
            <dependency>
                <groupId>org.example</groupId>
                <artifactId>parent1</artifactId>
                <version>1.0-SNAPSHOT</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
 
            <dependency>
                <groupId>org.example</groupId>
                <artifactId>parent2</artifactId>
                <version>1.0-SNAPSHOT</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
 
        </dependencies>
    </dependencyManagement>
 
    <!--  指定继承哪些依赖库  -->
    <dependencies>
        
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-hdfs</artifactId>
        </dependency>
 
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-mapreduce-client-core</artifactId>
        </dependency>
        
    </dependencies>
 
 
</project>

按照继承项目parent1的步骤继续继承项目parent2后结果如下：

总结：对比继承和多继承，唯一的区别就是声明继承父项目的内容，在继承中通过<parent>指定父项目的地址即可，而在多继承中通过<dependencyManagement>集中管理父项目，每个<dependency>就是一个项目，而且相比前面的继承还多了<type>信息和<scope>信息。

7.3、聚合关系

概述：聚合时多个项目的本质还是一个项目，这些项目被一个大的父项目包含，且这时父项目类型为pom类型，而且需要在父项目的pom.xml中添加<modules>标签表示包含的所有子模块。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/煮酒与君饮/article/detail/942646

Maven项目管理学习记录_本地开发 不同项目 maven管理