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

文章目录

• 学习目标
• 一、分模块开发与设计

• 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目录下

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



2. 再创建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

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

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

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

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

0. 创建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模块要用

0. 创建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

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

0. 创建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

可能有不合理之处，但好歹人家不报错了~

0. maven_controller 里粘贴入页面
   
1. 测试执行
   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的排除要注释掉，否则整个项目都没有这两个包了，项目无法正常执行了。
除非(高层如)controller里面再自己直接依赖这两个包

4 可选依赖和排除依赖的区别

三、聚合与继承

1. 聚合工程

问题导入

什么叫聚合？

• 聚合：将多个模块组织成一个整体，同时进行项目构建的过程称为聚合
• 聚合工程：通常是一个不具有业务功能的”空“工程（有且仅有一个pom文件）
• 作用：使用聚合工程可以将多个工程编组，通过对聚合工程进行构建，实现对所包含的模块进行同步构建

• 当工程中某个模块发生更新（变更）时，必须保障工程中与已更新模块关联的模块同步更新，此时可以使用聚合工程来解决批量模块同步构建的问题

之前，我们是这么做的

3个项目都依赖pojo,万一pojo变了（eg: 删掉一个属性），其他模块都会出问题。如果4个模块都已经打好包了，难道改了一个，其余4个都要重新打包吗？好麻烦啊。

这个时候想到可不可以来一个管理的工程，一旦发现某一处更新了，管理工程就要求4个同时构建更新

管理工程称为：聚合工程

只需对聚合工程进行构建，其他(被管理的)工程都会跟着构建

2. 聚合工程开发

问题导入

工程的打包方式有哪几种？

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

pom.xml里修改打包方式为：pom

<packaging>pom</packaging>

注意事项：

1. 每个maven工程都有对应的打包方式，默认为jar，web工程打包方式为war

2.2 设置当前聚合工程所包含的子模块名称

<!-- 设置管理的模块名称 -->
<modules>
  <!-- 后来会打包到一起 所以使用相对路径导入工程 -->
  <module>../maven_controller</module>
  <module>../maven_service</module>
  <module>../maven_dao</module>
  <module>../maven_pojo</module>
  <module>../maven_ssm</module>
</modules>

刷新maven

编译聚合工程，会发现，所有6个工程模块全都一起跟着构建了

而且构建顺序跟配置顺序无关，完全根据依赖关系合理设置构建顺序的

.

同样，一点install,所有的模块都打包到本地仓库了

)

（除controller要打war包外，parent要打pom包外，其他工程打包方式统统改成jar 或者不写默认jar， 因为要在本地仓库以jar的形式作为依赖而存在）
(前面service的pom里面除去了两个要用的包，把排除依赖注释掉，或者自己在controller的pom.xml里再直接依赖这两个包，就OK啦)

然后启动controller，浏览器还能访问，完美~
.
一点parent(root)项目的clean，在IDEA中全部项目的target都删除了

注意事项：

1. 聚合工程中所包含的模块在进行构建时会根据模块间的依赖关系设置构建顺序，与聚合工程中模块的配置书写位置无关。
2. 参与聚合的工程无法向上感知是否参与聚合，只能向下配置哪些模块参与本工程的聚合。

至此，再没有继承的情况下（完全靠依赖传递+聚合），跑通了web工程，备份一下项目，保留其复杂性，下面对比才能项目继承的好处太大了
链接：https://pan.baidu.com/s/1d1Hwi3xnF0lc0_Yx8vwcBA 提取码：5jsd
IntelliJ IDEA 2022.3.2 (Ultimate Edition)

3. 继承关系

问题导入

什么叫继承？

• 概念：

• 继承描述的是两个工程间的关系，与java中的继承相似，子工程可以继承父工程中的配置信息，常见于依赖关系的继承

• 作用：

• 简化配置
• 减少版本冲突

终于到包的管理了，如何合理地写依赖关系？继承是最好的方式，大家都要用到的依赖统一写在父工程里，都直接继承自父工程，就不要一级一级依赖传递了，万一断链了咋办
.
不是传递依赖，而是直接继承到依赖，除了父工程不依赖其他工程了（继承的包似乎是直接依赖）

