02-Maven高级-分模块开发依赖传递聚合继承（SpringBoot的部分底层原理）多模块开发(环境切换)Nexus私服搭建与使用

Posted 2023-04-01 奇迹是执着的人创造的

文章目录

• • 学习目标
  • 一、分模块开发与设计
  • • 1. 分模块开发的意义
    • • 问题导入
    • 模块拆分原则
    • 2. 分模块开发（模块拆分）
    • • 问题导入
      • 2.1 创建Maven模块
      • 2.2 书写模块代码
      • 2.3 通过maven指令安装模块到本地仓库（install指令）
      • 2.4 代码演示
  • 二、依赖管理
  • • 1. 依赖传递
    • • 问题导入
    • 2. 可选依赖
    • • 问题导入
    • 3. 排除依赖
    • • 问题导入
    • 4 可选依赖和排除依赖的区别
  • 三、聚合与继承
  • • 1. 聚合工程
    • • 问题导入
    • 2. 聚合工程开发
    • • 问题导入
      • 2.1 创建Maven模块，设置打包类型为pom
      • 2.2 设置当前聚合工程所包含的子模块名称
    • 3. 继承关系
    • • 问题导入
    • 4. 继承关系开发
    • • 4.1 创建Maven模块，设置打包类型为pom
      • 4.2 在父工程的pom文件中配置依赖关系（子工程将沿用父工程中的依赖关系）
      • 4.3 配置子工程中可选的依赖关系
    • 5. 聚合与继承的区别
    • • 问题导入
  • 四、属性管理
  • • 1. 属性
    • • 问题导入
      • 1.1 属性配置与使用
      • • ①：定义属性
        • ②：引用属性
      • 1.2 资源文件引用属性 （resources下的资源文件如何引用pom.xml里的属性值）
      • • ①：定义属性
        • ②：配置文件中引用属性
        • ③：开启资源文件目录加载属性的过滤器
      • 注意: 配置maven打war包时，忽略web.xml检查
      • 1.3 其他属性（了解）
    • 2. 版本管理
    • • 问题导入
      • 2.1 工程版本
      • 2.2 发布版本
  • 五、多环境配置与应用
  • • 1. 多环境配置作用
    • • 问题导入
    • 2. 多环境配置步骤
    • • 2.1 定义多环境
      • 2.2 使用多环境（构建过程）
    • 2. 跳过测试（了解）
    • • 问题导入
      • 2.1 应用场景
      • 2.2 跳过测试命令
      • 2.3 细粒度控制跳过测试
  • 六、私服
  • • 1. 私服介绍
    • • 问题导入
      • 1.1 介绍
      • 1.2 Nexus安装与启动
      • 1.3 私服资源操作流程分析
    • 2. 私服仓库分类
    • • 问题导入
    • 3. 资源上传与下载
    • • 问题导入
      • 3.0 私服中创建仓库
      • 3.1 从私服中下载依赖
      • 3.2 上传依赖到私服中
    • 4. 个人开发私服不会一直开着，改回阿里云服务器

学习目标

• 理解分模块开发的意义
• 能够使用聚合工程快速构建项目
• 能够使用继承简化项目配置
• 能够根据需求配置生产、开发、测试环境，并在各环境间切换运行

一、分模块开发与设计

1. 分模块开发的意义

问题导入

分模块开发对工程有什么好处？

模块拆分原则

目的：项目的扩展性变强了，方便其他项目引用相同的功能。

• 将原始模块按照功能拆分成若干个子模块，方便模块间的相互调用，接口共享

一个团队专门开发一个模块，开发好后给别人调用即可

2. 分模块开发（模块拆分）

问题导入

一个完整的工程依据什么来进行模块的拆分？

2.1 创建Maven模块

2.2 书写模块代码

注意事项：

1. 分模块开发需要先针对模块功能进行设计，再进行编码。不会先将工程开发完毕，然后进行拆分

2.3 通过maven指令安装模块到本地仓库（install指令）

mvn install

本地仓库有该模块包

注意事项：

1. 团队内部开发需要发布模块功能到团队内部可共享的仓库中（私服）

2.4 代码演示

环境搭建参考：springMVC02-SSM整合

页面以及代码文件直接复制粘贴然后修改下即可，不需要手写, 先准备好这些文件，(分模块创建的过程要自己做)

链接：https://pan.baidu.com/s/1ugCV7BRWleeaQC0mTejY1w
提取码：2xrg
代码在：maven_plus/code目录下

