第1章 为什么要使用Maven

之所以会提出这个问题，是因为即使不使用Maven我们仍然可以进行B/S结构项目的开发。从表述层、业务逻辑层到持久化层再到数据库都有成熟的解决方案——不使用Maven我们一样可以开发项目啊？所以我们有必要通过企业开发中的实际需求来看一看哪些方面是我们现有技术的不足。

1.1 获取第三方jar包

开发中需要使用到的jar包种类繁多，获取jar包的方式都不尽相同。为了查找一个jar包找遍互联网，身心俱疲。不仅如此，费劲心血找到的jar包里有的时候并没有你需要的那个类，又或者有同名的类没有你要的方法——以不规范的方式获取的jar包也往往是不规范的。
使用Maven我们可以享受到一个完全统一规范的jar包管理体系。你只需要在你的项目中以坐标的方式依赖一个jar包，Maven就会自动从中央仓库进行下载，并同时下载这个jar包所依赖的其他jar包——规范、完整、准确！一次性解决所有问题！

1.2 添加第三方jar包

在今天开发领域，有大量的第三方框架和工具可以供我们使用。要使用这些jar包最简单的方法就是复制粘贴到WEB-INF目录下的lib目录下。但是这会导致每次创建一个新的工程就需要将jar包重复复制到lib目录下，从而造成工作区中存在大量重复的文件。
而使用Maven后每个jar包只在本地仓库中保存一份，需要jar包的工程只需要维护一个文本形式的jar包的引用——我们称之为“坐标”。不仅极大的节约了存储空间，让项目更轻巧，更避免了重复文件太多而造成的混乱。

1.3 jar包之间的依赖关系

jar包往往不是孤立存在的，很多jar包都需要在其他jar包的支持下才能够正常工作，我们称之为jar包之间的依赖关系。最典型的例子是：commons-fileupload-1.3.jar依赖于commons-io-2.0.1.jar，如果没有IO包，FileUpload包就不能正常工作。
那么问题来了，你知道你所使用的所有jar包的依赖关系吗？当你拿到一个新的从未使用过的jar包，你如何得知他需要哪些jar包的支持呢？如果不了解这个情况，导入的jar包不够，那么现有的程序将不能正常工作。再进一步，当你的项目中需要用到上百个jar包时，你还会人为的，手工的逐一确认它们依赖的其他jar包吗？这简直是不可想象的。
而引入Maven后，Maven就可以替我们自动的将当前jar包所依赖的其他所有jar包全部导入进来，无需人工参与，节约了我们大量的时间和精力。用实际例子来说明就是：通过Maven导入commons-fileupload-1.3.jar后，commons-io-2.0.1.jar会被自动导入，程序员不必了解这个依赖关系。

1.4 处理jar包之间的冲突

上一点说的是jar包不足项目无法正常工作，但其实有的时候jar包多了项目仍然无法正常工作，这就是jar包之间的冲突。
举个例子：我们现在有三个工程MakeFriend、HelloFriend、和Hello。MakeFriend依赖HelloFriend，HelloFriend依赖Hello。而Hello依赖log4j.1.2.17.jar，HelloFriend依赖log4j.1.2.14.jar。如下图所示：
image.png
那么MakeFriend工程的运行时环境中该导入log4j.1.2.14.jar呢还是log4j.1.2.17.jar呢？
这样的问题一个两个还可以手工解决，但如果系统中存在几十上百的jar包，他们之间的依赖关系会非常复杂，几乎不可能手工实现依赖关系的梳理。
使用Maven就可以自动的处理jar包之间的冲突问题。因为Maven中内置了两条依赖原则：最短路径者优先和先声明者优先，上述问题MakeFriend工程会自动使用log4j.1.2.14.jar。

1.5 将项目拆分成多个工程模块

随着JavaEE项目的规模越来越庞大，开发团队的规模也与日俱增。一个项目上千人的团队持续开发很多年对于JavaEE项目来说再正常不过。那么我们想象一下：几百上千的人开发的项目是同一个Web工程。那么架构师、项目经理该如何划分项目的模块、如何分工呢？这么大的项目已经不可能通过package结构来划分模块，必须将项目拆分成多个工程协同开发。多个模块工程中有的是Java工程，有的是Web工程。
那么工程拆分后又如何进行互相调用和访问呢？这就需要用到Maven的依赖管理机制。大家请看调查项目拆分的情况：
image.png
下层模块依赖上层，所以上层模块中定义的API都可以为下层所调用和访问。

1.6 实现项目的分布式部署

在实际生产环境中，项目规模增加到一定程度后，可能每个模块都需要运行在独立的服务器上，我们称之为分布式部署，这里同样需要用到Maven。
image.png