4. 继承关系开发

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

直接用上面的maven_parent模块做为父工程，聚合和继承通常都是做在一起的

<packaging>pom</packaging>

注意事项：

1. 建议父工程打包方式设置为pom

然后其他所有子工程的pom里全部加上下面的配置：继承自父工程：

<!-- 配置当前工程继承自parent工程 -->
<parent>
  <groupId>cn.whu</groupId>
  <artifactId>maven_parent</artifactId>
  <version>1.0-SNAPSHOT</version>
  <!-- 配置相对路径，可以使得子工程快速找到父工程  (不写也行)-->
  <relativePath>../maven_parent/pom.xml</relativePath>
</parent>

父工程导的包（包括依赖传递的包），子工程全部继承到了
因此所有的包都可以写在父工程了
公共的包直接写<dependencies> 直接依赖，子工程继承后也是直接依赖 详见4.2
非所有项目公共的包写<dependencyManagement>配置成可选依赖，子工程选择性地继承 详见4.3

4.2 在父工程的pom文件中配置依赖关系（子工程将沿用父工程中的依赖关系）

接下来把maven_ssm的pom.xml中的依赖坐标全部剪切到父工程中去，公共的都在这里

maven_parent目前pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>cn.whu</groupId>
  <artifactId>maven_parent</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>pom</packaging>

  <!-- 设置管理的模块名称 -->
  <modules>
    <!-- 后来会打包到一起 所以使用相对路径导入工程 -->
    <module>../maven_controller</module>
    <module>../maven_service</module>
    <module>../maven_dao</module>
    <module>../maven_pojo</module>
    <module>../maven_ssm</module>
  </modules>

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

    <!--... 中间省略 重要的不是项目本身-->

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

继承的和直接依赖的，一模一样

版本管理：父工程parent中修改一次版本，所有子工程中的版本就都跟着改了。一改全改，好方便

4.3 配置子工程中可选的依赖关系

不公共的也可以写在父工程里，但是得用 <dependencyManagement>配置成可选依赖
然后子工程需要的话，在里面写GA即可导入这些可选依赖（不需要写版本，父工程统一管理版本）

• 父工程maven_parent的pom.xml 配置可选依赖

<!-- 定义可选依赖 或者说 依赖管理 -->
 <dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>4.13</version>
       <scope>test</scope>
     </dependency>
     <!-- 只有POJO需要 可以移到这里来 -->
     <dependency>
       <groupId>org.projectlombok</groupId>
       <artifactId>lombok</artifactId>
       <version>1.18.26</version>
     </dependency>
     <!-- 可以写其他一系列可选依赖 -->
   </dependencies>
 </dependencyManagement>

junit只有service或者dao可能需要，配置成可选依赖
lombok只有pojo需要，配置成可选依赖
然后service里勾选junit可选依赖，pojo里勾选lombok可选依赖

• 子工程引入父工程的可选依赖

pojo的pom.xml 引入父工程的可选依赖

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

service的pom.xml 引入父工程的可选依赖

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

不用写烦人的版本了，多好啊

注意事项：

1. 子工程中使用父工程中的可选依赖时，仅需要提供群组id和项目id，无需提供版本，版本由父工程统一提供，避免版本冲突
2. 子工程中还可以定义父工程中没有定义的依赖关系（当然也可以导入父工程没有的依赖啦）

5. 聚合与继承的区别

问题导入

聚合和继承的作用？

• 作用

• 聚合用于快速构建项目
• 继承用于快速配置

• 相同点：

• 聚合与继承的pom.xml文件打包方式均为pom，可以将两种关系制作到同一个pom文件中
• 聚合与继承均属于设计型模块，并无实际的模块内容

• 不同点：

• 聚合是在当前模块中配置关系，聚合可以感知到参与聚合的模块有哪些 （父维护子）
• 继承是在子模块中配置关系，父模块无法感知哪些子模块继承了自己 (子维护父)

四、属性管理

1. 属性

问题导入

