Maven——你的麻烦制造者？

前言：
maven是用来提高编程效率的，但它为何总是成为你的bug缔造者呢？

你是否经常遇到如下问题

例如：

• 害怕做新项目，因为每一次下载新项目，你的pom文件总是会报红。然后一调就是好几天过去了。。。
• 打包的时候，经常build faliure。。。
• 明明都是同一个maven的settings文件，别人的maven依赖都正常，而你的仓库总是少点东西。。

如果你还在被这些问题困扰 ，那说明你对maven的认知已经达到了匮乏的程度了。如果你不希望再因为maven而无畏的加班，那就静下心来仔细阅读本篇文章，一定能解决你的困扰！

Maven 自动化的构建工具

第一章 Maven简介

1.1 软件开发中的阶段

需求分析： 分析项目具体完成的功能，有什么要求， 具体怎么实现。

设计阶段：根据分析的结果， 设计项目的使用什么技术， 解决难点。

开发阶段：编码实现功能。 编译代码。自我测试

测试阶段：专业的测试人员，测整个项目的功能十分符合设计要求。出一个测试报告。

项目的打包，发布阶段： 给用户安装项目

1.2 Maven能做什么

1）项目的自动构建，帮助开发人员做项目代码的编译，测试， 打包，安装，部署等工作。

2）管理依赖（管理项目中使用的各种jar包）。

​ 依赖：项目中需要使用的其他资源， 常见的是jar 。 比如项目要使用mysql驱动。我们就说项目依赖mysql驱动。

1.3 没有使用maven怎么管理依赖

管理jar ，需要从网络中单独下载某个jar

需要选择正确版本

手工处理jar文件之间的依赖。 a.jar里面要使用b.jar的类。

1.4 什么是maven

maven是apache基金会的开源项目，使用java语法开发。 Maven 这个单词的本意是：专家，内行。读音是['meɪv(ə)n] 或 ['mevn]。

maven是项目的自动化构建工具。 管理项目的依赖。

1.5 maven中的概念

①POM
②约定的目录结构
③坐标
④依赖管理
⑤仓库管理
⑥生命周期
⑦插件和目标
⑧继承
⑨聚合

1.6 maven工具的获取和安装

地址： http://maven.apache.org/ 从中下载 .zip文件。 使用的 apache-maven-3.3.9-bin.zip

安装：

1. 确定JAVA_HOME 指定jdk的安装目录， 如果没有JAVA_HOME， 需要在windows的环境变量中创建JAVA_HOME, 它的值是jdk的安装目录

2. 解压缩 apache-maven-3.3.9-bin.zip ，把解压后的文件放到一个目录中。

   目录的路径不要有中文， 不要有空格。

3. 把maven安装目录中下的bin的路径添加到path中

4. 测试maven的安装。 在命令行执行 mvn -v

   C:\Users\NING MEI>mvn -v
   Apache Maven 3.3.9 (bb52d8502b132ec0a5a3f4c09453c07478323dc5; 2015-11-11T00:41:47+08:00)
   Maven home: D:\tools\apache-maven-3.3.9\bin\..
   Java version: 1.8.0_101, vendor: Oracle Corporation
   Java home: C:\Program Files\Java\jdk1.8.0_101\jre
   Default locale: zh_CN, platform encoding: GBK
   OS name: "windows 10", version: "10.0", arch: "amd64", family: "dos"
   

maven的其他安装方式：

1. 确定JAVA_HOME是否有效

2. 在环境变量中，创建一个叫做M2_HOME (或者MAVEN_HOME) ，它的值是maven的安装目录

   M2_HOME=D:\tools\apache-maven-3.3.9

3. 在path环境变量中，加入 %M2_HOME%\bin

4. 测试maven的安装，在命令行执行 mvn -v

   C:\Users\NING MEI>mvn -v
   Apache Maven 3.3.9 (bb52d8502b132ec0a5a3f4c09453c07478323dc5; 2015-11-11T00:41:47+08:00)
   Maven home: D:\tools\apache-maven-3.3.9\bin\..
   Java version: 1.8.0_101, vendor: Oracle Corporation
   Java home: C:\Program Files\Java\jdk1.8.0_101\jre
   Default locale: zh_CN, platform encoding: GBK
   OS name: "windows 10", version: "10.0", arch: "amd64", family: "dos"
   

