Maven简介

image.png

官网：http://maven.apache.org/

软件是一个工程

我们在日常生活常能听到工程这个词，像桥梁工程、道路工程、南水北调工程等等。

工程说简单点就是各个行业的从业人员通过总结规律或者方法，以最短的时间和人力、物力来做出高效可靠的东西。我们也就能理解桥梁工程，其实就是人们通过经验的总结和各种研究得出来的、用来修建桥梁时所采用的高效的方法，当然这种方法是可复用的。我们将这种作工程的思想应用到软件上，于是就产生了—软件工程。

软件工程：为了能够实现软件的流水线式生产，在设计和构建软件时能够有一种规范和工程化的方法，人们便提出了软件工程概念。

上面的内容做个日常生活的类比，做道菜就是一个工程。今天心情好，想吃红烧肉，自动动手做：
1.想买什么猪的那个位置的肉，黑猪肉，土猪肉等，使用冰糖还是绵白糖，用什么牌子的酱油等
2.到菜市场购买各种原料。
3.准备材料，洗肉，切块，花椒，大料等
4.开始做了，肉下锅炖煮，不同时间加入花椒，大料，冰糖，酱油
5.炖煮一段时间后，看肉是否熟透，尝试口味，是不是咸了等等
6.做好了，开始吃了
7.需要刷碗，倒垃圾

这些工作从头做到尾步骤非常繁琐，每个步骤都是费时费力的。所以才出现净菜，半成品菜，拿回家直接做可以了，只做 6,7 步骤就可以 。

软件开发需要编译代码—>开发人员自己测试代码—>把代码打包—>部署项目到测试服务器—>测试人员测试功能—>测试测试出 bug

开发人员需要修改bug—>开发人员自己测试代码—>把代码打包—>部署项目到测试服务器—>测试人员测试功能—>直到符合功能要求。

上述过程需要重复多次，大型项目中构建项目比较复杂，有很多的配置文件，jar 文件，多个子项目等等。都用人力完成费时费力，效率比较低。maven 可以让我们从上面的工作中解脱出来。

maven 是自动化构建工具。

传统项目开发存在的问题

一个项目做成一个工程，造成工程比较庞大，需要使用多模块来划分项目；
项目中需要的数量众多的 jar 包，需要手动下载并引入，并且多个项目需要的 jar 包存在重复的问题；
项目中需要的 jar 包有版本兼容的问题，需要手动解决；
项目中需要的 jar 包又依赖其它的 jar 包，需要手动解决。

Maven 概述

Maven 是 Apache 软件基金会组织维护的一款自动化构建工具，专注服务于 Java 平台的项目构建和依赖管理。Maven 这个单词的本意是：专家，内行。读音是['meɪv(ə)n]或['mevn]。

Maven 是目前最流行的自动化构建工具，对于生产环境下多框架、多模块整合开发有重要作用，Maven 是一款在大型项目开发过程中不可或缺的重要工具。

Maven 可以整合多个项目之间的引用关系，我们可以根据业务和分层需要任意拆分一个项目；
Maven 提供规范的管理各个常用 jar 包及其各个版本，并且可以自动下载和引入项目中；
Maven 可以根据指定版本自动解决 jar 包版本兼容问题；
Maven 可以把 jar 包所依赖的其它 jar 包自动下载并引入项目。
类似自动化构建工具还有：Ant, Maven, Gradle。

构建过程中的各个环节：清理、编译、测试、报告、打包、安装、部署。

构建（build），是面向过程的(从开始到结尾的多个步骤)，涉及到多个环节的协同工作。

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

Maven 核心概念

Maven能够实现自动化构建是和它的内部原理分不开的，这里我们从 Maven的九个核心概念入手，看看Maven是如何实现自动化构建的

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

安装 Maven 环境

1、 确保安装了 java 环境:maven 本身就是 java 写的，所以要求必须安装 JDK。
查看 java 环境变量：echo %JAVA_HOME%

2、 下载并解压 maven 安装程序：
http://maven.apache.org/download.cgi