定义属性有什么好处？

看看这些spring下各类包的版本号，都一样，都是spring版本号，一个个都重复写，且都写死了，万一换个spring版本，一个个重复地改，多麻烦啊，万一有的改了，有的没改，那问题就大了。

能不能将版本号定义成变量，然后变量值维护为spring版本号呢？这样不就能一改全改了吗？

1.1 属性配置与使用

xml里的属性 简单理解为 java里的变量

①：定义属性

<!--定义属性-->
<properties>
  <!--spring.version是属性名，随便自己定义-->
  <spring.version>5.1.11.RELEASE</spring.version>
  <junit.version>4.12</junit.version>
</properties>

②：引用属性

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>${spring.version}</version>
</dependency>

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-jdbc</artifactId>
  <version>${spring.version}</version>
</dependency>

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-test</artifactId>
  <version>${spring.version}</version>
</dependency>


<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>${junit.version}</version>
  <scope>test</scope>
</dependency>

1.2 资源文件引用属性 （resources下的资源文件如何引用pom.xml里的属性值）

resources里也有配置（资源文件），如jdbc.properties

这些值也是写死的，虽然没必要，但是其实这些值也是可以放到pom.xml中维护的，然后资源文件以属性(变量)形式引用一下即可。

在maven_parent的pom.xml里面定义属性
属性文件在maven_controller的resources/jdbc.properties下，就在这里面写。看看效果

①：定义属性

maven_parent的pom.xml 父工程里定义一份，所有子工程的pom.xml里就都有了

<!--自定义属性 属性名随便写-->
  <properties>
    <!--spring.version是属性名，随便自己定义-->
    <spring.version>5.1.11.RELEASE</spring.version>
    <junit.version>4.12</junit.version>
    <!--上面两行不用看 上面的需求遗留下来的-->

    <jdbc.driver>com.mysql.jdbc.Driver</jdbc.driver>
    <jdbc.url>jdbc:mysql://localhost:3306/ssm_db?useSSL=false</jdbc.url>
    <jdbc.username>root</jdbc.username>
    <jdbc.password>1234</jdbc.password>
  </properties>

在maven_controller的pom.xml里随便哪里使用el表达式，看看有没有这些变量

果然，父工程pom里的配置被继承下来了

②：配置文件中引用属性

maven_controller的resources/jdbc.properties下

jdbc.driver=${jdbc.driver}
jdbc.url=${jdbc.url}
jdbc.username=${jdbc.username}
jdbc.password=${jdbc.password}

③：开启资源文件目录加载属性的过滤器

pom.xml中定义的属性，只能默认只能在pom.xml中使用，想要在其他文件中也能使用，得配置一下拓展范围路径
.
父工程里这么配置扫描路径: ${project.basedir}/src/main/resources 子工程继承这行配置，于是所有工程的resources目录都会被扫描到了，不管jdbc.properties等资源文件在哪个工程下，都没问题了

<!-- 父工程里配置一份 相当与给所有子工程都配置上了 -->
<build>
  <!--  pom.xml中定义的属性，只能默认只能在pom.xml中使用，想要在其他文件中也能使用，得配置一下拓展范围 -->
  <resources>
    <resource>
      <!-- 扫描这个目录下的文件，解析里面的${el表达式} -->
      <!-- ${project.basedir}指的是当前项目根目录名，所有子项目都会继承这个配置，自然就给所有子项目的resources目录都扫描到了 -->
      <directory>${project.basedir}/src/main/resources</directory>
      <filtering>true</filtering>
    </resource>
  </resources>
</build>

maven_parent下重新install,然后启动maven_controller服务器，再浏览器访问，能正常访问页面和功能，就OK啦~

或者打包maven_controller，然后解压maven_ssm-1.0-SNAPSHOT.jar，看看值有没有被解析出来

注意: 配置maven打war包时，忽略web.xml检查

问题引入：

删掉maven_controller工程WEB-INF下面的web.xml，再对其进行package或者install打包，会报错

注解开发本来就不想要web.xml怎么办？