0. 先创建空的Project作为容器
   

1. 再创建maven_ssm 框架整合模块 (专门写一系列的配置文件的)
   
   创建目录结构如下：
   
   pom.xml先不管 直接根据参考博客里的全部复制过来

   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>cn.whu</groupId>
     <artifactId>maven_ssm</artifactId>
     <!-- 打包方式改成jar 得作为依赖给别人用 或者不写默认就是jar -->
     <packaging>jar</packaging>
     <version>1.0-SNAPSHOT</version>
   
     <dependencies>
       <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-webmvc</artifactId>
         <version>5.2.10.RELEASE</version>
       </dependency>
   
       <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-jdbc</artifactId>
         <version>5.2.10.RELEASE</version>
       </dependency>
   
       <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-test</artifactId>
         <version>5.2.10.RELEASE</version>
       </dependency>
   
       <dependency>
         <groupId>org.mybatis</groupId>
         <artifactId>mybatis</artifactId>
         <version>3.5.6</version>
       </dependency>
   
       <dependency>
         <groupId>org.mybatis</groupId>
         <artifactId>mybatis-spring</artifactId>
         <version>1.3.0</version>
       </dependency>
   
       <dependency>
         <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId>
         <version>5.1.47</version>
       </dependency>
   
       <dependency>
         <groupId>com.alibaba</groupId>
         <artifactId>druid</artifactId>
         <version>1.1.16</version>
       </dependency>
   
       <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>4.12</version>
         <scope>test</scope>
       </dependency>
   
       <dependency>
         <groupId>javax.servlet</groupId>
         <artifactId>javax.servlet-api</artifactId>
         <version>3.1.0</version>
         <scope>provided</scope>
       </dependency>
   
       <dependency>
         <groupId>com.fasterxml.jackson.core</groupId>
         <artifactId>jackson-databind</artifactId>
         <version>2.9.0</version>
       </dependency>
   
   	<!-- 不要lombok 只有pojo用得着 让他自己导入-->
   
     <build>
       <plugins>
         <plugin>
           <groupId>org.apache.tomcat.maven</groupId>
           <artifactId>tomcat7-maven-plugin</artifactId>
           <version>2.1</version>
           <configuration>
             <port>80</port>
             <path>/</path>
           </configuration>
         </plugin>
       </plugins>
     </build>
   
   </project>
   
   

   然后直接根据模版创建各种配置文件
   
   (以下文件全部创建(复制)完毕才不会报错)
   jdbc.properties
   JdbcConfig
   MybatisConfig
   ServletContainersInitConfig
   SpringMvcConfig
   SpringConfig
   

   

   打包到本地仓库，其他模块肯定要用到
   

2. 创建maven_pojo模块
   
   删除多余的目录，创建需要的目录
   
   pom.xml里加入lombok即可
   （打包方式改成jar 或者不写默认jar）

     <dependencies>
       <dependency>
         <groupId>org.projectlombok</groupId>
         <artifactId>lombok</artifactId>
         <version>1.18.26</version>
       </dependency>
     </dependencies>
   

   打包到本地仓库，其他模块要用
   

3. 创建maven_dao模块
   
   
   删除多余的（webapp目录），然后加上BookDao模块
   pom.xml 先引入需要的包，现在初学，保证不报错就OK了
   (直接导入maven_ssm 省时省力)
   （打包方式改成jar 或者不写默认jar）

     <dependencies>
       <!-- 直接引入maven_ssm -->
       <dependency>
         <groupId>cn.whu</groupId>
         <artifactId>maven_ssm</artifactId>
         <version>1.0-SNAPSHOT</version>
       </dependency>
       <!-- POJO模块之前打包到本地仓库了，可以直接引入了 -->
       <dependency>
         <groupId>cn.whu</groupId>
         <artifactId>maven_pojo</artifactId>
         <version>1.0-SNAPSHOT</version>
       </dependency>
     </dependencies>
   

   现在写BookDao，就不会报错了：

   public interface BookDao 
   
       @Insert("insert into tbl_book (type,name,description) values(#type,#name,#description)")
       public int save(Book book);
   
       @Update("update tbl_book set type = #type, name = #name, description = #description where id = #id")
       public int update(Book book);
   
       @Delete("delete from tbl_book where id = #id")
       public int delete(Integer id);
   
       @Select("select * from tbl_book where id = #id")
       public Book getById(Integer id);
   
       @Select("select * from tbl_book")
       public List<Book> getAll();
   
   

   

   打包到本地仓库，service模块要用