第二章Maven的核心概念

2.1 约定的目录结构

maven项目使用的大多人 遵循的目录结构。 叫做约定的目录结构。

一个maven项目是一个文件夹。 比如项目叫做Hello

Hello 项目文件夹
    \src
        \main                叫做主程序目录（完成项目功能的代码和配置文件）
             \java          源代码（包和相关的类定义）
             \resources        配置文件
        \test               放置测试程序代码的（开发人员自己写的测试代码）
             \java          测试代码的（junit）
             \resources     测试程序需要的配置文件
    \pom.xml                maven的配置文件， 核心文件

maven的使用方式：

1）maven可以独立使用： 创建项目，编译代码，测试程序，打包，部署等等

2）maven和idea一起使用：通过idea借助maven，实现编码，测试，打包等等

2.2 POM

POM： Project Object Model 项目对象模型， maven把项目当做模型处理。 操作这个模型就是操作项目。

maven通过pom.xml文件实现 项目的构建和依赖的管理。

<?xml version="1.0" encoding="UTF-8"?>

<!-- project是根标签， 后面的是约束文件 -->
<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">
    
    
  <!-- pom模型的版本， 就是4.0.0 -->  
  <modelVersion>4.0.0</modelVersion>

  <!-- 坐标 -->  
  <groupId>com.bjpowernode</groupId>
  <artifactId>ch01-maven</artifactId>
  <version>1.0-SNAPSHOT</version>
  
  <properties>
     <java.version>1.8</java.version>
     <maven.compiler.source>1.8</maven.compiler.source>
     <maven.compiler.target>1.8</maven.compiler.target>
  </properties>
  
</project>

2.3 坐标

坐标组成是 groupid, artifiactId, version。 坐标概念来自数学。·

坐标作用：确定资源的，是资源的唯一标识。 在maven中，每个资源都是坐标。 坐标值是唯一的。简称叫gav

  <groupId>com.bjpowernode</groupId>
  <artifactId>ch01-maven</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

groupId: 组织名称，代码。 公司，团体或者单位的标识。 这个值常使用的公司域名的倒写。
         例如：学校的网站 www.bjpowernode.com, groupId: com.bjpowernode

         如果项目规模比较大， 也可以是 域名倒写+大项目名称。
         例如： www.baidu.com ,  无人车： com.baidu.appollo
artifactId:项目名称， 如果groupId中有项目， 此时当前的值就是子项目名。 项目名称是唯一的。
version：版本， 项目的版本号， 使用的数字。 三位组成。 例如 主版本号.次版本号.小版本号， 例如： 5.2.5。
         注意：版本号中有-SNAPSHOT， 表示快照，不是稳定的版本。      
   
packaging 项目打包的类型， 有jar ，war， ear， pom等等 默认是jar

项目使用gav：

1.每个maven项目，都需要有一个自己的gav

2.管理依赖，需要使用其他的jar ，也需要使用gav作为标识。

搜索坐标的地址： https://mvnrepository.com/

2.4 依赖 dependency

依赖：项目中要使用的其他资源（jar）。

需要使用maven表示依赖，管理依赖。 通过使用dependency和gav一起完成依赖的使用

需要在pom.xml文件中，使用dependencies 和dependency， 还有gav 完成依赖的说明。

依赖配置格式：

<dependencies>
  
    <!-- 日志 -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>
    
    <!-- mysql驱动 -->
     <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.16</version>
    </dependency>

</dependencies> 

maven使用gav作为标识，从互联网下载依赖的jar。 下载到你的本机上。  由maven管理项目使用的这些jar

2.4.1依赖传递：

• 依赖具有传递性

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

• 依赖传递冲突问题
  -路径优先：当以来中出现相同资源时，层级越深，优先级越低；层级越浅，优先级越高。
  -声明优先：当资源在相同层级被依赖时，配置顺序靠前的覆盖配置顺序靠后的。
  -特殊优先：当同级配置了相同资源的不同版本，后配置的会覆盖先配置的。
  