问题解决： 配置maven打war包时，忽略web.xml检查 在父工程的pom里配置 这样相当于给所有子项目的pom都加了这个配置(简化配置，这么来的，深刻体会到了)

<build>
<!-- ....其他配置省略.... -->
<plugins>
  <plugin>
    <!-- maven自带的打war的插件 -->
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-war-plugin</artifactId>
    <version>3.2.3</version>
    <!-- 告诉该插件忽略web.xml检查 -->
    <configuration>
      <failOnMissingWebXml>false</failOnMissingWebXml>
    </configuration>
  </plugin>
</plugins>
</build>

再去install，不会报错啦

1.3 其他属性（了解）

上面用到了${project.basedir} 可以直接动态得到当前项目根目录名
怎么做到？maven的内置属性呗

• 属性列表

• 自定义属性（常用）
• 内置属性
• Setting属性 (读maven安装目录下的conf/settings.xml里的属性)
• Java系统属性
• 环境变量属性

了解即可，都是做框架的人 才需要用到的知识

2. 版本管理

问题导入

项目开发的版本可以分为哪几种？

2.1 工程版本

• SNAPSHOT（快照版本）

• 项目开发过程中临时输出的版本，称为快照版本
• 快照版本会随着开发的进展不断更新

• RELEASE（发布版本）

• 项目开发到进入阶段里程碑后，向团队外部发布较为稳定的版本，这种版本所对应的构件文件是稳定的
• 即便进行功能的后续开发，也不会改变当前发布版本内容，这种版本称为发布版本

https://mvnrepository.com/

2.2 发布版本

• alpha版
• beta版
• 纯数字版

五、多环境配置与应用

1. 多环境配置作用

问题导入

多环境配置有什么好处？

• maven提供配置多种环境的设定，帮助开发者使用过程中快速切换环境

2. 多环境配置步骤

2.1 定义多环境

父工程 maven_parent 的pom.xml里写定义

<!-- 配置多环境 -->
<profiles>
  <!--一个profile就是一个环境-->
  
  <!--开发环境-->
  <profile>
    <id>env_dep</id>
    <properties>
      <!--这里面挨个写这个环境的属性即可-->
      <jdbc.url>jdbc:mysql://127.1.1.1:3306/ssm_db?useSSL=false</jdbc.url>
      <jdbc.password>1234</jdbc.password>
    </properties>
    <!-- 设定是否为默认启动环境 -->
    <activation>
      <activeByDefault>true</activeByDefault>
    </activation>
  </profile>
  
  <!--生产环境-->
  <profile>
    <id>env_pro</id>
    <properties>
      <jdbc.url>jdbc:mysql://127.2.2.2:3306/ssm_db?useSSL=false</jdbc.url>
      <jdbc.password>1234</jdbc.password>
    </properties>
  </profile>
  
  <!--测试环境-->
  <profile>
    <id>env_test</id>
    <properties>
      <jdbc.url>jdbc:mysql://127.3.3.3:3306/ssm_db?useSSL=false</jdbc.url>
      <jdbc.password>1234</jdbc.password>
    </properties>
  </profile>

</profiles>

子工程会继承这些配置，maven_ssm的resources的jdbc.properties里面正好就是动态配置的属性

jdbc.driver=${jdbc.driver}
jdbc.url=${jdbc.url}
jdbc.username=${jdbc.username}
jdbc.password=${jdbc.password}

重新maven_parent下install所有工程，然后看maven_ssm-1.0-SNAPSHOT.jar解压后的jdbc.properties

果然变成激活环境里的属性了（可以切换激活环境，发现确实是动态变化的）

后面SpringBoot封装得更好，这里知道一点原理即可

2.2 使用多环境（构建过程）

【命令】：
mvn 指令 –P 环境定义id

【范例】：
mvn install –P pro_env

使用install指令时添加临时参数，可以指定按哪个环境(打包)安装项目

解压maven_ssm-1.0-SNAPSHOT.jar后，查看 jdbc.properties

2. 跳过测试（了解）

问题导入

跳过测试会不会影响项目的构建过程？