4. 创建maven_service模块
   
   删除多余的，加上service
   
   pom.xml:
   （打包方式改成jar 或者不写默认jar）

     <dependencies>
       <!-- 直接导入dao就行了 dao到如何ssm和pojo -->
       <dependency>
         <groupId>cn.whu</groupId>
         <artifactId>maven_dao</artifactId>
         <version>1.0-SNAPSHOT</version>
       </dependency>
     </dependencies>
   

   BookService
   BookServiceImpl
   

   

   打包失败，后面再学习如何解决；现在保证不报错就行

5. 创建maven_controller模块
   
   

   pom.xml直接引入maven_service即可

     <dependencies>
       <dependency>
         <groupId>cn.whu</groupId>
         <artifactId>maven_service</artifactId>
         <version>1.0-SNAPSHOT</version>
       </dependency>
     </dependencies>
   

   看看引用结构就知道了
   
   BookController
   Code
   ProjectExceptionAdvice
   Result
   BusinessException
   SystemException
   
   
   
   可能有不合理之处，但好歹人家不报错了~

6. maven_controller 里粘贴入页面
   
   

7. 测试执行

   controller的pom.xml里加入tomcat7插件

     <build>
       <plugins>
         <plugin>
           <groupId>org.apache.tomcat.maven</groupId>
           <artifactId>tomcat7-maven-plugin</artifactId>
           <version>2.1</version>
           <configuration>
             <port>80</port>
             <path>/</path>
           </configuration>
         </plugin>
       </plugins>
     </build>
   

启动服务器，直接访问：http://localhost/pages/books.html

功能正常，分模块开发，结束~

注意：
路径千万别写错了，想跳转webapp根目录下创建index.jsp然后写

<script>
    location.href="pages/books.html"
</script>

新建index.html不行

除了Controller，其他所有工程打包方式改成jar 或者不写默认jar，因为要作为依赖给别的项目用

二、依赖管理

• 依赖管理指当前项目运行所需的jar，一个项目可以设置多个依赖

• 格式：

<!--设置当前项目所依赖的所有jar-->
<dependencies>
    <!--设置具体的依赖-->
    <dependency>
        <!--依赖所属群组id-->
        <groupId>org.springframework</groupId>
        <!--依赖所属项目id-->
        <artifactId>spring-webmvc</artifactId>
        <!--依赖版本号-->
        <version>5.2.10.RELEASE</version>
    </dependency>
</dependencies>

1. 依赖传递

问题导入

A依赖B，B依赖C，A是否依赖于C呢？

A也依赖C，依赖具有传递性，而且可以重复不会特别冲突（后配置的会覆盖先配置的，版本之间差异较大可能冲突，springBoot自动版本管理，应该就很难出现这种问题了），所有直接依赖和间接依赖的总和为此项目的依赖全集

• 依赖具有传递性
  • 直接依赖：在当前项目中通过依赖配置建立的依赖关系
  • 间接依赖：被资源的资源如果依赖其他资源，当前项目间接依赖其他资源
  • 特殊优先：当同级配置了相同资源的不同版本，后配置的覆盖先配置的

同一个pom.xml中也可以写同一个依赖不同版本，后写的覆盖先写的，后写的生效（如下：最终就是junit4.12生效）

相同层级：eg：3度资源两个里面分别依赖的junit4.11和junit4.12 这时看谁写在前面
其实也不需要记忆，最终到maven->Dependencies下面看，展示出来的是谁就用谁

IDEA有一个maven神器，直接可以看到依赖结构图 （ctrl+滚轮 可以放大）

2. 可选依赖

问题导入

A依赖B，B依赖C，如果B不想将C依赖传递给A，是否可以做到？

• 可选依赖指对外隐藏当前所依赖的资源————不透明
• optional属性设置为true 就被隐藏了 只会在当前环境下有效，永不会被传递成为间接依赖

eg: 上图中 maven_controller依赖maven_service， maven_service依赖maven_dao
从而导致maven_controller间接依赖了maven_dao（从而依赖了后面的maven_ssm及其里面一系列jar）
下面在maven_service里将maven_dao隐藏起来，看看会发生什么

<dependency>
  <groupId>cn.whu</groupId>
  <artifactId>maven_dao</artifactId>
  <version>1.0-SNAPSHOT</version>
  <!--可选依赖是隐藏当前工程所依赖的资源，隐藏后对应资源将不具有依赖传递性-->
  <!-- optional属性设置为true 就被隐藏了 只会在当前环境下有效，永不会被传递成为间接依赖 -->
  <optional>true</optional>