第2章 Maven 是什么？

image.png

如果上面的描述能够使你认识到使用Maven是多么的重要，我们下面就来介绍一下Maven是什么。

2.1 自动化构建工具

1) Maven这个单词的本意是：专家，内行。读音是[‘meɪv(ə)n]或[‘mevn]，不要读作“妈文”。
2) Maven是一款自动化构建工具，专注服务于Java平台的项目构建和依赖管理。在JavaEE开发的历史上构建工具的发展也经历了一系列的演化和变迁：
Make→Ant→Maven→Gradle→其他……

2.2 构建的概念

1) 构建并不是创建，创建一个工程并不等于构建一个项目。构建是一个过程，就是以我们编写的Java代码、框架配置文件、国际化等其他资源文件、JSP页面和图片等静态资源作为“原材料”，去“生产”出一个可以运行的项目的过程。
那么项目构建的全过程中都包含哪些环节呢？

2.3 构建环节

1) 清理：删除以前的编译结果，为重新编译做好准备。
2) 编译：将Java源程序编译为字节码文件。
3) 测试：针对项目中的关键点进行测试，确保项目在迭代开发过程中关键点的正确性。
4) 报告：在每一次测试后以标准的格式记录和展示测试结果。
5) 打包：将一个包含诸多文件的工程封装为一个压缩文件用于安装或部署。Java工程对应jar包，Web工程对应war包。
6) 安装：在Maven环境下特指将打包的结果——jar包或war包安装到本地仓库中。
7) 部署：将打包的结果部署到远程仓库或将war包部署到服务器上运行。
image.png

第3章Maven 如何使用

在这一节中，我们来看看Maven核心程序的安装和本地仓库的必要设置。然后我们就可以编写第一个Maven程序了。

3.1 安装Maven核心程序

1) 下载地址：http://maven.apache.org/
2) 检查JAVA_HOME环境变量。Maven是使用Java开发的，所以必须知道当前系统环境中JDK的安装目录。

  1. C:\Users\韩总>echo %JAVA_HOME%
  2. D:\Java\jdk1.8.0_111

3) 解压Maven的核心程序。
将apache-maven-3.6.3-bin.zip解压到一个非中文无空格的目录下。例如：

  1. D:\apache-maven-3.6.3

4) 配置环境变量。

  1. MAVEN_HOME
  2. D:\apache-maven-3.6.3
  3. path
  4. %MAVEN_HOME%\bin

5) ④查看Maven版本信息验证安装是否正确

  1. C:\Users\韩总>mvn -v
  2. Apache Maven 3.6.3 (cecedd343002696d0abb50b32b541b8a6ba2883f)
  3. Maven home: D:\apache-maven-3.6.3\bin\..
  4. Java version: 1.8.0_111, vendor: Oracle Corporation, runtime: D:\Java\jdk1.8.0_111\jre
  5. Default locale: zh_CN, platform encoding: GBK
  6. OS name: "windows 10", version: "10.0", arch: "amd64", family: "windows"

3.2 第一个Maven程序(做程序前，做好先做3.5配置仓库)

3.2.1 Maven约定的目录结构及说明

image.pngimage.png
main目录用于存放主程序。
test目录用于存放测试程序。
java目录用于存放源代码文件。
resources目录用于存放配置文件和资源文件。

3.2.2 通过命令行的方式运行Maven程序

1) 在电脑的任意位置创建Hello目录（文件夹）
2) 在Hello目录中创建src目录和pom.xml文件
3) 在src目录中创建main和test目录
4) 在main和test目录中分别创建java和resources目录
5) 将以下内容复制到pom.xml文件中

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>com.atguigu.maven</groupId>
  8.     <artifactId>Hello</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  11.     <dependencies>
  12.         <dependency>
  13.             <groupId>junit</groupId>
  14.             <artifactId>junit</artifactId>
  15.             <version>4.0</version>
  16.             <scope>test</scope>
  17.         </dependency>
  18.     </dependencies>
  20. </project>

6) 编写主程序
在src/main/java目录下新建文件Hello.java

  1. public class Hello {
  2.     public String sayHello(String name){
  3.         return "Hello "+name+"!";
  4.     }
  5. }

7) 编写测试程序
在/src/test/java目录下新建测试文件HelloTest.java

  1. import org.junit.Test;
  3. public class HelloTest {
  5.     @Test
  6.     public void testHello(){
  7.         Hello hello = new Hello();
  8.         String maven = hello.sayHello("Maven");
  9.         System.out.println(maven);
  10.     }
  11. }