直接使用install等需要打包的指令时，会先帮你测试，测试通过才会继续打包，否则报错直接不打包
确实有想跳过测试直接打包的场景，该如何做呢？

2.1 应用场景

• 功能更新中并且没有开发完毕
• 快速打包
• ……

2.2 跳过测试命令

• mvn install –D skipTests

注意事项：

1. 执行的项目构建的指令必须包含测试生命周期，否则无效果。例如执行compile生命周期，不经过test生命周期，也就是-D参数不是所有的指令都有的

直接点击也可跳过测试：

再点install，打包时就会跳过测试了。

2.3 细粒度控制跳过测试

上面点击一下，会使得所有项目打包都跳过测试，如何设定跳过某些(我们确实知道有问题，但是无关紧要)测试呢

父工程maven_parent的pom.xml下配置

<build>
<plugins>
<plugin>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.22.1</version>
    <configuration>
    	<!--这是写true就是跳过所有测试-->
        <skipTests>false</skipTests>
        <!--设置跳过测试-->
        <includes>
            <!--包含指定的测试用例  ‘**/’指任意目录下的-->
            <include>**/User*Test.java</include>
        </includes>
        <excludes>
            <!--排除指定的测试用例-->
            <exclude>**/User*TestCase.java</exclude>
        </excludes>
    </configuration>
</plugin>
</plugins>
</build>

<include>**/User*Test.java</include> ：任意目录下的User*Test.java文件

六、私服

1. 私服介绍

问题导入

这里的私服和平时我们听的国服、体验服、欧服等等有什么区别？

我们公司内部自己开发了一些模块，怎么交流？打包好U盘分享？大项目这么做肯定不行。放到中央仓库？红发才有的面子。只能自己公司内部搭建一个私服了，都把打好的jar包放到私服的仓库里，引用兄弟团队的jar，直接到私服仓库里下载。

1.1 介绍

• 团队开发现状分析
• 私服是一台独立的服务器，用于解决团队内部的资源共享与资源同步问题
• Nexus

• Sonatype公司的一款maven私服产品
• 下载地址：https://help.sonatype.com/repomanager3/download

下拉，下载windows版本即可：

下载好的在这：

链接：

https://pan.baidu.com/s/1tE8YPzMS5t_YJl43Ffoc4g

提取码：j1o6

1.2 Nexus安装与启动

和tomcat一样，解压即安装
解压后进入nexus-3.30.1-01/bin目录下，以命令行形式启动，因为要指定参数

• 启动服务器（命令行启动）

• nexus.exe /run nexus

• 访问服务器（默认端口：8081）

• http://localhost:8081

• 修改基础配置信息

• 安装路径下etc目录中nexus-default.properties文件保存有nexus基础配置信息，例如默认访问端口。

• 修改服务器运行配置信息

• 安装路径下bin目录中nexus.vmoptions文件保存有nexus服务器启动对应的配置信息，例如默认占用内存空间。

演示：

先进入nexus-3.30.1-01/bin目录下，打开命令行，输入指令: nexus.exe /run nexus

稍等片刻，启动成功：

再到浏览器端访问nexus服务器 http://localhost:8081/ 人家的默认端口就是8081，和tomcat紧挨着，但是区分开了

默认用户名: admin

默认密码：指定文件下查

设置新密码

这里选择允许匿名访问

修改配置： 如修改默认端口

sonatype-work/nexus3/etc/nexus.properties 文件里可以改默认端口等配置

建议保持默认，不要改了~

1.3 私服资源操作流程分析

所有的资源都直接找仓库组下，仓库组先帮你找到对应的仓库，然后去仓库里找包，找到直接给，找不到私服就去中央仓库下载，或者第三方地址去下载。总之：有了私服，不管什么包，我们就直接找私服就够了，剩下的操作私服帮你完成。

2. 私服仓库分类

问题导入

私服仓库分为哪几种？

宿主仓库的第三方资源指的是中央库中也没有的第三方资源。（eg: Oracel数据库连接包，非开源，中央仓库没有，得去Oracle官网下载）

仓库组里面有一个代理仓库和若干个宿主仓库