3、 配置 Maven 的环境变量：
MAVEN_HOME=d:/apache-maven-3.3.9 或者 M2_HOME=d:/apache-maven-3.3.9
path=%MAVEN_HOME%/bin; 或者%M2_HOME%/bin;

4、验证是否安装成功:
mvn –v

Maven 的核心概念:

Maven 工程约定目录结构

目录结构.png

说明：
Hello:根目录，也就是工程名
src：源代码
main：主程序
java：主程序的 java 源码
resources：主程序的配置文件
test：测试程序
java：测试程序的 java 源码
resources：测试程序的配置文件
pom.xml：Maven 工程的核心配置文件。

一般情况下，我们习惯上采取的措施是：约定>配置>编码

maven 的 pom.xml 记录的关于构建项目的各个方面的设置，maven 从 pom.xml 文件开始，按照助约定的工程目录编译，测试，打包，部署，发布项目。

第一个 maven 工程

按照如下步骤，实现第一个 maven 项目，以 maven 推荐的约定方式创建目录，类文件。
1.某个目录中创建文件夹 Hello
2.在 Hello 中创建子目录 src
3.拷贝 pom.xml 到 Hello 目录和 src 是同级放置的。
4.进入 src 目录，创建 main， test 目录
5.进入 main 目录，创建 java，resources 目录。
6.进入 java 目录，创建目录 com/bjpowernode/
6.在 com/bjpowernode/目录下创建 HelloMaven.java 文件，定义 int addNumber(int n1,n2){ return n1+n2};
定义 public static void main(String args[]) { System.out.prinltn(“Hello Manven”); //也可以调用 addNumber()方法 }
7.进入到 Hello 目录在，执行 mvn compile
8.进入到 target/classes 目录执行 java com.bjpowernode.HelloMaven

POM 文件

即 Project Object Model 项目对象模型。Maven 把一个项目的结构和内容抽象成一个模型，在 xml 文件中进行声明，以方便进行构建和描述，pom.xml 是 Maven 的灵魂。所以，maven 环境搭建好之后，所有的学习和操作都是关于 pom.xml 的。

pom.xml 初识：

image.png

image.png

仓库

仓库的概念

现在我们对maven工程有一个大概的认识了，那现在思考一个问题，maven怎么就这么神奇，我们写完的工程交给他之后，他就能够自动帮我们管理，我们依赖的jar包它从哪儿获取呢？有同学说已经安装了，在它的安装包里啊，大家可以看一下maven下载下来才8M，我们需要的jar包有时候都几百兆甚至几个G，它从哪儿弄去呢？其实，maven有仓库的概念。在Maven中，任何一个依赖、插件或者项目构建的输出，都可以称之为构件。Maven
核心程序仅仅定义了自动化构建项目的生命周期，但具体的构建工作是由特定的构件完成的。而且为了提高构建的效率和构件复用，maven把所有的构件统一存储在某一个位置，这个位置就叫做仓库。

仓库存什么

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

1. Maven 的插件，插件也是一些 jar，这些 jar 可以完成一定的功能。
   2.我们自己开发项目的模块
   3.第三方框架或工具的 jar 包

仓库的类别

根据仓库存储的位置，把仓库分为本地仓库和远程仓库。

本地仓库，存在于当前电脑上,默认存放在~.m2\repository中,为本机上所有的Maven工程服务。你也可以通过Maven的配置文件Maven_home/conf/settings.xml中修改本地仓库所在的目录。

~ 是用户的主目录，windows系统中是 c：/user/登录系统的用户名

远程仓库，分为为全世界范围内的开发人员提供服务的中央仓库、为全世界范围内某些特定的用户提供服务的中央仓库镜像、为本公司提供服务自己架设的私服。中央仓库是maven默认的远程仓库，其地址是:http://repo.maven.apache.org/maven2/

中央仓库，包含了绝大多数流行的开源Java构件，以及源码、作者信息、许可证信息等。一般来说，简单的Java项目依赖的构件都可以在这里下载得到。

私服是一种特殊的远程仓库，它是架设在局域网内的仓库服务，私服代理广域网上的远程仓库，供局域网内的Maven用户使用。当Maven需要下载构件的时候，它从私服请求，如果私服上不存在该构件，则从外部的远程仓库下载，缓存在私服上之后，再为Maven的下载请求提供服务。我们还可以把一些无法从外部仓库下载到的构件上传到私服上。

分类说明：
1）本地仓库：本机当前电脑上的资源存储位置，为本机上所有 Maven工程提供服务
2）远程仓库：不在本机上， 通过网络才能使用。多电脑共享使用的。

①：中央仓库：通过Internet访问，为全世界所有 Maven工程服务。 最权威的。
②：中央仓库的镜像：架设在不同位置，欧洲，美洲，亚洲等每个洲都有若干的服务器，为中央仓库分担流量。减轻中央仓库的访问，下载的压力。所在洲的用户首先访问的是本洲的镜像服务器。
③：私服：在局域网环境中部署的服务器，为当前局域网范围内的所有 Maven工程服务。公司中常常使用这种方式。

image.png

Maven 对仓库的使用

在 Maven 构建项目的过程中如果需要某些插件，首先会到 Maven 的本地仓库中查找，如果找到则可以直接使用；如果找不到，它会自动连接外网，到远程中央仓库中查找；如果远程仓库中能找到，则先把所需要的插件下载到本地仓库，然后再使用，并且下次再用到相同的插件也可以直接使用本地仓库的；如果没有外网或者远程仓库中也找不到，则构建失败。

资源搜索地址：https://mvnrepository.com/

Maven 的生命周期

对项目的构建是建立在生命周期模型上的，它明确定义项目生命周期各个阶段，并且对于每一个阶段提供相对应的命令，对开发者而言仅仅需要掌握一小堆的命令就可以完成项目各个阶段的构建工作。

构建项目时按照生命周期顺序构建，每一个阶段都有特定的插件来完成。不论现在要执行生命周期中的哪个阶段，都是从这个生命周期的最初阶段开始的。

对于我们程序员而言，无论我们要进行哪个阶段的构建，直接执行相应的命令即可，无需担心它前边阶段是否构建，Maven 都会自动构建。这也就是 Maven 这种自动化构建工具给我们带来的好处。

Maven 的常用命令

Maven 对所有的功能都提供相对应的命令，要想知道 maven 都有哪些命令，那要看 maven 有哪些功能。

一开始就跟大家说了，maven 三大功能：管理依赖、构建项目、管理项目信息。管理依赖，只需要声明就可以自动到仓库下载；管理项目信息其实就是生成一个站点文档，一个命令就可以解决，最后再说；那 maven 功能的主体其实就是项目构建。

Maven 提供一个项目构建的模型，把编译、测试、打包、部署等都对应成一个个的生命周期阶段，并对每一个阶段提供相应的命令，程序员只需要掌握一小堆命令，就可以完成项目的构建过程。

mvn clean 清理(会删除原来编译和测试的目录，即 target 目录，但是已经 install 到仓库里的包不会删除)
mvn compile 编译主程序(会在当前目录下生成一个 target,里边存放编译主程序之后生成的字节码文件)
mvn test-compile
编译测试程序(会在当前目录下生成一个 target,里边存放编译测试程序之后生成的字节码文件)
mvn test 测试(会生成一个目录surefire-reports，保存测试结果)
mvn package
打包主程序(会编译、编译测试、测试、并且按照 pom.xml 配置把主程序打包生成 jar 包或者 war 包)
mvn install 安装主程序(会把本工程打包，并且按照本工程的坐标保存到本地仓库中)
mvn deploy 部署主程序(会把本工程打包，按照本工程的坐标保存到本地库中，并且还会保存到私服仓库中。
还会自动把项目部署到 web 容器中)。

注意：执行以上命令必须在命令行进入 pom.xml 所在目录！

练习 maven 命令

以第一个 maven 项目为例，进入到 Hello 目录中执行 maven 各种命令
1.准备工作，pom.xml 添加依赖

<dependencies>
   <!-- 单元测试 -->
   <dependency>
     <groupId>junit</groupId>
     <artifactId>junit</artifactId>
     <version>4.11</version>
   </dependency>
</dependencies>

2.在 Hello/src/test/目录下创建 java ， resources 目录
3.在 Hello/src/test/java 目录下，创建 com/bjpowernode/目录

4. 在 com/bjpowernode/目录中创建 MyTest.java 文件

导入类：
import org.junit.Assert;
import org.junit.Test;

定义方法

public class MyTest {
   @Test
   public void testAddNumber(){
     System.out.println("执行 HelloMaven 类 addNumber()方法");
     int n1 = 10;
     int n2 = 20;
     int res = 0;
     HelloMaven hello =new HelloMaven();
     res = hello.addNumber(n1,n2);
     // 期望值，实际值
     Assert.assertEquals(30,res);
   } 
}

5.执行先执行 mvn compile ,观察目录结构的变化，生成 target 目录
6.在执行 mvn clean， 观察 taget 目录被清除
7.执行 mvn compile
8.进入 taget/classes 目录执行 java com.bjpowernode.HelloMaven
9.进入 Hello 目录，执行 mvn test-compile 生成 test-target 测试编译后的目录

10. 进入 Hello 目录，执行 mvn test 执行 MyTest 类中方法，生成测试报告
    11.进入目录 surefire-reports，查看测试报告
    12.修改 MyTest.java, 增加测试方法

   @Test
   public void testAddNumber2(){
     System.out.println("执行 HelloMaven 类 addNumber()方法");
     int n1 = 20;
     int n2 = 30;
     int res = 0;
     HelloMaven hello =new HelloMaven();
     res = hello.addNumber(n1,n2);
     // 期望值，实际值
     Assert.assertEquals(60,res);
}

13. 进入 Hello 目录，执行 mvn test-compile
14. 进入 Hello 目录，执行 mvn test
15. 修改 testAddNumber2()方法中 60 为 50 16. 进入 Hello 目录，执行 mvn package ，生成 xxx.jar 文件，这就是所说的打包
16. 进入 Hello 目录，执行 mvn install ， 把 xxx.jar 文件安装到本地 maven 仓库，安装成功后查看仓库中的 jar 文 件

插件

maven 过程构建周期，由 maven 的插件 plugin 来执行完成。

官网插件说明：http://maven.apache.org/plugins/
在项目根目录下执：mvn clean install

image.png

解释说明

clean 插件 maven-clean-plugin:2.5
clean 阶段是独立的一个阶段，功能就是清除工程目前下的 target 目录

resources 插件 maven-resources-plugin:2.6
resource 插件的功能就是把项目需要的配置文件拷贝到指定的目当，默认是拷贝 src\main\resources 目录下的件到classes 目录下

compile 插件 maven-compiler-plugin
compile 插件执行时先调用 resouces 插件，功能就是把 src\mainjava 源码编译成字节码生成 class 文件，并把编译好的 class 文件输出到 target\classes 目录下

test 测试插件
单元测试所用的 compile 和 resources 插件和主代码是相同的，但执行的目标不行，目标 testCompile 和 testResources是把 src\test\java 下的代码编译成字节码输出到 target\test-classes，同时把 src\test\resources 下的配置文件拷贝到target\test-classes

package 打包插件 maven-jar-plugin
这个插件是把 class 文件、配置文件打成一个 jar(war 或其它格式)包

deploy 发布插件 maven-install-plugin
发布插件的功能就是把构建好的 artifact 部署到本地仓库，还有一个 deploy 插件是将构建好的 artifact 部署到远程仓库

常用插件

插件可以在自己的项目中设置，最常使用的是 maven 编译插件。设置项目使用的 jdk 版本时通过编译插件指定。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> 
         <target>1.8</target> 
       </configuration> 
     </plugin> 
   </plugins> 
</build>

坐标(gav)

Maven 把任何一个插件都作为仓库中的一个项目进行管理，用一组(三个)向量组成的坐标来表示。坐标在仓库中可以唯一定位一个 Maven 项目。

groupId：组织名，通常是公司或组织域名倒序+项目名
artifactId：模块名，通常是工程名
version：版本号

需要特别指出的是，项目在仓库中的位置是由坐标来决定的：groupId、artifactId 和 version 决定项目在仓库中的路径，artifactId 和 version 决定 jar 包的名称。

依赖(dependency)

一个 Maven 项目正常运行需要其它项目的支持，Maven 会根据坐标自动到本地仓库中进行查找。对于程序员自己的 Maven 项目需要进行安装，才能保存到仓库中。

不用 maven 的时候所有的 jar 都不是你的，需要去各个地方下载拷贝，用了 maven 所有的 jar 包都是你的，想要谁，叫谁的名字就行。maven 帮你下载。

pom.xml 加入依赖的方式：

log4j 日志依赖

<dependency>
   <groupId>log4j</groupId>
   <artifactId>log4j</artifactId>
   <version>1.2.17</version>
</dependency>

junit 单元测试依赖

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

Maven 在 IDEA 中的应用

IDEA 集成 Maven
File---->Settings：设置 maven 安装主目录、maven 的 settings.xml 文件和本地仓库所在位置。

image.png

IDEA 创建 Maven 版 java 工程:

创建 maven 版 java 工程
File-->New-->Module…：

image.png

填写 maven 工程的坐标

image.png

填写工程名和存储路径

image.png

pom.xml 加入依赖

<dependency>
   <groupId>log4j</groupId>
   <artifactId>log4j</artifactId>
   <version>1.2.17</version>
 </dependency>

创建后视图

image.png

image.png

创建测试类

image.png

输出一条语句，测试项目构建成功。

IDEA 创建 Maven 版 web 工程

创建 Maven 版 web 工程
File-->New-->Module…：

image.png

设置 module 信息

image.png

设置所使用的 maven：

image.png

这个窗口基本上不用修改什么，但是这样会比较慢，有时候如果网速不好，就会卡的比较久，这是因为maven 这个骨架会从远程仓库加载 archetype 元数据，但是 archetype 又比较多，所以比较卡，这时候可以加个属性 -DarchetypeCatelog = internal，表示仅使用内部元数据：

image.png

填写 maven 工程名称和存储路径

image.png

由于要运行 archetype 程序，所以这个过程需要几分钟的时间，当控制台出现” BUILD SUCCESS”时，表示工程创建完成。

创建后视图

image.png

显然，按照 maven archetype 原型创建的 maven web 工程缺少 maven 项目的完整结构：src-main-java / resources，src-test-java/resources，所以需要我们手动添加文件目录。

创建缺省文件夹
src-main-java / resources，src-test-java/resources

image.png

把文件夹标识为源码文件夹
File -> Project Structure, 选择Modules：右边找到java这层机构，在上面有个“Mask as”, 点下Sources，表示这里面是源代码类。

image.png

pom.xml 添加依赖

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

编写测试类 HelloWorld 和测试页面 index.jsp

IDEA 中导入 Maven 工程(module)

新建一个空的 project 作为工作空间

在项目结构中导入或移除 module
File-->Project Structure…

image.png

选择要导入的 Module：

image.png

选择导入方式

image.png

选择要导入的项目

image.png

选择要导入的 maven 工程

image.png

设置导入 module 所使用的 JDK

image.png

导入后项目结构

image.png

导入后视图

image.png

依赖管理

依赖的范围

依赖的范围：compile、test、provided，默认采用 compile

image.png

Maven 常用设置

全局变量

在 Maven 的 pom.xml 文件中，<properties>用于定义全局变量，POM 中通过${property_name}的形式引用变量的值。

定义全局变量：

<properties>
   <spring.version>4.3.10.RELEASE</spring.version>
</properties>

引用全局变量：

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

Maven 系统采用的变量：

<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>

指定资源位置

src/main/java 和 src/test/java 这两个目录中的所有*.java 文件会分别在 comile 和 test-comiple 阶段被编译，编译结果分别放到了 target/classes 和 targe/test-classes 目录中，但是这两个目录中的其他文件都会被忽略掉，如果需要把 src 目录下的文件包放到 target/classes 目录，作为输出的 jar 一部分。需要指定资源文件位置。以下内容放到<buid>标签中。

<build>
    <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>

总结maven

第一部分

完成一个java项目，需要做哪些工作
1.分析项目要做什么，知道项目有哪些组成部分。
2.设计项目，通过哪些步骤，使用哪些技术。需要多少人， 多长的时间。
3.组建团队，招人， 购置设备，服务器， 软件， 笔记本。
4.开发人员写代码。 开发人员需要测试自己写代码。 重复多次的工作。
5.测试人员，测试项目功能是否符合要求。
测试开发人员提交代码-如果测试有问题--需要开发人员修改--在提交代码给测试--测试人员在测试代码-如果还有问题-在交给开发人员-开发人员在提交-在测试
直到-测试代码通过。

2.传统开发项目的问题，没有使用maven【meivn】管理的项目
1）很多模块，模块之间有关系， 手工管理关系，比较繁琐。
2）需要很多第三方功能， 需要很多jar文件，需要手工从网络中获取各个jar
3）需要管理jar的版本， 你需要的是mysql.5.1.5.jar 拿你不能给给一个mysql.4.0.jar
4）管理jar文件之间的依赖， 你的项目要使用a.jar 需要使用b.jar里面的类。
必须首先获取到b.jar才可以， 然后才能使用a.jar.

a.jar需要b.jar这个关系叫做依赖， 或者你的项目中要使用mysql的驱动， 也可以叫做项目依赖mysql驱动。
a.class使用b.class， a依赖b类

3.需要改进项目的开发和管理，需要maven
1）maven可以管理jar文件
2）自动下载jar和他的文档，源代码
3）管理jar直接的依赖， a.jar需要b.jar ， maven会自动下载b.jar
4）管理你需要的jar版本
5）帮你编译程序，把java编译为class
6）帮你测试你的代码是否正确。
7）帮你打包文件，形成jar文件，或者war文件
8）帮你部署项目

4.构建： 项目的构建。
构建是面向过程的，就是一些步骤，完成项目代码的编译，测试，运行，打包，部署等等。
maven支持的构建包括有：
1）.清理， 把之前项目编译的东西删除掉，我新的编译代码做准备。
2）.编译， 把程序源代码编译为执行代码， java-class文件
批量的，maven可以同时把成千上百的文件编译为class。
与javac 不一样，javac一次编译一个文件。
3）.测试， maven可以执行测试程序代码，验证你的功能是否正确。
批量的，maven同时执行多个测试代码，同时测试很多功能。
4）.报告， 生成测试结果的文件， 测试通过没有。
5）.打包， 把你的项目中所有的class文件，配置文件等所有资源放到一个压缩文件中。
这个压缩文件就是项目的结果文件， 通常java程序，压缩文件是jar扩展名的。
对于web应用，压缩文件扩展名是.war
6）.安装， 把5中生成的文件jar，war安装到本机仓库
7）.部署， 把程序安装好可以执行。

5.maven核心概念： 用好maven，了解这些概念
①POM ： 一个文件 名称是pom.xml , pom翻译过来叫做项目对象模型。
maven把一个项目当做一个模型使用。控制maven构建项目的过程，管理jar依赖。

②约定的目录结构 ： maven项目的目录和文件的位置都是规定的。

③坐标 ： 是一个唯一的字符串，用来表示资源的。

④依赖管理 ： 管理你的项目可以使用jar文件

⑤仓库管理（了解） ：你的资源存放的位置

⑥生命周期 (了解) ： maven工具构建项目的过程，就是生命周期。
⑦插件和目标（了解）：执行maven构建的时候用的工具是插件
⑧继承
⑨聚合

讲maven的使用，先难后易的。 难是说使用maven的命令，完成maven使用 ， 在idea中直接使用maven，代替命令。

6.maven工具的安装和配置。
1）需要从maven的官网下载maven的安装包 apache-maven-3.3.9-bin.zip
2）解压安装包，解压到一个目录，非中文目录。
子目录 bin :执行程序，主要是mvn.cmd
conf :maven工具本身的配置文件 settings.xml
3）配置环境变量
在系统的环境变量中，指定一个M2_HOME的名称， 指定它的值是maven工具安装目录，bin之前的目录

M2_HOME=D:\work\maven_work\apache-maven-3.3.9

再把M2_HOME加入到path之中，在所有路径之前加入%M2_HOME%\bin;

4）验证，新的命令行中，执行mvn -v

注意：需要配置JAVA_HOME ，指定jdk路径

C:\Users\Administrator>mvn -v
出现如下内容，maven安装，配置正确。

    Apache Maven 3.3.9 (bb52d8502b132ec0a5a3f4c09453c07478323dc5; 2015-11-11T00:41:4
    Maven home: D:\work\maven_work\apache-maven-3.3.9
    Java version: 1.8.0_40, vendor: Oracle Corporation
    Java home: C:\java\JDK8-64\jre
    Default locale: zh_CN, platform encoding: GBK
    OS name: "windows 7", version: "6.1", arch: "amd64", family: "dos"

第二部分

1.maven约定的目录结构， 约定是大家都遵循的一个规则。

每一个maven项目在磁盘中都是一个文件夹（项目-Hello）
Hello/
---/src
------/main #放你主程序java代码和配置文件
----------/java #你的程序包和包中的java文件
----------/resources #你的java程序中要使用的配置文件

------/test #放测试程序代码和文件的（可以没有）
----------/java #测试程序包和包中的java文件
----------/resources #测试java程序中要使用的配置文件

---/pom.xml #maven的核心文件（maven项目必须有）

2.疑问： mvn compile 编译src/main目录下的所有java文件的。
1）为什么要下载
maven工具执行的操作需要很多插件（java类--jar文件）完成的
2）下载什么东西了
jar文件--叫做插件--插件是完成某些功能

3）下载的东西存放到哪里了。
默认仓库（本机仓库）：
C:\Users\（登录操作系统的用户名）Administrator.m2\repository

https://repo.maven.apache.org ：中央仓库的地址

执行mvn compile， 结果是在项目的根目录下生成target目录（结果目录），maven编译的java程序，最后的class文件都放在target目录中

设置本机存放资源的目录位置(设置本机仓库)：

1. 修改maven的配置文件， maven安装目录/conf/settings.xml
   先备份 settings.xml

2. 修改 <localRepository> 指定你的目录（不要使用中文目录）

D:\work\maven_work\maven_repository

3.仓库
1）仓库是什么： 仓库是存放东西的， 存放maven使用的jar 和 我们项目使用的jar

maven使用的插件（各种jar）
我项目使用的jar(第三方的工具)

2）仓库的分类

本地仓库， 就是你的个人计算机上的文件夹，存放各种jar
远程仓库， 在互联网上的，使用网络才能使用的仓库
①：中央仓库，最权威的， 所有的开发人员都共享使用的一个集中的仓库，https://repo.maven.apache.org ：中央仓库的地址
②：中央仓库的镜像：就是中央仓库的备份， 在各大洲，重要的城市都是镜像。
③：私服，在公司内部，在局域网中使用的， 不是对外使用的。

3）仓库的使用，maven仓库的使用不需要人为参与。

开发人员需要使用mysql驱动--->maven首先查本地仓库--->私服--->镜像--->中央仓库

4.pom:项目对象模型，是一个pom.xml文件
1）坐标：唯一值， 在互联网中唯一标识一个项目的

<groupId>公司域名的倒写</groupId>
<artifactId>自定义项目名称</artifactId>
<version>自定版本号</version>

https://mvnrepository.com/ 搜索使用的中央仓库， 使用groupId 或者 artifactId作为搜索条件

2） packaging： 打包后压缩文件的扩展名，默认是jar ，web应用是war
packaging 可以不写， 默认是jar

3. 依赖
   dependencies 和dependency ，相当于是 java代码中import

你的项目中要使用的各种资源说明， 比我的项目要使用mysql驱动

      <dependencies>
            <!--依赖  java代码中 import -->
          <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.9</version>
         </dependency>

     </dependencies>

4）properties：设置属性

5）build ： maven在进行项目的构建时， 配置信息，例如指定编译java代码使用的jdk的版本等

5.maven生命周期， maven的命令，maven的插件
maven的生命周期：就是maven构建项目的过程，清理，编译，测试，报告，打包，安装，部署
maven的命令：maven独立使用，通过命令，完成maven的生命周期的执行。
maven可以使用命令，完成项目的清理，编译，测试等等

maven的插件： maven命令执行时，真正完成功能的是插件，插件就是一些jar文件， 一些类。

1）单元测试（测试方法）：用的是junit， junit是一个专门测试的框架（工具）。
junit测试的内容： 测试的是类中的方法， 每一个方法都是独立测试的。
方法是测试的基本单位（单元）。

maven借助单元测试，批量的测试你类中的大量方法是否符合预期的。

2）使用步骤
1.加入依赖，在pom.xml加入单元测试依赖

         <!-- 单元测试 -->
         <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

2.在maven项目中的src/test/java目录下，创建测试程序。
推荐的创建类和方法的提示：
1).测试类的名称 是Test + 你要测试的类名
2).测试的方法名称 是：Test + 方法名称