2.4.2可选依赖

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

A项目引用了B项目，B项目设置了junit包的可选依赖，则在A项目中看不到B引用了junit包。

2.4.3排除依赖

排除依赖是指主动断开依赖的资源，被排除的资源无需指定版本。

2.4.4依赖范围

依赖的jar默认情况可以在任何地方使用，可以通过scope标签设定其作用范围。
依赖范围就是用来控制依赖与这三种classpath(编译classpath、测试classpath、运行classpath)的关系，Maven有以下几种依赖范围：

• compile: 编译依赖范围。如果没有指定，就会默认使用该依赖范围。使用此依赖范围的Maven依赖，对于编译、测试、运行三种classpath都有效。

• test: 测试依赖范围。使用此依赖范围的Maven依赖，只对于测试classpath有效，在编译主代码或者运行项目的使用时将无法使用此类依赖。典型的例子就是JUnit，它只有在编译测试代码及运行测试的时候才需要。

• provided: 已提供依赖范围。使用此依赖范围的Maven依赖，对于编译和测试classpath有效，但在运行时无效。典型的例子是servlet-api，编译和测试项目的时候需要该依赖，但在运行项目的时候，由于容器已经提供，就不需要Maven重复地引入一遍。

• runtime: 运行时依赖范围。使用此依赖范围的Maven依赖，对于测试和运行classpath有效，但在编译主代码时无效。典型的例子是JDBC驱动实现，项目主代码的编译只需要JDK提供的JDBC接口，只有在执行测试或者运行项目的时候才需要实现上述接口的具体JDBC驱动。

• system: 和provide相同，不过被依赖项不会从maven仓库抓，而是从本地系统文件拿，一定要配合systemPath使用

servlet-api 打包的时候不参与打包，因为tomcat提供了该jar包。
junit只在测试代码范围生效，如果加上test，则在main下面无法导入junit这个包到代码里。

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

能被打包的，才能被传递。

2.4.5外部依赖

外部依赖是指在maven中央库，本地库，远程库都不存在的jar包，如本地硬盘中的jar包。

可通过如下方式配置外部依赖项。

<dependency>
  <groupId>com.qikegu.com</groupId>
  <artifactId>mydependency</artifactId>
  <scope>system</scope>
  <version>1.0</version>
  <systemPath>${basedir}warWEB-INFlibmydependency.jar</systemPath>
</dependency>

2.5 仓库

仓库是存东西的，maven的仓库存放的是：

1. maven工具自己的jar包。

2. 第三方的其他jar， 比如项目中要使用mysql驱动。

3. 自己写的程序，可以打包为jar 。 存放到仓库。

仓库的分类：

1. 本地仓库（本机仓库）： 位于你自己的计算机， 它是磁盘中的某个目录。

   本地仓库：默认路径，是你登录操作系统的账号的目录中/.m2/repository

        C:\Users\NING MEI\.m2\repository
   

   修改本地仓库的位置：修改maven工具的配置文件（maven的安装路径\conf\setting.xml）
   settings.xml有两个级别
   1.用户级别：C:\Users\NING MEI.m2\settings.xml。
   2.全局级别：maven的安装路径\conf\settings.xml。
   这两个文件都可以指定本地仓库路径，但是用户级别的优先级高，因此如果在用户级别的xml中找到了的配置，则全局的配置失效。否则会去全局级别的xml中找的配置。
   如果依然找不到，则认为没有指定本地仓库路径，则会用默认路径C:\Users\NING MEI.m2作为本地仓库路径。

   ​ 步骤：

   ​ 1）创建一个目录，作为仓库使用。 目录不要有中文和空格。 目录不要太深。

   ​ 例如： D:\openrepository

   ​ 2）修改setting.xml文件，指定 D:\openrepository这个目录

       <localRepository>D:/openrepository</localRepository>
   

   ​ 3) 把我给你提供的 仓库的资源 拷贝到 D:/openrepository