</dependency>

再看maven_controller的依赖（"资金链"断裂，好可怜，啥都没了）

原因在于maven_service不想别人知道我用了啥，他的maven_dao就不允许被传递了，maven_controller要用maven_dao怎么办？自己在pom.xml里写直接依赖呗，然后直接依赖要是出了问题就跟我maven_dao没关系了（要是从我这传递的，你可能还会找我麻烦）

3. 排除依赖

问题导入

A依赖B，B依赖C，如果A不想将C依赖进来，是否可以做到？

(这次不是B不想传递依赖，而是A嫌弃B用的依赖C太low了，或者跟我冲突了，总之就是A不想用B传递过来的依赖C,想主动丢弃C，(然后自己直接依赖自己想要的包替代C))

• 排除依赖指主动断开依赖的资源，被排除的资源无需指定版本————不需要
• 排除依赖资源仅指定GA即可，无需指定V （G:groupId A:artifactId V:version）
• <exclusions> <exclusion>

场景模拟：
maven_dao里引入了log4j和mybatis，间接依赖了lombok

 <dependency>
   <groupId>log4j</groupId>
   <artifactId>log4j</artifactId>
   <version>1.2.12</version>
 </dependency>
 <dependency>
   <groupId>org.mybatis</groupId>
   <artifactId>mybatis</artifactId>
   <version>3.5.6</version>
 </dependency>

maven_service引入了maven_dao，但是不想要他传递过来的这2+1个依赖，咋办？（更深层次间间接依赖的lombok也不想要）

问题解决：

<dependency>
      <groupId>cn.whu</groupId>
      <artifactId>maven_dao</artifactId>
      <version>1.0-SNAPSHOT</version>
      <!--排除依赖是隐藏当前资源对应的依赖关系-->
      <exclusions>
        <exclusion>
          <groupId>log4j</groupId>
          <artifactId>log4j</artifactId>
        </exclusion>
        <exclusion>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis</artifactId>
        </exclusion>
        <!-- 甚至可以排除更深层次的间接依赖  (maven_dao->maven_ssm->lombok 也可以排除)-->
        <exclusion>
          <groupId>org.projectlombok</groupId>
          <artifactId>lombok</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

不想要的3个都没了

演示完毕，mybatis和lombok的排除要

Maven高级：聚合和继承

Maven高级

Maven高级：分模块开发
Maven高级：依赖管理

一、聚合和继承

我们的项目已经从以前的单模块，变成了现在的多模块开发。项目一旦变成了多模块开发以后，就会引发一些问题，在这一节中我们主要会学习两个内容聚合和继承，用这两个知识来解决下分模块后的一些问题。

1.1 聚合

• 分模块开发后，需要将这四个项目都安装到本地仓库，目前我们只能通过项目Maven面板的install来安装，并且需要安装四个，如果我们的项目足够多，那么一个个安装起来还是比较麻烦的
• 如果四个项目都已经安装成功，当ssm_pojo发生变化后，我们就得将ssm_pojo重新安装到maven仓库，但是为了确保我们对ssm_pojo的修改不会影响到其他项目模块，我们需要对所有的模块进行重新编译，那又需要将所有的模块再来一遍

项目少的话还好，但是如果项目多的话，一个个操作项目就容易出现漏掉或重复操作的问题，所以我们就想能不能抽取一个项目，把所有的项目管理起来，以后我们要想操作这些项目，只需要操作这一个项目，其他所有的项目都走一样的流程，这个不就很省事省力。

这就用到了我们接下来要讲解的聚合，

• 所谓聚合:将多个模块组织成一个整体，同时进行项目构建的过程称为聚合
• 聚合工程：通常是一个不具有业务功能的"空"工程（有且仅有一个pom文件）
• 作用：使用聚合工程可以将多个工程编组，通过对聚合工程进行构建，实现对所包含的模块进行同步构建
  • 当工程中某个模块发生更新（变更）时，必须保障工程中与已更新模块关联的模块同步更新，此时可以使用聚合工程来解决批量模块同步构建的问题。

关于聚合具体的实现步骤为:

步骤1:创建一个空的maven项目

步骤2:将项目的打包方式改为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.itheima</groupId>
    <artifactId>maven_01_parent</artifactId>
    <version>1.0-RELEASE</version>
    <packaging>pom</packaging>
    