8) 运行以下常用的Maven命令

  1. 打开cmd命令行，进入Hello项目根目录(pom.xml文件所在目录)执行mvn compile命令，查看根目录变化
  2. cmd 中继续录入mvn clean命令，然后再次查看根目录变化
  3. cmd 中录入 mvn  compile命令, 查看根目录变化
  4. cmd 中录入 mvn  test-compile命令， 查看target目录的变化
  5. cmd 中录入 mvn  test命令，查看target目录变化
  6. cmd 中录入 mvn  package命令,查看target目录变化
  7. cmd 中录入 mvn  install命令， 查看本地仓库的目录变化

注意：运行Maven命令时一定要进入pom.xml文件所在的目录！

执行mvn compile命令： 则会在仓库下载相关依赖(如果有就不下载了)和生成class文件。看下图下载的还挺多！ image.pngimage.pngimage.png 如果你删除这个class文件，即target文件，再次运行mvn compile的话，会再次生成，只是这次不需要下载jar包了。 我们运行mvn clean命令，发现target自动删除了(只有这个下载的jar包会不会删除，这个没注意)。上面是手动删除！ 运行mvn test-compile：则会将Test的类也生产class文件，上面的只是生成了main下的java中的。 如果用了mvn test-compile，自然此时classes文件夹下有了Hello.class文件(至于这个是mvn compile的效果，还是mvn test-compile也可以，没注意)，而test-classes下面有了HelloTest.class文件。 image.png 此时就可以执行mvn test，发现运行了结果。 image.png 执行mvn package：则在target下生成jar包。这个jar包里面肯定只有Hello.class文件，没有测试字节码文件。 image.pngimage.png 下面是：mvn install，那么这个jar包就会放到本地仓库中！ 原本仓库 image.png 现在仓库 image.pngimage.png 该jar包和上面的mvn package生成的一模一样！ image.png 有一点想说的是：上面的所有命令都不是直接由maven做的，而是有插件做的(maven插件)，举一个例子： 比如mvn clean命令，是由这个插件做的，因此你第一次运行这个命令，是需要下载插件的。 image.png

3.3 在Eclipse中使用Maven

3.3.1 在Eclipse中配置Maven

Eclipse中默认自带Maven插件，但是通常我们不使用自带的Maven，而是使用自己安装的，在Eclipse中配置Maven的步骤如下：
1) 点击Eclipse中的Window→Preferences
image.png
2) 点开Maven前面的箭头，选择Installations，点击Add…
image.png
3) 点击Directory…选择我们安装的Maven核心程序的根目录，然后点击Finish
image.png
4) 勾上添加的Maven核心程序
image.png
5) 选择Maven下的User Settings，在全局设置哪儿点击Browse…选择Maven核心程序的配置文件settings.xml，本地仓库会自动变为我们在settings.xml文件中设置的路径
image.png

3.3.2 在Eclipse中创建Maven项目

1) 点击File→New→Maven Project，弹出如下窗口
image.png
2) 点击Next，配置坐标（GAV）及打包方式，然后点击Finish
image.png
3) 创建完工程之后发现默认的JDK的编译版本是1.5，在Maven的核心配置文件settings.xml文件中添加以下配置将编译版本改为1.8，重启Eclipse即可

  1. <profile>
  2.   <id>jdk-1.8</id>
  3.   <activation>
  4.     <activeByDefault>true</activeByDefault>
  5.     <jdk>1.8</jdk>
  6.   </activation>
  7.   <properties>
  8.       <maven.compiler.source>1.8</maven.compiler.source>
  9.       <maven.compiler.target>1.8</maven.compiler.target>
  10.       <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
  11.   </properties>
  12. </profile>

4) 参照3.2配置pom.xml文件，创建主程序和测试程序代码
5) 在工程名Hello或pom.xml上右键→Run As运行Maven项目
image.png

3.3.3 在Eclipse中导入Maven项目

1) 点击File→Import…
image.png
2) 第一次导入手动创建的Maven项目时，由于项目中没有Eclipse生成的一些文件，使用方式一导入时Eclipse认为它不是一个工程
image.png

image.png
3) 所以必须通过方式二导入到Eclipse中
image.png
image.png
4) 导入到Eclipse中之后就会生成一些Eclipse能识别的文件
image.png
5) 有了这些Eclipse能识别的文件之后以后再往Eclipse中导入的时候选择方式一和方式二都可以

3.4 在Idea中使用Maven