• 远程仓库： 需要通过联网访问的

  1）中央仓库： 一个ftp服务器， 存放了所有的资源。 中央仓库地址：https://repo.maven.apache.org

  2）中央仓库的镜像： 就是中央仓库的拷贝。 在各大洲，各大主要城市都有镜像。
  

  3）私服：在局域网中使用的。 私服就是自己的仓库服务器。 在公司内部使用的。
  私服的作用：

  • 保存具有版权的资源
    - 中央仓库的jar都是开源的，不能存储具有版权的资源

  • 一定范围内共享资源，仅对内部公开，不对外部公开

  私服详情见第十章

maven使用仓库： maven自动使用仓库，不用人为参与， 当项目启动后， 执行了maven的命令， maven首先访问的是本地仓库， 从仓库中获取所需的jar， 如果本地仓库没有 ，需要访问私服或者中央仓库或者镜像。
本地仓库----私服----镜像-----中央仓库。

2.6 maven的生命周期，插件和命令

maven的生命周期： 项目构建的各个阶段。 包括 清理， 编译， 测试，报告，打包，安装，部署等
maven对项目构建的生命周期划分为3套

• clean：清理工作
• default：核心工作，例如编译，测试，打包，部署等
• site：产生报告，发布站点等
  
  
  这里面执行任意的一个操作，会将直接的每个操作挨个执行一遍。

插件：要完成构建项目的各个阶段，要使用maven的命令， 执行命令的功能是通过插件完成的。插件就是jar，一些类。

• 插件与生命周期内的阶段绑定，在执行到对应生命周期时执行对应的插件功能。
• 默认maven在各个生命周期上绑定有预设的插件功能。
• 如果觉得某些生命周期需要完成额外的事情，可以通过插件自定义其功能。

命令： 执行maven功能是 由命令发出的。 比如 mvn compile

单元测试（junit）：

junit是一个单元测试的工具， 在java中经常使用。

单元：在java中指的是方法。 一个方法就是一个单元， 方法是测试的最小单位。

作用：使用junit去测试方法是否完成了要求。 开发人员自测。

使用单元测试：

1）加入junit的依赖（一些类和方法）

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

2)在src/test/java 目录中创建测试类文件。 写测试代码

单元测试使用的建议：

​ 1.测试类的定义， 名称一般是Test+要测试的类名称

​ 2.测试类它的包名和要测试的类包名一样。

​ 3.在类中定义方法，要测试代码。

​ 方法的定义：public方法，

​ 没有返回值

​ 方法名称自定义（建议 Test+测试的方法名称）

​ 方法没有参数

4.在测试类中的方法，可以单独执行。 测试类也可以单独执行

5.在方法的上面加入@Test

命令：

1） mvn clean: 清理命令， 作用删除以前生成的数据， 删除target目录。

​ 插件： maven-clean-plugin ， 版本是 2.5

2）mvn compile:编译命令，执行的代码编译， 把src/main/java目录中的java代码编译为class文件。

​ 同时把class文件拷贝到 target/classes目录。 这个目录classes是存放类文件的根目录（也叫做类路径，classpath）

​ 插件： maven-compiler-plugin 版本3.1。 编译代码的插件

​ maven-resources-plugin 版本2.6 。 资源插件， 处理文件的。 作用是把src/main/resources目录中的

​ 文件拷贝target/classes目录中。

3）mvn test-compile: 编译命令， 编译src/test/java目录中的源文件， 把生成的class拷贝到target/test-classes目录。同时把src/test/resources目录中的文件拷贝到 test-clasess目录

​ 插件： maven-compiler-plugin 版本3.1。 编译代码的插件

​ maven-resources-plugin 版本2.6 。 资源插件， 处理文件的

4）mvn test:测试命令， 作用执行 test-classes目录的程序， 测试src/main/java目录中的主程序代码是否符合要求。

​ 插件： maven-surefire-plugin 版本 2.12.4

5）mvn package:打包，作用是把项目中的资源class文件和配置文件都放到一个压缩文件中， 默认压缩文件是jar类型的。 web应用是war类型， 扩展是jar，war的。

​ 插件：maven-jar-plugin 版本 2.4。 执行打包处理。 生成一个jar扩展的文件， 放在target目录下.

​ 打包的文件包含的是 src/main目录中的所有的生成的class和配置文件和test无关。

