(一)、Maven 简介

1.传统项目管理的缺点

1. jar 包不统一，jar 包不兼容;
2. 工程升级维护过程操作繁琐;

2.Maven是什么

Maven 的本质是一个项目管理工具，将项目开发和管理过程抽象成一个项目对象模型 (POM)

POM (Project Object Model) : 项目对象模型

3.Maven的作用

• 项目构建：提供标准的跨平台的自动化项目构建方式;
• 依赖管理：方便快捷地管理项目依赖的资源 (jar 包)， 避免资源间的版本冲突问题。
• 统一开发结构: 提供标准的、统一的项目结构

(二)、Maven 的下载与安装

1.下载与认识目录

https://maven.apache.org/download.cgi

• bin 目录：核心运行文件;
• boot 目录: 类加载器;
• conf 目录：核心配置;
• lib 目录：所依赖的 jar 包;
  

2.配置Maven的全局环境

1.配置高级环境

2.输入cmd 测试是否全局配置成功!!!

(三)、Maven 的基础概念

1.Maven 仓库

用于存储资源，包含各种 jar 包。

中央仓库由Maven开发者团队进行维护，私服服务器由各个公司的局域网进行管理。 正常开发者需要一个Jar现在本地找，假如本地找不到要门去私服下载对应的Jar包，要么去Maven官方管理的Maven中央仓库去下载。

(1).仓库分类

1. 本地仓库：自己电脑上存储资源的仓库，连接远程仓库获取资源；
2. 远程仓库：非本机电脑上的仓库，为本地仓库提供资源
   ① 中央仓库：Maven 团队维护，存储所有资源的仓库;
   ② 私服：部门/公司范围内存储资源的仓库，从中央仓库获取资源；

私服的作用：

① 保存具有版权的资源，包含购买或自主研发的 jar;
② 解决访问速度慢的问题；

2. Maven 坐标

描述仓库中资源的位置。 让Maven能够更快捷的帮助我们找到对应的Jar包。

组成:

groupId (组织ID): 定义当前 Maven 项目隶属的组织名称（通常是域名反写，如 org.mybatis) ;
artifactId (项目名ID): 定义当前 Maven 项目名称（通常是模块名称，例如 CRM, SMS)
version (项目版本号): 定义当前项目版本号;
packaging: 定义当前项目的版本号;

3.Maven 本地仓库配置

我们安装Maven的时候，官方不会给我们默认指定一个Maven的仓库的，需要我们开发者自己来对其进行配置和安装。

我们在命令控制台中输入 CMD 然后回车 ，再输入mvn，Maven官方会再电脑用户给我们生成一个 .m2的文件夹。这个文件夹就是我们所说的Maven本地仓库

(1).改变默认的仓库地址

在下面位置放置我们自定义的 Maven本地仓库地址

  <localRepository>E:\Maven\apache-maven-3.6.3\maven-repo</localRepository>

(2).改变远程仓库地址 (配置镜像)

因为我们没有私服，只能借用阿里云的镜像进行快速访问外网Maven中央仓库

    <mirror>
    <!-- 此镜像的唯一标识符，用来区分不同 mirror 元素 -->
      <id>nexus-aliyun</id>
      <!-- 对哪个仓库进行镜像，简单来说就是要替换哪个仓库 -->
      <mirrorOf>*</mirrorOf>
      <!-- 镜像名称 -->
      <name>Nexus aliyun</name>
      <!-- 镜像 URL -->
      <url>http://maven.aliyun.com/nexus/content/groups/public</url>
    </mirror>
  </mirrors

(四)、第一个Maven项目 (纯手写)

1.编写基本框架代码

我们需要手动编写: main包和test包在src父包中，然后分别在main和test的子包中写java包和resources包。

package main.java.com.jsxs;

/**
 * @Author Jsxs
 * @Date 2023/8/1 16:09
 * @PackageName:main.java
 * @ClassName: Demo1
 * @Description: TODO
 * @Version 1.0
 */
public class Demo1 {
    public static void main(String[] args) {
        System.out.println("你好 Maven!");
    }
}