3.4.1 在Idea中配置Maven

  1. Idea中也自带Maven插件，而且我们也可以给自带的Maven插件进行配置，所以我们可以使用自带的Maven，也可以使用我们安装的Maven核心程序<br />1) 配置自带的Maven插件<br />1) Idea自带的Maven在Idea的安装目录的plugins目录中<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/12786164/1636053264662-908051da-da0a-4621-aa2e-a0639bd96583.png#clientId=uaa68314e-89aa-4&from=paste&id=ud63190ee&name=image.png&originHeight=143&originWidth=437&originalType=binary&ratio=1&size=33135&status=done&style=none&taskId=uc928eb69-f4bd-42ed-b3f8-c897baf09aa)<br />2) 在自带的Maven里配置了本地仓库之后打开Idea之后会发现本地仓库自动变成了我们设置的仓库<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/12786164/1636053283091-934a2c3d-b07f-4c8a-b1e5-dd5fb27ab96f.png#clientId=uaa68314e-89aa-4&from=paste&id=ue83068bf&name=image.png&originHeight=327&originWidth=456&originalType=binary&ratio=1&size=81097&status=done&style=none&taskId=u2aeda3ad-dcd5-46e9-8dfc-b04708a5fa6)<br />3) 设置Maven自动导包<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/12786164/1636053304570-afb7a78e-4c0e-4fd7-b671-a7bd50919499.png#clientId=uaa68314e-89aa-4&from=paste&id=u0b8ca653&name=image.png&originHeight=334&originWidth=465&originalType=binary&ratio=1&size=111308&status=done&style=none&taskId=u4dfdc8e1-0db1-4708-879f-d8e0d1bc2d7)<br />1) 配置我们自己安装的Maven<br />1) 点击工具栏中的Settings<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/12786164/1636053325913-b8d2f644-3807-43ca-8bde-ae2e3eb767ad.png#clientId=uaa68314e-89aa-4&from=paste&id=ua0c3edaa&name=image.png&originHeight=335&originWidth=467&originalType=binary&ratio=1&size=93069&status=done&style=none&taskId=u24803d35-284a-464e-aeb1-0c63899fa70)<br />2) 点击OK保存即可

3.4.2 在Idea中创建Maven项目

1) 点击File→New→Module…（如果之前没有Project选Project）→Maven
image.png
2) 点击Next，配置要继承的模块（如果直接创建的是Project不存在这一项）、坐标（GAV）、路径。不同的Idea版本可能有所差别，我使用的是2019.3.3的版本
image.png
3) 点击Finish即可创建成功
4) 创建完工程之后在settings→Build，Execusion，Development→Compiler→Java Compiler中发现默认的JDK的编译版本是1.5，在Maven的核心配置文件settings.xml文件中添加以下配置将编译版本改为1.8，重启Idea即可

  1. <profile>
  2.   <id>jdk-1.8</id>
  3.   <activation>
  4.     <activeByDefault>true</activeByDefault>
  5.     <jdk>1.8</jdk>
  6.   </activation>
  7.   <properties>
  8.       <maven.compiler.source>1.8</maven.compiler.source>
  9.       <maven.compiler.target>1.8</maven.compiler.target>
  10.       <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
  11.   </properties>
  12. </profile>

5) 配置Maven的核心配置文件pom.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>com.atguigu.maven</groupId>
  8.     <artifactId>Hello</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  11.     <dependencies>
  12.         <dependency>
  13.             <groupId>junit</groupId>
  14.             <artifactId>junit</artifactId>
  15.             <version>4.0</version>
  16.             <scope>test</scope>
  17.         </dependency>
  18.     </dependencies>
  20. </project>

6) 编写主代码
在src/main/java目录下新建文件Hello.java

  1. package com.atguigu.maven;
  3. public class Hello {
  4.     public String sayHello(String name){
  5.         return "Hello "+name+"!";
  6.     }
  7. }

7) 编写测试代码
在/src/test/java目录下新建测试文件HelloTest.java

  1. package com.atguigu.maven;
  3. import org.junit.Test;
  5. public class HelloTest {
  7.     @Test
  8.     public void testHello(){
  9.         Hello hello = new Hello();
  10.         String maven = hello.sayHello("Maven");
  11.         System.out.println(maven);
  12.     }
  13. }

8) 使用Maven的方式运行Maven工程
image.png

3.4.3 在Idea中导入Maven项目

1) 点击Project Structure
image.png
2) 点击Modules→➕→Import Module
image.png
3) 找到项目所在的位置
image.png
4) 选择Import module from external model（从外部模型导入模块）→Maven→Finish
image.png

3.5 Maven 联网问题

1) 配置本地仓库
1) Maven的核心程序并不包含具体功能，仅负责宏观调度。具体功能由插件来完成。Maven核心程序会到本地仓库中查找插件。如果本地仓库中没有就会从远程中央仓库下载。此时如果不能上网则无法执行Maven的具体功能。为了解决这个问题，我们可以将Maven的本地仓库指向一个在联网情况下下载好的目录。
2) Maven默认的本地仓库：~.m2\repository目录。
Tips：~表示当前用户的家目录。
3) Maven的核心配置文件位置：

  1. 解压目录D:\apache-maven-3.6.3\conf\settings.xml