例如你要测试HelloMaven ,
创建测试类 TestHelloMaven

       @Test
         public void testAdd(){
          测试HelloMaven的add方法是否正确
         }

其中testAdd叫做测试方法，它的定义规则
1.方法是public的，必须的
2.方法没有返回值， 必须的
3.方法名称是自定义的，推荐是Test + 方法名称
4.在方法的上面加入 @Test

3)mvn compile
编译main/java/目录下的java 为class文件， 同时把class拷贝到 target/classes目录下面
把main/resources目录下的所有文件 都拷贝到target/classes目录下

第三部分：
1.在idea中设置maven ，让idea和maven结合使用。
idea中内置了maven ，一般不使用内置的， 因为用内置修改maven的设置不方便。
使用自己安装的maven， 需要覆盖idea中的默认的设置。让idea指定maven安装位置等信息

配置的入口
①：配置当前工程的设置， file--settings ---Build, Excution,Deployment--Build Tools--Maven

Maven Home directory: maven的安装目录
User Settings File : 就是maven安装目录conf/setting.xml配置文件
Local Repository : 本机仓库的目录位置

--Build Tools--Maven--Runner
VM Options : -DarchetypeCatalog=internal
RE: 你项目的jdk

-DarchetypeCatalog=internal , maven项目创建时，会联网下载模版文件，比较大， 使用-DarchetypeCatalog=internal，不用下载， 创建maven项目速度快。