2.填充Pom.xml至项目中

如果我们普通的Java目录想要变成一个Maven项目，那么我们需要在Src同级目录下编写一个文件 pom.xml。

<?xml version="1.0" encoding="UTF-8"?>
<!-- Maven根元素 这里面具有三个配置-->
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <!--  当前Maven的Pom对象版本  -->
    <modelVersion>4.0.0</modelVersion>
    <!--打包方式，web 工程打包为 war, java 工程打包为 jar-->
  	<packaging>war</packaging>
    <!--    归属ID-->
    <groupId>com.jsxs</groupId>
    <!--    项目名ID-->
    <artifactId>Maven_handle</artifactId>
    <!--    项目版本号 SNAPSHOT代表开发版 ，RELEASE代表完成版-->
    <version>0.0.1-SNAPSHOT</version>
    <!--    项目名称-->
    <name>Maven_handle</name>
    <!--    项目描述-->
    <description>Demo project for Maven_handle</description>

    <!--    依赖管理-->
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
        </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>

3.Maven 项目构建命令

Maven 构建命令使用 mvn 开头，后面添加功能参数，可以一次执行多个命令，使用空格分隔。

其实这里分别对应着我们SpringBoot项目中的右侧功能栏目。

mvn compile #编译
mvn clean #清理
mvn test #测试 target 目录下 surefire-reports 有测试报告
mvn package #打包 只打包源程序
mvn install #安装到本地仓库

1. 执行编译命令之后

2. 执行清理的操作

3. 执行测试

我们在target目录中可以看到我们的测试结果，都会被记录下来的

4. 执行 打包

5. 将我们的项目安装到本地仓库

4.使用插件创建Maven项目

(注意要用 命令行，不要用 powershell)

1. 创建Java工程

mvn archetype:generate
-DgroupId={project-packaging}
-DartifactId={project-name}
-DarchetypeArtifactId=maven-archetype-quickstart
-DinteractiveMode=false

2. 创建 web 工程：

mvn archetype:generate -DgroupId={project-packaging}
-DartifactId={project-name}
-DarchetypeArtifactId=maven-archetype-webapp 
-Dversion=0.0.1-snapshot 
-DinteractiveMode=false

(五)、第一个Maven项目 (IDea)

1.配置 Maven

2.创建Maven项目

3.设置插件

打包web项目打包成war; java工程打包成jar。

    <!--  构建  -->
    <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>

(六)、依赖管理

1.依赖配置

依赖指当前项目运行所需要的 jar, 一个项目可以设置多个依赖。

<!-- 设置当前项目所需要的所有 jar-->
<dependencies>
	<!-- 设置具体的依赖 -->
	<dependency>
		<!-- 依赖所属群组 id-->
		<groupId>junit</groupId>
		<!-- 依赖所属项目 id-->
		<artifactId>junit</artifactId>
		<!-- 依赖版本号 -->
		<version>4.12</version>
	</dependency>
</dependencies>

2.依赖传递

就是说假如B项目使用了A项目本身的依赖，那么B项目将会拥有A项目所有的依赖，然而A项目是不变的。

依赖具有传递性：

• 直接依赖：在当前项目中通过依赖配置建立的依赖关系；
• 间接依赖：被依赖资源如果依赖其他资源，当前项目间接依赖其他资源;

依赖传递的冲突问题:

• 路径优先：当依赖中出现相同的资源时，层级越浅，优先级越高，层级越深，优先级越低;
• 声明优先：当资源在相同层级被依赖时，配置顺序靠前的覆盖配置顺序靠后的;
• 特殊优先：当同级配置了相同资源的不同版本，后配置的覆盖先配置的;

3.可选依赖 (被动断)

可选依赖指对外隐藏当前所依赖的资源 - 不透明

当我们配置完这一项之后，假如别人引入我们的项目依赖，那么不会存在延申的依赖的。比如说我们在项目A中引入项目B，项目B的pom.xml的文件中在junit这个依赖，然后加入optional之后，我们就在项目A中看不到B中的Junit这个依赖。