4) 设置方式

  1. <localRepository>以及准备好的仓库位置</localRepository>
  2. <localRepository>D:\LocalRepository</localRepository>

5) 为了以后下载jar包方便，配置阿里云镜像
将以下标签配置到标签里面

  1. <mirror>
  2.     <id>nexus-aliyun</id>
  3.     <mirrorOf>central</mirrorOf>
  4.     <name>Nexus aliyun</name>
  5.     <url>http://maven.aliyun.com/nexus/content/groups/public</url>
  6. </mirror>

第4章 Maven的核心概念

4.1 核心概念

1) POM
2) 约定的目录结构
3) 插件和目标
4) 生命周期
5) 仓库
6) 坐标
7) 依赖
8) 继承
9) 聚合

4.2 POM

Project Object Model：项目对象模型。将Java工程的相关信息封装为对象作为便于操作和管理的模型。Maven工程的核心配置。可以说学习Maven就是学习pom.xml文件中的配置。

4.3 约定的目录结构

现在JavaEE开发领域普遍认同一个观点：约定>配置>编码。意思就是能用配置解决的问题就不编码，能基于约定的就不进行配置。而Maven正是因为指定了特定文件保存的目录才能够对我们的Java工程进行自动化构建。
目录结构含义参见前面的描述。

4.4 插件和目标

1) Maven的核心仅仅定义了抽象的生命周期，具体的任务都是交由插件完成的。
2) 每个插件都能实现多个功能，每个功能就是一个插件目标。
3) Maven的生命周期与插件目标相互绑定，以完成某个具体的构建任务。
例如：compile就是插件maven-compiler-plugin的一个功能；pre-clean是插件maven-clean-plugin的一个目标。

4.5 生命周期

1) 什么是Maven的生命周期？
Maven生命周期定义了各个构建环节的执行顺序，有了这个清单，Maven就可以自动化的执行构建命令了。
Maven有三套相互独立的生命周期，分别是：
Clean Lifecycle在进行真正的构建之前进行一些清理工作。
Default Lifecycle构建的核心部分，编译，测试，打包，安装，部署等等。
Site Lifecycle生成项目报告，站点，发布站点。
再次强调一下它们是相互独立的，你可以仅仅调用clean来清理工作目录，仅仅调用site来生成站点。当然你也可以直接运行mvn clean install site运行所有这三套生命周期。
每套生命周期都由一组阶段(Phase)组成，我们平时在命令行输入的命令总会对应于一个特定的阶段。比如，运行mvn clean，这个clean是Clean生命周期的一个阶段。有Clean生命周期，也有clean阶段。
2) clean生命周期
Clean生命周期一共包含了三个阶段：
pre-clean 执行一些需要在clean之前完成的工作
clean 移除所有上一次构建生成的文件
post-clean 执行一些需要在clean之后立刻完成的工作
3) Site生命周期
pre-site 执行一些需要在生成站点文档之前完成的工作
site 生成项目的站点文档
post-site 执行一些需要在生成站点文档之后完成的工作，并且为部署做准备
site-deploy 将生成的站点文档部署到特定的服务器上
这里经常用到的是site阶段和site-deploy阶段，用以生成和发布Maven站点，这可是Maven相当强大的功能，Manager比较喜欢，文档及统计数据自动生成，很好看。
4) Default生命周期
Default生命周期是Maven生命周期中最重要的一个，绝大部分工作都发生在这个生命周期中。这里，只解释一些比较重要和常用的阶段：
validate
generate-sources
process-sources
generate-resources
process-resources 复制并处理资源文件，至目标目录，准备打包。
compile编译项目的源代码。
process-classes
generate-test-sources
process-test-sources
generate-test-resources
process-test-resources 复制并处理资源文件，至目标测试目录。
test-compile编译测试源代码。
process-test-classes
test使用合适的单元测试框架运行测试。这些测试代码不会被打包或部署。
prepare-package
package接受编译好的代码，打包成可发布的格式，如JAR。
pre-integration-test
integration-test
post-integration-test
verify
install将包安装至本地仓库，以让其它项目依赖。
deploy将最终的包复制到远程的仓库，以让其它开发人员与项目共享或部署到服务器上运行。

5) 生命周期与自动化构建
运行任何一个阶段的时候，它前面的所有阶段都会被运行，例如我们运行mvn install的时候，代码会被编译，测试，打包。这就是Maven为什么能够自动执行构建过程的各个环节的原因。此外，Maven的插件机制是完全依赖Maven的生命周期的，因此理解生命周期至关重要。