</project>

**说明:**项目的打包方式，我们接触到的有三种，分别是

• jar:默认情况，说明该项目为java项目
• war:说明该项目为web项目
• pom:说明该项目为聚合或继承(后面会讲)项目

步骤3: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>com.itheima</groupId>
    <artifactId>maven_01_parent</artifactId>
    <version>1.0-RELEASE</version>
    <packaging>pom</packaging>
    
    <!--设置管理的模块名称-->
    <modules>
        <module>../maven_02_ssm</module>
        <module>../maven_03_pojo</module>
        <module>../maven_04_dao</module>
    </modules>
</project>

步骤4:使用聚合统一管理项目

测试发现，当maven_01_parent的compile被点击后，所有被其管理的项目都会被执行编译操作。这就是聚合工程的作用。

**说明：**聚合工程管理的项目在进行运行的时候，会按照项目与项目之间的依赖关系来自动决定执行的顺序和配置的顺序无关。

聚合的知识我们就讲解完了，最后总结一句话就是，聚合工程主要是用来管理项目。

1.2 继承

我们已经完成了使用聚合工程去管理项目，聚合工程进行某一个构建操作，其他被其管理的项目也会执行相同的构建操作。那么接下来，我们再来分析下，多模块开发存在的另外一个问题，重复配置的问题，我们先来看张图:

• spring-webmvc、spring-jdbc在三个项目模块中都有出现，这样就出现了重复的内容
• spring-test只在ssm_crm和ssm_goods中出现，而在ssm_order中没有，这里是部分重复的内容
• 我们使用的spring版本目前是5.2.10.RELEASE,假如后期要想升级spring版本，所有跟Spring相关jar包都得被修改，涉及到的项目越多，维护成本越高

面对上面的这些问题，我们就得用到接下来要学习的继承

• 所谓继承:描述的是两个工程间的关系，与java中的继承相似，子工程可以继承父工程中的配置信息，常见于依赖关系的继承。
• 作用：
  • 简化配置
  • 减少版本冲突

接下来，我们到程序中去看看继承该如何实现?

步骤1:创建一个空的Maven项目并将其打包方式设置为pom

因为这一步和前面maven创建聚合工程的方式是一摸一样，所以我们可以单独创建一个新的工程，也可以直接和聚合公用一个工程。实际开发中，聚合和继承一般也都放在同一个项目中，但是这两个的功能是不一样的。

步骤2:在子项目中设置其父工程

分别在maven_02_ssm,maven_03_pojo,maven_04_dao的pom.xml中添加其父项目为maven_01_parent

<!--配置当前工程继承自parent工程-->
<parent>
    <groupId>com.itheima</groupId>
    <artifactId>maven_01_parent</artifactId>
    <version>1.0-RELEASE</version>
    <!--设置父项目pom.xml位置路径-->
    <relativePath>../maven_01_parent/pom.xml</relativePath>
</parent>

步骤3:优化子项目共有依赖导入问题

1. 将子项目共同使用的jar包都抽取出来，维护在父项目的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>com.itheima</groupId>
    <artifactId>maven_01_parent</artifactId>
    <version>1.0-RELEASE</version>
    <packaging>pom</packaging>
    
    <!--设置管理的模块名称-->
    <modules>
        <module>../maven_02_ssm</module>
        <module>../maven_03_pojo</module>
        <module>../maven_04_dao</module>
    </modules>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.0</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.0</version>
        </dependency>
    </dependencies>
</project>

2. 删除子项目中已经被抽取到父项目的pom.xml中的jar包，如在maven_02_ssm的pom.xml中将已经出现在父项目的jar包删除掉

<?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.itheima</groupId>
  <artifactId>maven_02_ssm</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <!--配置当前工程继承自parent工程-->
  <parent>
    <groupId>com.itheima</groupId>
    <artifactId>maven_01_parent</artifactId>
    <version>1.0-RELEASE</version>
    <relativePath>../maven_01_parent/pom.xml</relativePath>
  </parent>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>

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

    <dependency>
      <groupId>com.itheima</groupId>
      <artifactId>maven_04_dao</artifactId>
      <version>1.0-SNAPSHOT</version>
      <!--排除依赖是隐藏当前资源对应的依赖关系-->
      <exclusions>
        <exclusion>
          <groupId>log4j</groupId>
          <artifactId>log4j</artifactId>
        </exclusion>
        <exclusion>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.1</version>
        <configuration>
          <port>80</port>
          <path>/</path>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