<optional>true</optional>

<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>4.12</version>
	<optional>true</optional>
</dependency>

4.排除依赖 (主动断)

• 排除依赖指主动断开依赖的资源，被排除的资源无需指定版本 - 不需要

项目3中不添加 optional，我们这里在项目2中直接进行排除的操作。

 <!-- 具体依赖-->
<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>4.12</version>
	<!-- 排除集合 -->
	<exclusions>
		<!-- 排除某一个具体的 -->
		<exclusion>
			<!-- 三件套 ： 版本号就不用写了，因为一排除，就是排除所有版本-->
			<groupId>org.hamcrest</groupId>
			<artifactId>hamcrest-core</artifactId>
		</exclusion>
	</exclusions>
</dependency>

我们也发现没存在 junit衍生的版本。

5.依赖范围

• 依赖的 jar 默认情况可以在任何地方使用，可以通过 scope 标签设定其作用范围
• 作用范围
  • 主程序范围内有效 (main 文件夹范围内）
  • 测试程序范围内有效（test 文件夹范围内）
  • 是否参与打包（package 指令范围内）

6.依赖范围传递性

带有依赖范围的资源在进行传递时，作用范围会受到影响：

(七)、生命周期与插件

1.生命周期

Maven 构建生命周期描述的是一次构建过程中经历了多少个事件:

(1).Maven生命周期三阶段

• clean: 清理工作
• default: 核心工作，例如编译、测试、打包、部署等
• site: 产生报告，发布站点等

(2).Clean 生命周期

• pre-clean 执行一些需要在clean之前完成的工作
• clean 移除所有上一次构建生成的文件
• post-clean 执行一些需要在clean之后立刻完成的工作

(3).Default 生命周期

• validate（校验） 校验项目是否正确并且所有必要的信息可以完成项目的构建过程。
• initialize（初始化） 初始化构建状态，比如设置属性值。
• generate-sources（生成源代码） 生成包含在编译阶段中的任何源代码。
• process-sources（处理源代码） 处理源代码，比如说，过滤任意值。
• generate-resources（生成资源文件） 生成将会包含在项目包中的资源文件。
• process-resources （处理资源文件） 复制和处理资源到目标目录，为打包阶段最好准备。
• compile（编译） 编译项目的源代码。
• process-classes（处理类文件） 处理编译生成的文件，比如说对Java class文件做字节码改善优化。
• generate-test-sources（生成测试源代码） 生成包含在编译阶段中的任何测试源代码。
• process-test-sources（处理测试源代码） 处理测试源代码，比如说，过滤任意值。
• generate-test-resources（生成测试资源文件） 为测试创建资源文件。
• process-test-resources（处理测试资源文件） 复制和处理测试资源到目标目录。
• test-compile（编译测试源码） 编译测试源代码到测试目标目录.
• process-test-classes（处理测试类文件） 处理测试源码编译生成的文件。
• test（测试） 使用合适的单元测试框架运行测试（Juint是其中之一）。
• prepare-package（准备打包） 在实际打包之前，执行任何的必要的操作为打包做准备。
• package（打包） 将编译后的代码打包成可分发格式的文件，比如JAR、 WAR或者EAR文件。
• pre-integration-test（集成测试前） 在执行集成测试前进行必要的动作。比如说，搭建需要的环境。
• integration-test（集成测试） 处理和部署项目到可以运行集成测试环境中。
• post-integration-test（集成测试后） 在执行集成测试完成后进行必要的动作。比如说，清理集成测试环境。
• verify （验证） 运行任意的检查来验证项目包有效且达到质量标准。
• install（安装） 安装项目包到本地仓库，这样项目包可以用作其他本地项目的依赖。
• deploy（部署） 将最终的项目包复制到远程仓库中与其他开发者和项目共享。
  

(4).Site生命周期

• pre-site 执行一些需要在生成站点文档之前完成的工作
• site 生成项目的站点文档
• post-site 执行一些需要在生成站点文档之后完成的工作，并且为部署做准备
• site-deploy 将生成的站点文档部署到特定的服务器上

2.插件

(1).插件的定义

• 插件与生命周期内的阶段绑定，在执行到对应生命周期时执行对应的插件功能
• 默认 maven 在各个生命周期上绑定有预设的功能
• 通过插件可以自定义其他功能

(2).插件的用列

eg: 我们自定义在test测试的时候，进行打包的操作。

    <build>
        <!--设置插件-->
        <plugins>
            <!--       打包插件     -->
            <plugin>
                <!--        三件套        -->
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-source-plugin</artifactId>
                <version>2.2.1</version>
                <!--       执行集合         -->
                <executions>
                    <!--          具体执行          -->
                    <execution>
                        <!--            执行目标            -->
                        <goals>
                            <!--              具体执行目标      -->
                            <goal>jar</goal>
                        </goals>
                        <phase>generate-test-resources</phase>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

当我们点击生命周期的test的时候，我们发现帮助我们打成了一个jar包

---

(八)、分模块开发与设计

在实际开发中，dao、service、controller是不可能全部同时有一个人做的，也就是说我们的dao、service、contollrt是需要进行分包的操作的。

1.拆分springMvc_ssm项目

(1).ssm_pojo 拆分

• 新建模块
• 拷贝原始项目中对应的相关内容到 ssm_pojo 中
  • 实体类 User
  • 配置文件无

(2).ssm_dao 拆分

• 新建模块
• 拷贝原始项目中对应的相关内容到 ssm_dao 中
  • 数据层接口 UserDao
  • 配置文件: 保留与数据层相关配置文件（3 个）
    • 注意：分页插件在配置中与 SqlSessionFactoryBean 绑定，需要保留
  • pom.xml: 引入数据层相关坐标即可，删除 springmvc 相关坐标
    • spring
    • mybatis
    • spring 整合 mybatis
    • mysql
    • druid
    • pagehelper
    • 直接依赖 ssm_pojo (对 ssm_pojo 模块执行 install 指令，将其安装到本地仓库）
      ssm_service 拆分

注意: 我们发现问题,我们发现我们的dao层项目中需要使用到实体类，但是我们的dao项目中没有放实体的项目，所以我们需要对原先的 ssm_pojo进行安装到本地的仓库，然后我们在ssm_dao层使用三件套引用即可。

(3).ssm_service 拆分

• 新建模块
• 拷贝原始项目中对应的相关内容到 ssm_service 模块中
  • 业务层接口与实现类 (UserService、UserServiceImpl)
  • 配置文件：保留与数据层相关配置文件（1个）
  • pom.xml: 引入数据库相关坐标即可，删除 springmvc 相关坐标
    • spring
    • junit
    • spring 整合 junit
    • 直接依赖 ssm_dao （对 ssm_dao 模块执行 install 指令， 将其安装到本地仓库）
    • 间接依赖 ssm_pojo（由 ssm_dao 模块负责依赖关系的建立）
  • 修改 service 模块 spring 核心配置文件名，添加模块名称, 格式：applicationContext-service.xml
  • 修改 dao 模块 spring 核心配置文件名，添加模块名称，格式：applicationContext-dao.xml
  • 修改单元测试引入的配置文件名称，由单个文件修改为多个文件

注意: 因为我们的service层是需要我们的ssm_dao层的接口和实现类的，所以我们需要在ssm_dao 进行 install的操作，又因为我们ssm_dao install ssm_pojo， 所以直接依赖ssm_dao,间接依赖ssm_pojo。

(4).ssm_controller 拆分

• 新建模板（使用 webapp 模板)
• 拷贝原始项目中对应的相关内容到 ssm_controller 模块中
  • 表现层控制器类与相关设置类（UserController，异常相关)
  • 配置文件：保留与表现层相关配置文件（1个）、服务器相关配置文件（1个）
  • pom.xml：引入数据层相关坐标即可，删除 springmvc 相关坐标
    • spring
    • springmvc
    • jackson
    • servlet
    • tomcat 服务器插件
    • 直接依赖 ssm_service（对 ssm_service 模块执行 install 指令，将其安装到本地仓库）
    • 间接依赖 ssm_dao、ssm_pojo
  • 修改 web.xml 配置文件中加载 spring 环境的配置文件名称，使用 * 通配，加载所有 applicationContext- 开始的配置文件
    