4.6 仓库

1) 分类
① 本地仓库：为当前本机电脑上的所有Maven工程服务。
② 远程仓库
[1] 私服：架设在当前局域网环境下，为当前局域网范围内的所有Maven工程服务。
image.png
[2]中央仓库：架设在Internet上，为全世界所有Maven工程服务。
[3]中央仓库的镜像：架设在各个大洲，为中央仓库分担流量。减轻中央仓库的压力，同时更快的响应用户请求。
1) 仓库中的文件
① Maven的插件
② 我们自己开发的项目的模块
③ 第三方框架或工具的jar包
※不管是什么样的jar包，在仓库中都是按照坐标生成目录结构，所以可以通过统一的方式查询或依赖。

4.7 坐标

1) 几何中的坐标
[1]在一个平面中使用x、y两个向量可以唯一的确定平面中的一个点。
[2]在空间中使用x、y、z三个向量可以唯一的确定空间中的一个点。
2) Maven的坐标
使用如下三个向量在Maven的仓库中唯一的确定一个Maven工程。
[1]groupId：公司或组织的域名倒序+当前项目名称
[2]artifactId：当前项目的模块名称
[3]version：当前模块的版本

  1.     <groupId>com.atguigu.maven</groupId>
  2.     <artifactId>Hello</artifactId>
  3.     <version>1.0-SNAPSHOT</version>

3) 如何通过坐标到仓库中查找jar包？
[1]将gav三个向量连起来(version版本号也是一个坐标！！)

  1. com.atguigu.maven+Hello+1.0-SNAPSHOT

[2]以连起来的字符串作为目录结构到仓库中查找

  1. com/atguigu/maven/Hello/1.0-SNAPSHOT/Hello-1.0-SNAPSHOT.jar

※注意：我们自己的Maven工程必须执行安装操作才会进入仓库。安装的命令是：mvn install

4.8 第二个Maven工程

1) 创建HelloFriend工程
image.png
2) 在pom.xml配置文件中配置当前工程依赖Hello

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>com.atguigu.maven</groupId>
  8.     <artifactId>HelloFriend</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  11.     <dependencies>
  12.         <dependency>
  13.             <groupId>com.atguigu.maven</groupId>
  14.             <artifactId>Hello</artifactId>
  15.             <version>1.0-SNAPSHOT</version>
  16.         </dependency>
  17.         <dependency>
  18.             <groupId>junit</groupId>
  19.             <artifactId>junit</artifactId>
  20.             <version>4.0</version>
  21.             <scope>test</scope>
  22.         </dependency>
  23.     </dependencies>
  25. </project>

3) 主程序
在src/main/java目录下新建文件HelloFriend.java

  1. package com.atguigu.maven;
  3. public class HelloFriend {
  4.     public String sayHelloToFriend(String name){
  5.         Hello hello = new Hello();
  6.         String str = hello.sayHello(name)+" I am "+this.getMyName();
  7.         return str;
  8.     }
  9.     public String getMyName(){
  10.         return "Idea";
  11.     }
  12. }

4) 测试程序
在/src/test/java目录下新建测试文件HelloFriendTest.java

  1. package com.atguigu.maven;
  3. import org.junit.Test;
  5. public class HelloFriendTest {
  6.     @Test
  7.     public void testHelloFriend(){
  8.         HelloFriend helloFriend = new HelloFriend();
  9.         String results = helloFriend.sayHelloToFriend("Maven");
  10.         System.out.println(results);
  11.     }
  13. }

5) 关键：对Hello的依赖
这里Hello就是我们的第一个Maven工程，现在HelloFriend对它有依赖。那么这个依赖能否成功呢？更进一步的问题是：HelloFriend工程会到哪里去找Hello呢？
答案是：本地仓库。任何一个Maven工程会根据坐标到本地仓库中去查找它所依赖的jar包。如果能够找到则可以正常工作，否则就不行。

4.9 依赖管理

1) 基本概念
当A jar包需要用到B jar包中的类时，我们就说A对B有依赖。例如：commons-fileupload-1.3.jar依赖于commons-io-2.0.1.jar。
通过第二个Maven工程我们已经看到，当前工程会到本地仓库中根据坐标查找它所依赖的jar包。
配置的基本形式是使用dependency标签指定目标jar包的坐标。例如：

  1. <dependency>
  2.     <!--坐标-->
  3.     <groupId>junit</groupId>
  4.     <artifactId>junit</artifactId>
  5.     <version>4.0</version>
  6.     <!--依赖的范围-->
  7.     <scope>test</scope>
  8. </dependency>