②：配置以后新建工程的设置， file--other settings--Settings for New Project

2.使用模版创建项目
1）maven-archetype-quickstart : 普通的java项目
2）maven-archetype-webapp : web工程

第四部分
1依赖范围， 使用scope表示的。
scope的值有 compile, test, provided ,默认是compile
scope:表示依赖使用的范围，也就是在maven构建项目的那些阶段中起作用。
maven构建项目 编译， 测试 ，打包， 安装 ，部署 过程（阶段）

junit的依赖范围是 test

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

    <dependency>
      <groupId>a</groupId>
      <artifactId>b</artifactId>   
      <version>4.11</version>
    </dependency>

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

你在写项目的中的用到的所有依赖（jar ） ，必须在本地仓库中有。
没有必须通过maven下载， 包括provided的都必须下载。

你在servlet需要继承HttpServlet( provided) , 你使用的HttpServlet是maven仓库中的。

当你的写好的程序， 放到 tomat服务器中运行时， 此时你的程序中不包含servlet的jar,因为tomcat提供了 servlet的.jar

第五部分：
maven常用操作
1.maven的属性设置
<properties> 设置maven的常用属性
2.maven的全局变量
自定义的属性，
1).在<properties> 通过自定义标签声明变量（标签名就是变量名）
2).在pom.xml文件中的其它位置，使用 ${标签名} 使用变量的值

自定义全局变量一般是定义 依赖的版本号， 当你的项目中要使用多个相同的版本号，先使用全局变量定义， 在使用${变量名}

3.资源插件

  <build>
    <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>

作用： mybatis中会用到这个作用

1. 默认没有使用resources的时候， maven执行编译代码时， 会把src/main/resource目录中的文件拷贝到target/classes目录中。

思维导图.png