运行的话，我们只需要运行Controller即可。因为我们其他的资源都放在本地仓库了，所以不需要进行启动其他的业务即可。

(5).分模块开发小结

• 模块仅包含当前模块对应的功能类与配置文件
• spring 核心配置根据模块功能不同进行独立制作
• 当前模块所依赖的模块通过导入坐标的形式加入当前模块后才可以使用
• web.xml 需要加载所有的 spring 核心配置文件

2.模块聚合

(1).多模块构建维护

在实际开发的过程中，我们会有很多模块，但是假如我们对一个模块进行更新后，其他模块不知到它更新。那么这个服务就会启动不起来。所以我们现在迫切需要一个统一的管理模块，负责管理我们的4个模块，当这个统一的模块更新的时候，这管理的所有模块都将一起进行更新，谁都不会落下。

(2).聚合

• 作用：聚合用于快速构建 maven 工程，一次性构建多个项目/模块。
• 制作方式：

1. 创建一个空模块，打包类型定义为 pom

  <!--定义该工程用于进行构建管理 -->
	<packaging>pom</packaging>

2. 定义当前模块进行构建操作时关联的其他模块名称

	<!-- 管理的工程列表  -->
<modules>
	<!-- 具体的工程 -->
	<module>../ssm_controller</module>
	<module>../ssm_service</module>
	<module>../ssm_dao</module>
	<module>../ssm_pojo</module>