2) 直接依赖和间接依赖
如果A依赖B，B依赖C，那么A→B和B→C都是直接依赖，而A→C是间接依赖。

4.9.1 依赖的范围

1) compile（默认就是这个范围）
[1]main目录下的Java代码可以访问这个范围的依赖
[2]test目录下的Java代码可以访问这个范围的依赖
[3]部署到Tomcat服务器上运行时要放在WEB-INF的lib目录下
例如：对Hello的依赖。主程序、测试程序和服务器运行时都需要用到。

2) test
[1]main目录下的Java代码不能访问这个范围的依赖
[2]test目录下的Java代码可以访问这个范围的依赖
[3]部署到Tomcat服务器上运行时不会放在WEB-INF的lib目录下
例如：对junit的依赖。仅仅是测试程序部分需要。

3) provided
[1]main目录下的Java代码可以访问这个范围的依赖
[2]test目录下的Java代码可以访问这个范围的依赖
[3]部署到Tomcat服务器上运行时不会放在WEB-INF的lib目录下
例如：servlet-api在服务器上运行时，Servlet容器会提供相关API，所以部署的时候不需要。
4) 其他：runtime、import、system等。
各个依赖范围的作用可以概括为下图：
image.png

4.9.2 依赖的传递性

当存在间接依赖的情况时，主工程对间接依赖的jar可以访问吗？这要看间接依赖的jar包引入时的依赖范围——只有依赖范围为compile时可以访问，即依赖范围是compile时才具有传递性。例如：

Maven工程 依赖范围 对A的可见性
A B C compile √
D test ×
E provided ×

4.9.3 依赖的原则：解决jar包冲突

1) 路径最短者优先
image.png
2) 路径相同时先声明者优先
image.png
这里“声明”的先后顺序指的是dependency标签配置的先后顺序。

4.9.4 依赖的排除

1) 有的时候为了确保程序正确可以将有可能重复的间接依赖排除。请看如下的例子：
假设当前工程为MakeFriend，直接依赖OurFriends。
OurFriends依赖commons-logging的1.1.1对于MakeFriend来说是间接依赖。
当前工程MakeFriend直接依赖commons-logging的1.1.2
加入exclusions配置后可以在依赖OurFriends的时候排除版本为1.1.1的commons-logging的间接依赖

  1. <dependency>
  2.     <groupId>com.atguigu.maven</groupId>
  3.     <artifactId>OurFriends</artifactId>
  4.     <version>1.0-SNAPSHOT</version>
  5.     <!--依赖排除-->
  6.     <exclusions>
  7.         <exclusion>
  8.             <groupId>commons-logging</groupId>
  9.             <artifactId>commons-logging</artifactId>
  10.         </exclusion>
  11.     </exclusions>
  12. </dependency>
  14. <dependency>
  15.     <groupId>commons-logging</groupId>
  16.     <artifactId>commons-logging</artifactId>
  17.     <version>1.1.2</version>
  18. </dependency>

4.9.5 统一管理目标jar包的版本

以对Spring的jar包依赖为例：Spring的每一个版本中都包含spring-context，springmvc等jar包。我们应该导入版本一致的Spring jar包，而不是使用5.3.1的spring-context的同时使用5.3.2的springmvc。

  1. <dependency>
  2.     <groupId>org.springframework</groupId>
  3.     <artifactId>spring-context</artifactId>
  4.     <version>5.3.1</version>
  5. </dependency>
  6. <dependency>
  7.     <groupId>org.springframework</groupId>
  8.     <artifactId>spring-webmvc</artifactId>
  9.     <version>5.3.1</version>
  10. </dependency>
  11. <dependency>
  12.     <groupId>org.springframework</groupId>
  13.     <artifactId>spring-jdbc</artifactId>
  14.     <version>5.3.1</version>
  15. </dependency>
  16. <dependency>
  17.     <groupId>org.springframework</groupId>
  18.     <artifactId>spring-orm</artifactId>
  19.     <version>5.3.1</version>
  20. </dependency>

问题是如果我们想要将这些jar包的版本统一升级为5.3.2，是不是要手动一个个修改呢？显然，我们有统一配置的方式：

  1. <!--统一管理当前模块的jar包的版本-->
  2. <properties>
  3.     <spring.version>5.3.1</spring.version>
  4. </properties>
  6. ……
  8. <dependency>
  9.     <groupId>org.springframework</groupId>
  10.     <artifactId>spring-context</artifactId>
  11.     <version>${spring.version}</version>
  12. </dependency>
  13. <dependency>
  14.     <groupId>org.springframework</groupId>
  15.     <artifactId>spring-webmvc</artifactId>
  16.     <version>${spring.version}</version>
  17. </dependency>
  18. <dependency>
  19.     <groupId>org.springframework</groupId>
  20.     <artifactId>spring-jdbc</artifactId>
  21.     <version>${spring.version}</version>
  22. </dependency>
  23. <dependency>
  24.     <groupId>org.springframework</groupId>
  25.     <artifactId>spring-orm</artifactId>
  26.     <version>${spring.version}</version>
  27. </dependency>