删除完后，你会发现父项目中有依赖对应的jar包，子项目虽然已经将重复的依赖删除掉了，但是刷新的时候，子项目中所需要的jar包依然存在。

当项目的<parent>标签被移除掉，会发现多出来的jar包依赖也会随之消失。

3. 将maven_04_dao项目的pom.xml中的所有依赖删除，然后添加上maven_01_parent的父项目坐标

<?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.itheima</groupId>
    <artifactId>maven_04_dao</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--配置当前工程继承自parent工程-->
    <parent>
        <groupId>com.itheima</groupId>
        <artifactId>maven_01_parent</artifactId>
        <version>1.0-RELEASE</version>
        <relativePath>../maven_01_parent/pom.xml</relativePath>
    </parent>
</project>

刷新并查看Maven的面板，会发现maven_04_dao同样引入了父项目中的所有依赖。

这样我们就可以解决刚才提到的第一个问题，将子项目中的公共jar包抽取到父工程中进行统一添加依赖，这样做的可以简化配置，并且当父工程中所依赖的jar包版本发生变化，所有子项目中对应的jar包版本也会跟着更新。

步骤4:优化子项目依赖版本问题

如果把所有用到的jar包都管理在父项目的pom.xml，看上去更简单些，但是这样就会导致有很多项目引入了过多自己不需要的jar包。如上面看到的这张图:

如果把所有的依赖都放在了父工程中进行统一维护，就会导致ssm_order项目中多引入了spring-test的jar包，如果这样的jar包过多的话，对于ssm_order来说也是一种"负担"。

那针对于这种部分项目有的jar包，我们该如何管理优化呢?

1. 在父工程mavne_01_parent的pom.xml来定义依赖管理

<!--定义依赖管理-->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

2. 将maven_02_ssm的pom.xml中的junit依赖删除掉，刷新Maven

刷新完会发现，在maven_02_ssm项目中的junit依赖并没有出现，所以我们得到一个结论:

<dependencyManagement>标签不真正引入jar包，而是配置可供子项目选择的jar包依赖

子项目要想使用它所提供的这些jar包，需要自己添加依赖，并且不需要指定<version>

3. 在maven_02_ssm的pom.xml添加junit的依赖

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

注意：这里就不需要添加版本了，这样做的好处就是当父工程dependencyManagement标签中的版本发生变化后，子项目中的依赖版本也会跟着发生变化

4. 在maven_04_dao的pom.xml添加junit的依赖

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

这个时候，maven_02_ssm和maven_04_dao这两个项目中的junit版本就会跟随着父项目中的标签dependencyManagement中junit的版本发生变化而变化。不需要junit的项目就不需要添加对应的依赖即可。

至此继承就已经学习完了，总结来说，继承可以帮助做两件事

• 将所有项目公共的jar包依赖提取到父工程的pom.xml中，子项目就可以不用重复编写，简化开发
• 将所有项目的jar包配置到父工程的dependencyManagement标签下，实现版本管理，方便维护
  • dependencyManagement标签不真正引入jar包，只是管理jar包的版本
  • 子项目在引入的时候，只需要指定groupId和artifactId，不需要加version
  • 当dependencyManagement标签中jar包版本发生变化，所有子项目中有用到该jar包的地方对应的版本会自动随之更新

最后总结一句话就是，父工程主要是用来快速配置依赖jar包和管理项目中所使用的资源。

小结

继承的实现步骤:

• 创建Maven模块，设置打包类型为pom

  <packaging>pom</packaging>
  

• 在父工程的pom文件中配置依赖关系(子工程将沿用父工程中的依赖关系),一般只抽取子项目中公有的jar包

  <dependencies>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-webmvc</artifactId>
          <version>5.2.10.RELEASE</version>
      </dependency>
      ...
  以上是关于02-Maven高级-分模块开发依赖传递聚合继承（SpringBoot的部分底层原理）多模块开发(环境切换)Nexus私服搭建与使用的主要内容，如果未能解决你的问题，请参考以下文章
   
   maven高级（黑马程序员 P15~P29）
   maven高级（黑马程序员 P15~P29）
   maven高级（黑马程序员 P15~P29）
   Maven高级：根据需求完成生成开发测试环境，并在各个环境间切换运行
   Maven高级：多环境配置与应用
   maven 之分模块构建web项目 及 聚合与继承特性