</modules>

注意事项：参与聚合操作的模块最终执行顺序与模块间的依赖关系有关，与配置顺序无关;

3.模块继承

(1).多模块继承

比如说: 在我们日常开发中，我们使用多模块开发的时候，会遇到如下的问题:“我们在开发一个SpringBoot项目会出现版本依赖的版本号不一致的问题，所以我们需要对我们所有使用的公共版本号进行统一管理，避免出现不兼容的问题”。

作用：通过继承可以实现在子工程中沿用父工程中的 配置

• maven 中的继承与 java 中的继承相似，在子工程中配置继承关系

(2).继承

我们不仅可以对版本依赖的版本号可以进行统一的管理，而且我们也可以使用 插件管理器 对其进行版本控制。

1. 父工程进行声明的操作

    <!-- 声明此处进行依赖管理-->
    <dependencyManagement>
        <!--    具体的依赖集合    -->
        <dependencies>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.13.2</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

2. 子工程和父工程进行联系

    <!--    给这个子工程进行指定其父工程的位置是哪个-->
    <parent>
        <!--     这里设置三件套   -->
        <artifactId>Maven_Idea</artifactId>
        <groupId>com.jsxs</groupId>
        <version>1.0-SNAPSHOT</version>
        <!--        这里我们需要指定父工程的pom.xml文件-->
        <relativePath>pom.xml</relativePath>
    </parent>

• 在子工程中定义依赖关系，无需声明依赖版本，版本参照父工程中依赖的版本

<dependencies>
	<!-- spring 环境 -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-context</artifactId>
	</dependency>
</dependencies>

(3).继承的资源

(4).继承与聚合

• 作用
  • 聚合用于快速构建项目
  • 继承用于快速配置
• 相同点
  • 聚合与继承 的 pom.xml 文件打包方式均为 pom，可以将两种关系制作到同一个 pom 文件中
  • 聚合与继承 均属于 设计型模块，并无实际模块内容
• 不同点
  • 聚合是在当前模块中配置关系，聚合可以感知到参与聚合的模块有哪些
  • 继承是在子模块中配置关系，父模块无法感知哪些子模块继承了自己

4.属性

我们现在已经成功的解决了 父模块 与 子模块 之间的版本信息冲突的操作， 现在还存在着一种就是 父模块内部之间的版本依赖问题，比如说:“我们父工程内部使用mybatis与spring的时候要使用统一的版本号管理操作”