这样一来，进行版本调整的时候只改一改地方就行了。

第5章 继承

5.1 为什么需要继承机制？

由于非compile范围的依赖信息是不能在“依赖链”中传递的，所以有需要的工程只能单独配置(根据上面的内容：父子不可以传递吗？？？)。例如：

Hello <dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
HelloFriend <dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
MakeFriend <dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>

此时如果项目需要将各个模块的junit版本统一为4.9，那么到各个工程中手动修改无疑是非常不可取的。使用继承机制就可以将这样的依赖信息统一提取到父工程模块中进行统一管理。

5.2 创建父工程

  1. 父工程的打包方式为pom
  1. <groupId>com.atguigu.maven</groupId>
  2. <artifactId>Parent</artifactId>
  3. <packaging>pom</packaging>
  4. <version>1.0-SNAPSHOT</version>
  1. 父工程只需要保留pom.xml文件即可

5.3 在子工程中引用父工程



…
…
…
_ ..

  1. <!--继承-->
  2. <parent>
  3.     <groupId>com.atguigu.maven</groupId>
  4.     <artifactId>Parent</artifactId>
  5.     <version>1.0-SNAPSHOT</version>
  6. <!--指定从当前pom.xml文件出发寻找父工程的pom.xml文件的相对路径-->
  7. <relativePath>../Parent/pom.xml</relativePath>
  8. </parent>

此时如果子工程的groupId和version如果和父工程重复则可以删除。

5.4 在父工程中管理依赖

将Parent项目中的dependencies标签，用dependencyManagement标签括起来

  1. <!--依赖管理-->
  2. <dependencyManagement>
  3.     <dependencies>
  4.         <dependency>
  5.             <groupId>junit</groupId>
  6.             <artifactId>junit</artifactId>
  7.             <version>4.0</version>
  8.             <scope>test</scope>
  9.         </dependency>
  10.     </dependencies>
  11. </dependencyManagement>

在子项目中重新指定需要的依赖，删除范围和版本号

  1. <dependency>
  2.     <groupId>junit</groupId>
  3.     <artifactId>junit</artifactId>
  4. </dependency>

第6章 聚合

6.1 为什么要使用聚合？

将多个工程拆分为模块后，需要手动逐个安装到仓库后依赖才能够生效。修改源码后也需要逐个手动进行clean操作。而使用了聚合之后就可以批量进行Maven工程的安装、清理工作。

6.2 如何配置聚合？

在总的聚合工程中使用modules/module标签组合，指定模块工程的相对路径即可

  1. <!--聚合-->
  2. <modules>
  3.     <module>../MakeFriend</module>
  4.     <module>../OurFriends</module>
  5.     <module>../HelloFriend</module>
  6.     <module>../Hello</module>
  7. </modules>

Maven可以根据各个模块的继承和依赖关系自动选择安装的顺序

第7章 通过Maven创建Web工程

7.1 通过Eclipse创建Maven版Web工程

1) 创建简单的Maven工程，打包方式为war包
image.png
2) 创建完成之后因缺少web.xml文件工程出现小红叉
image.png
3) 在工程上右键→Build Path→Configure Build Path…
image.png
4) 点击Project Facets欺骗Eclipse当前工程不是Web工程，点击应用
image.png
5) 再告诉Eclipse当前工程是一个Web工程，点击应用并关闭
image.png
6) 发现MavenWeb工程小红叉消失，并出现了WebContext目录
image.png
7) 在WebContext下创建index.jsp页面并添加Tomcat库
image.png
8) 在MavenWeb上右键→Run As→Run on Server部署到Tomcat上运行

7.2 通过Idea创建Maven版Web工程

1) 创建简单的Maven工程，打包方式为war包

  1. <groupId>com.atguigu.maven</groupId>
  2. <artifactId>MavenWeb</artifactId>
  3. <packaging>war</packaging>
  4. <version>1.0-SNAPSHOT</version>

2) 点击Project Structure
image.png
3) 选择对应的Module，添加web目录
image.png
4) 设置目录名称
image.png
5) 在web目录下创建index.jsp页面
image.png
6) 部署到Tomcat上运行

第8章 Maven酷站

我们可以到http://mvnrepository.com或http://search.maven.org
搜索需要的jar包的依赖信息。