​ 生成的是 ch01-maven-1.0-SNAPSHOT.jar

  <groupId>com.bjpowernode</groupId>
  <artifactId>ch01-maven</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>
打包的文件名： artifactId-version.packaging

6）mvn install : 把生成的打包的文件 ，安装到maven仓库。

​ 插件： maven-install-plugin 版本 2.4 。 把生成的jar文件安装到本地仓库。

​ 查看查看中的jar文件：

  <groupId>com.bjpowernode</groupId>
  <artifactId>ch01-maven</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

groupId中的值， 如果有 "." 前和后都是独立的文件夹。 com\bjpowernode
artifactId, 独立的文件夹
version，独立的文件夹

2.7 自定义配置插件

在pom.xml文件中， build标签中。设置插件

<!-- 设置构建项目相关的内容 -->
<build>
  <plugins>
    <!-- 设置插件 -->
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.1</version>
        <configuration>
            <source>1.8</source> <!-- 指定编译代码的jdk版本 -->
            <target>1.8</target> <!-- 运行java程序使用的jdk版本-->
        </configuration>
    </plugin>
  </plugins>
</build> 

这是一种方式。
前面说过，如果不满足于默认的生命周期阶段做的事情，可以自定义插件，maven官网提供了每个插件的具体使用说明。 https://maven.apache.org/plugins/index.htmlhttps://maven.apache.org/plugins/index.html
此处已打源码包source插件为例说明，官方给的使用方式如下：

• 指定在某个生命周期阶段，执行打包插件

<project>
  ...
  <build>
    <plugins>
      <plugin>
      <!--插件的坐标-->
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-source-plugin</artifactId>
        <version>3.2.1</version>
        <!--插件执行配置，可以配置多个-->
        <executions>
          <execution>
            <id>attach-sources</id>
            <!--在哪个阶段执行-->
            <phase>verify</phase>
            <goals>
           	   <!--要生成什么要的包-->
              <goal>jar-no-fork</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
  ...
</project>

• 如果您想在发布过程中安装源代码的 jar 和工件，您可以将其添加到 pom.xml 文件中:

<project>
  ...
  <profiles>
    <profile>
      <id>release</id>
      <build>
        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-source-plugin</artifactId>
            <version>3.2.1</version>
            <executions>
              <execution>
                <id>attach-sources</id>
                <goals>
                  <goal>jar-no-fork</goal>
                </goals>
              </execution>
            </executions>
          </plugin>
        </plugins>
      </build>
    </profile>
  </profiles>
  ...
</project>

第三章 Maven和idea的集成

3.1 idea中集成maven

idea中有一个自带的maven。 我们要让idea使用自己安装的maven。

1. 选择File- Settings

设置项： -DarchetypeCatalog=internal

3.2 创建基于maven的普通java项目

3.3 创建web项目

3.4 导入module到idea

4. 第四章 依赖管理

依赖范围：使用scope表示依赖的范围。

依赖范围表示： 这个依赖（jar和里面类）在项目构建的那个阶段起作用。

依赖范围scope ：

​ compile:默认， 参与构建项目的所有阶段

​ test：测试，在测试阶段使用， 比如执行mvn test会使用junit 。

​ provided: 提供者。 项目在部署到服务器时，不需要提供这个依赖的jar ， 而是由服务器这个依赖的jar包

明显的是servlet 和jsp 依赖

5. 第五章 常用设置

1)讲的是properties它里面的配置

<properties>
<maven.compiler.source>1.8</maven.compiler.source> 源码编译 jdk 版本
<maven.compiler.target>1.8</maven.compiler.target> 运行代码的 jdk 版本
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> 项目
构建使用的编码，避免中文乱码
<project.reporting.outputEncoding>UTF-8
</project.reporting.outputEncoding> 生成报告的编码
</properties>

2. 全局变量，属性，maven中有物种属性，这里只介绍自定义的一种，其他的参加官网

在properties定义标签，这个标签就是一个变量， 标签的文本就是变量的值。

使用全局变量表示 多个依赖使用的版本号。

使用步骤：

1.在properties标签中，定义一个标签，指定版本的值

<properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <maven.compiler.source>1.8</maven.compiler.source>
  <maven.compiler.target>1.8</maven.compiler.target>
  <!--自定义变量-->
  <spring.version>5.2.5.RELEASE</spring.version>
  <junit.version>4.11</junit.version>
</properties>

2. 使用全局变量， 语法 ${变量名}

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

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

3）使用资源插件

处理的配置文件的信息， maven默认处理配置文件

①：maven会把src/main/resources目录中的文件， 拷贝到target/classes目录下

②：maven只处理src/main/java目录中的 .java文件，把这些java文件编译为class，拷贝到 target/classes目录中。 不处理其他文件。

<build>
  <!--资源插件
      告诉maven把 src/main/java目录中的 指定扩展名的文件 拷贝到 target/classes目录中。
  -->
  <resources>
    <resource>
      <directory>src/main/java</directory><!--所在的目录-->
      <includes>
      <!--包括目录下的.properties,.xml 文件都会扫描到-->
        <include>**/*.properties</include>
        <include>**/*.xml</include>
      </includes>
        <!--  filtering 选项 false 不启用过滤器， *.property 已经起到过
        滤的作用了 -->
      <filtering>false</filtering>
    </resource>
  </resources>
</build>

6. 第六章 聚合

6.1背景

现在的项目几乎都是多模块的，往往一个大项目由十几个，几十个项目共同完成。而且这些项目很多是互相依赖的，试想一下，如果其中某个项目更新了，而依赖他的项目没有同步更新，则很可能整个项目都会报错。因此我们想，在一个小项目更新的同时，依赖他的和他依赖的项目同时重新构建。如果手动挨个去构建，十几个或者几十个小项目，那将会是令人头疼的事情。
那么有什么更好的办法呢？答案是有的：聚合。

6.2聚合是什么

聚合：用于快速构建maven工程，一次性构建多个项目/模块
制作方式：创建一个空项目，该项目只有一个pom文件即可。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.groupId</groupId>
    <artifactId>ssm</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--定义该工程用于进行构建管理-->
    <packaging>pom</packaging>

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

</project>

注意：modules的配置不分先后，当构建这个聚合工程的时候，模块的打包顺序maven会根据依赖关系自动梳理打包顺序。

7. 第七章 继承

7.1背景

如下图所示，service项目，dao项目，controller都要用到Spring-context这个包，如果不同的人开发选用的不同的版本，那么项目在运行的时候很可能会出错。大家都是做的一个大项目，里面共同的jar包势必要统一版本，那么如何统一呢？这就用到了继承。

7.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>ssm</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--定义该工程用于进行构建管理-->
    <packaging>pom</packaging>

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

    <!--声明此处进行依赖管理-->
    <dependencyManagement>
        <!--具体的依赖-->
        <dependencies>

            <!--spring环境-->
            <!--spring环境-->
            <!--spring环境-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.1.9.RELEASE</version>
            </dependency>

            <!--mybatis环境-->
            <!--mybatis环境-->
            <!--mybatis环境-->
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>3.5.3</version>
            </dependency>
            <!--mysql环境-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.47</version>
            </dependency>
 ...
        </dependencies>

    </dependencyManagement>

    <build>
        <pluginManagement>
            <!--设置插件-->
            <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>
        </pluginManagement>
    </build>

</project>

子工程配置如下

    <!--定义该工程的父工程-->
    <parent>
        <groupId>com.itheima</groupId>
        <artifactId>ssm</artifactId>
        <version>1.0-SNAPSHOT</version>
        <!--填写父工程的pom文件-->
        <relativePath>../ssm/pom.xml</relativePath>
    </parent>
    ...
      <!--spring环境依赖，无需指定版本号，继承父工程的版本号-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>

" dependencyManagement>"的作用
maven使用dependencyManagement>提供管理依赖版本号的方式。一般在一个组织或者项目的最顶层父POM中看到dependencyManagement>元素。

作用：

1. 该元素能让所有子项目中引用一个依赖，而不用显式列出版本号。
2. 更新版本时，只需要更新顶层父容器中的版本号，不需要修改一个个子项目。
3. 子POM也可以声明自己的版本号。
4. dependencyManagement>只是声明依赖，并不实现引入。因此子项目需要显式声明需要用的依赖。