(1).自定义属性

• 作用：等同于定义变量，方便统一维护

• 定义格式：

    <properties>
        <!--        基本格式为:  技术名称.version-->
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <spring.version>5.1.9</spring.version>
    </properties>

使用格式

	<version>${spring.version}</version>

(2).内置属性

• 作用：使用 maven 内置属性，快速配置
• 调用格式:

${basedir}
${version}

(3).Setting 属性

• 作用：使用 maven 配置文件 settings.xml 中的标签属性，用于动态配置
• 调用格式

${settings.localRepository}

(4).Java 系统属性

• 作用: 读取 Java 系统属性
• 调用格式

${user.home}

• 系统属性查询方式

mvn help:system

(5).环境变量属性

• 调用格式

${env.JAVA_HOME}

• 环境变量属性查询方式

mvn help:system

5.版本管理

(1).工程版本

• SNAPSHOT (快照版本）
  项目开发过程中，为方便团队成员合作，解决模块间相互依赖和不时更新的问题，开发者对每个模块进行构建的时候，输出的临时性版本叫快照版本（测试阶段版本）
  快照版本会随着开发的进展不断更新。
• RELEASE (发布版本）
  项目开发进入阶段里程碑后，向团队外部发布较为稳定的版本，这种版本所对应的构件文件是稳定的，即便进行功能的后续开发，也不会改变当前发布版本内容，这种版本称为发布版本。

(2).工程版本号约定

• 约定规范
  • <主版本>.<次版本>.<增量版本>.<里程碑版本>
  • 主版本：表示项目重大架构的变更，如: spring 5 相较于 spring 4 的迭代
  • 次版本：表示有较大的功能增加和变化，或者全面系统地修复漏洞
  • 增量版本：表示有重大漏洞的修复
  • 里程碑版本：表明一个版本的里程碑（版本内部）。这样的版本
• 范例
  5.1.9.RELEASE

6.资源配置

(1).资源配置多文件维护

也就是说: 我们需要通过 Maven 来配置 比如数据库 驱动器、密码、账户等其他类似的数据。

1. 定义格式:

<properties>
<jdbc.url>jdbc:mysql://127.0.0.1:3306/ssm_db</jdbc.url>
</properties>

<build>
<!-- 配置资源文件对应的信息 -->
<resources>
	<resource>
		<!-- 设定配置文件对应的位置目录，支持使用属性动态设定路径 -->
		<directory>${project.basedir}/src/main/resources</directory>
		<!-- 开启对配置文件的资源加载过滤 -->
		<filtering>true</filtering>
	</resource>
</resources>
<!--配置测试资源文件对应的信息-->
<testResources>
	<testResource>
		<directory>${project.basedir}/src/test/resources</directory>
		<filtering>true</filtering>
	</testResource>
</testResources>
<build/>

2. 调用格式

${jdbc.url}

(2).配置文件中读取pom属性值

• 在配置文件中设置配置文件路径。
• 开启加载pom属性过滤功能。
• 使用${属性名}格式引用pom属性。

7.多环境开发配置

(1).多环境兼容

    <!--  1.  创建多环境-->
    <profiles>
        <!--    2.    定义具体的环境: 生产环境-->
        <profile>
            <!--      2.1      定义环境对应的唯一名称-->
            <id>pro_env</id>

            <!--        2.2    定义环境中专用的属性值-->
            <properties>
                <jdbc.url>jdbc:mysql://127.454545.1.1:3306/ssm_db</jdbc.url>
            </properties>

        </profile>

        <!--    3.    定义具体的环境: 开发环境-->
        <profile>
            <!--     3.1       定义环境对应的唯一名称-->
            <id>pro_dep</id>

            <!--      3.2      定义环境中专用的属性值-->
            <properties>
                <jdbc.url>jdbc:mysql://127.1.8888.1:3306/ssm_db</jdbc.url>
            </properties>
            <!--设置默认启动 ⭐-->
            <activation>
                <activeByDefault>true</activeByDefault>
            </activation>
        </profile>
    </profiles>

(2).加载指定环境

• 作用：加载指定环境配置
• 调用格式

mvn 指令 -P 环境定义id

例如：

mvn install –P pro_env

8.跳过测试

(1).使用命令跳过测试

• 命令

1. 整体模块功能未开发。
2. 模块中某个功能未开发完毕。
3. 单个功能更新调试导致其他功能失败。
4. 快速打包。

mvn 具体指令 -D skipTests

eg: mvn install -D skipTest

(2).使用界面操作跳过测试

单机 test 之后，我们点击闪电的图标就会发现会有一个画线的操作

(3).使用配置跳过测试

<build>
<piugins>
<plugin>
	<artifactId>maven-surefire-plugin</artifactId>
	<version>2.22.1</version>
	<configuration>
		<skipTests>true</skipTests><!-- 设置跳过测试 -->
			<includes> <!-- 包含指定的测试用例 -->
				<include>**/User*Test.java</include>
			</includes>
			<excludes><!-- 排除指定的测试用例 -->
				<exclude>**/User*TestCase.java</exclude>
			</excludes>
	</configuration>
</plugin>
<piugins/>
<build>

9.私服 (局部多台计算机共享)

(1). 安装 Nexus 服务器

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

(2).启动 Nexus 服务器

1. 服务器通过命令行进行启动的操作

nexus /run nexus

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

访问Nexus的服务器: http://localhost:8081/

• 修改基础配置信息

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

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

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

(3).私服资源获取

(4).仓库分类 (三种)

• 宿主仓库 hosted
  • 保存无法从中央仓库获取的资源
    • 自主研发
    • 第三方非开源项目
• 代理仓库 proxy
  • 代理远程仓库，通过 nexus 访问其他公共仓库，例如中央仓库
• 仓库组 group
  • 将若干个仓库组成一个群组，简化配置
  • 仓库组不能保存资源，属于设计型仓库

(5).可视化UI资源上传

1. 登入我们的账号

2. 仓库的分类图标

3. 创建主机仓库

4. 将我们创建的主机仓库放入 仓库组中

5. 给指定的仓库添加文件

进行上传我们的组件的信息

寻找上传的jar包和自定义我们的三件套

查看是否上传成功

(6). 本地仓库访问私服

1. 做好两个仓库，其中一个是开发版，另一个是稳定版。

2. 在Maven的核心配置文件中添加访问的账户和密码 ⭐

  <!-- 配置访问私服的用户名和密码 -->
  <servers>
	<server>
		<id>heima-release</id>
		<username>admin</username>
		<password>xxx</password>
	</server>
	<server>
		<id>heima-snapshot</id>
		<username>admin</username>
		<password>xxx</password>
	</server>
</servers>

3. 配置本地仓库镜像 ⭐

寻找我们的本地仓库位置

      <!-- 本地私服的仓库 -->
      <id>nexus-heima</id>
       <!-- 意味着所有资源全部在这里取 -->
      <mirrorOf>*</mirrorOf>
      <!-- 仓库的路径 -->
      <url>http://localhost:8081/repository/maven-public/</url>
    </mirror>

(7).idea 访问私服与组件上传

• 配置当前项目访问私服上传资源的保存位置 (pom.xml)

    <!--  发布配置管理  -->
    <distributionManagement>
        <!--  具体上传的仓库-->
        <repository>
            <!--      根据这个名称去我们本地仓库中找 对应的账户和密码      -->
            <id>heima-release</id>
            <!--        仓库要上传的路径    -->
            <url>http://localhost:8081/repository/heima-release/</url>
        </repository>
        <snapshotRepository>
            <!--      根据这个名称去我们本地仓库中找 对应的账户和密码      -->
            <id>heima-snapshots</id>
            <!--        仓库要上传的路径    -->
            <url>http://localhost:8081/repository/heima-snapshots/</url>
        </snapshotRepository>
    </distributionManagement>

• 发布资源到私服命令

mvn deploy