3. 资源上传与下载

问题导入

往私服上传资源是否需要身份认证？在哪里设置认证信息？

3.0 私服中创建仓库

华东到最下方点击创建仓库

同样的操作再创建一个whu-release

一共创建了2个仓库

仓库id就是whu-release、whu-snapshot

3.1 从私服中下载依赖

【第一步】在maven的settings.xml中<mirrors>标签中配置，此时就需要注释掉aliyun的配置。

本地仓库不去中央仓库(或者阿里云搭建的中央仓库)下载了，而是到我们的私服去下载(中间又多了一个中转)

<!-- id:仓库组id
	mirrorOf: *  表示仓库组下所有的仓库
	url： 仓库组URL (浏览器进入仓库组就能看到了)		
-->
<mirror>
  <id>maven-public</id>
  <mirrorOf>*</mirrorOf>
  <url>http://localhost:8081/repository/maven-public/</url>
</mirror>

如何查找仓库组id?

…

…

仓库组URL查询:

【第二步】在nexus中设置允许匿名下载，如果不允许将不会从私服中下载依赖

如果私服中没有对应的jar，会去中央仓库下载，速度很慢。可以配置让私服去阿里云中下载依赖。

3.2 上传依赖到私服中

【第一步】配置本地仓库访问私服的权限（在maven的conf/settings.xml的servers标签中配置）

<!-- 配置访问私服的权限 创建的两个私服都要配置--> 
<server>
  <!--id任意，多个server的id不重复就行-->
  <id>heima-nexus</id>
  <username>admin</username>
  <password>admin</password><!--填写自己nexus设定的登录秘密-->
</server>

<server>
	<id>whu-snapshot</id>
 	<username>admin</username>
  	<password>admin</password>
</server>

【第二步】配置当前项目访问私服上传资源的保存位置（(父)项目的pom.xml文件中配置）

<0distributionManagement>  
    <repository>
      	<!--和maven/settings.xml中server中的id一致，表示使用该id对应的用户名和密码-->
        <id>whu-release</id>
      	<!--如果jar的版本是release版本，那么就上传到这个仓库，根据自己情况修改-->
        <url>http://localhost:8081/repository/whu-release/</url>
    </repository>
    <snapshotRepository>
      	<!--和maven/settings.xml中server中的id一致，表示使用该id对应的用户名和密码-->
        <id>whu-snapshot</id>
      	<!--如果jar的版本是snapshot版本，那么就上传到这个仓库，根据自己情况修改-->
        <url>http://localhost:8081/repository/whu-snapshot/</url>
    </snapshotRepository>
</distributionManagement>

现在pom.xml里有仓库地址，conf/settings.xml里有权限(用户名密码) [二者完全可以通过id联系上]

id和url直接进入仓库就可以看到

注意：要和maven的settings.xml中server中定义的<id>whu-release</id>和<id>whu-snapshot</id>对应

【第三步】发布资源到私服命令

mvn deploy

先到仓库里看看有什么：

初始当然啥都没有啦

然后刷新maven，再点击deploy （install是安装到本地仓库，deploy是发布到私服仓库）

不管点击哪一个，都会很漫长，因为私服仓库啥也没有，第一次就这么大的项目，一定会去下载大量jar包的
(实验室网快，点击deploy也才7s就下载好了)

这个时候再去whu-snapshot仓库看，就有我们发布的东西了

将所有工程的版本号改成RELEASE，<version>1.0-RELEASE</version>，再deploy这时去看whu-release也有东西了

同样，中央仓库里也会下载一些东西，公共包：

4. 个人开发私服不会一直开着，改回阿里云服务器

现在Nexus私服服务器你不可能一直开着，本地仓库没有就会到私服仓库下载，私服一关闭，没人帮你下载，maven就死了。所以不用私服时将私服配置注释了，打开阿里云的配置吧。
(或者将私服仓库管理仓库全部去点，瞎配置一个不存在的，或者直接注释掉私服务器<mirror>配置这样也会去maven中央仓库下载)

maven安装目录下，conf/settings改成这样，还是用阿里云：