8. 第八章 工程版本

工程版本

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

工程版本号约定

• 约定规范:<主版本>.<次版本>.<增量版本>,<里程碑版本>
  • 主版本:表示项目重大架构的变更，如:spring5相较于spring4的迭代次版本:表示有较大的功能增加和变化，或者全面系统地修复漏洞
  • 增量版本:表示有重大漏洞的修复
  • 里程碑版本:表明一个版本的里程碑(版本内部)。这样的版本同下一个正式版本相比，相对来说不是很稳定，有待更多的测试范例:
    5.1.9.RELEASE

9. 第九章 其他概念

10. 第十章 私服详情

使用场景

每个不同模块的开发人员完成开发之后，其他模块想引用该模块，如何实现？显然需要每个人将自己开发的模块打包后放到一个公共的仓库里以供其他模块调用。那这个仓库放到本地仓库，还是中央仓库？都不可能，本地仓库无法共享，中央仓库也没有权限往上放。显然就需要一个公司内部的公共服务器。该服务器包含仓库，大家都可以把自己的包放上去，达到共享的目的，那么这个服务器仓库称之为私服。
如何搭建私服

目前主流的私服搭建使用Nexus(阿里的镜像也是用这个搭建的)

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

私服获取资源

私服里资源种类分三种:

• 一种是镜像中央仓库的。
• 一种是公司内部开发的快照版的资源。
• 一种是公司内部开发的发行版的资源。

仓库分类

• 宿主仓库(公司内部自己维护的jar包)
  • 保存无法从中央仓库获取的资源
    • 自主研发的资源
    • 第三方非开源项目(oracle数据库连接等，不开源，中央仓库没有)
• 代理仓库proxy(开源公开的jar包)
  • 代理远程仓库，通过nexus访问其他公共仓库，例如中央仓库/阿里镜像仓库等
• 仓库组group
  • 将若干个仓库组成一个群组，简化配置
  • 仓库组不能保存资源，属于设计型仓库
  • 通常仓库组包含快照库，发行库，代理库，取资源的时候直接从这个仓库组遍历去找。
    
    连接私服相关配置
    
    上传配置
• 用户名密码。(配到本地仓库settings.xml)
• 上传的位置(宿主仓库)(配到每个项目的pom.xml中，因为每个项目提交的宿主仓库不同)
  下载配置
• 访问私服的用户名密码(配到本地仓库settings.xml)
• 下载的地址（组地址，配到本地仓库settings.xml）

具体配置如下：
本地仓库访问私服的权限，settings.xml中配置

<!--配置访问服务器的权限，用户名密码-->
<servers>
     <!--发行库-->
	<server>
		<id>heima-release</id>
		<username>admin</username>
		<password>admin</password>
	</server>
	<!--快照库-->
	<server>
		<id>heima-snapshots</id>
		<username>admin</username>
		<password>admin</password>
	</server>
</servers>

本地仓库资源来源，镜像可以用私服

		<!--更换私服，将阿里云的私服屏蔽-->
        <mirror>
            <id>nexus-aliyun</id>
            <mirrorOf>central</mirrorOf>
            <name>Nexus aliyun</name>
            <url>http://maven.aliyun.com/nexus/content/groups/public</url>
        </mirror>
		<!--自定义的heima私服-->
        <mirror>
            <id>nexus-heima</id>
            <mirrorOf>*</mirrorOf>
            <!--私服的中央仓库镜像-->
            <url>http://localhost:8081/repository/maven-public/</url>
        </mirror>
    </mirrors>

发布配置管理，没给个项目的pom文件，发布到私服，供其他模块使用

    <!--发布配置管理-->
    <distributionManagement>
        <repository>
        	<!--根据此id去settings文件中找对应的用户名密码-->
            <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 package 打包，本地项目target生成jar包
mvn install 安装，将生成的jar包安装到本地仓库
mvn deploy 将本地仓库的jar包部署到私服中，根据上面配置的内容，去找私服的哪个仓库。