1、背景
1.1 软件是一个工程
我们在日常生活常能听到工程这个词,像桥梁工程、道路工程、南水北调工程等等。
工程说简单点就是各个行业的从业人员通过总结规律或者方法,以最短的时间和人力、物力来做出高效可靠的东西。我们也就能理解桥梁工程,其实就是人们通过经验的总结和各种研究得出来的、用来修建桥梁时所采用的高效的方法,当然这种方法是可复用的。我们将这种作工程的思想应用到软件上,于是就产生了一软件工程。
软件工程:为了能够实现软件的流水线式生产,在设计和构建软件时能够有一种规范和工程化的方法,人们便提出了软件工程概念。
1.2 完成一个java项目，需要做的工作
（1）分析项目要做什么,知道项目有哪些组成部分。
（2）设计项目,通过哪些步骤,使用哪些技术.需要多少人,多长的时间.
（3）组建团队,招人, 购置设备,服务器, 软件,笔记本..
（4）开发人员写代码。开发人员需要测试自己写代码。重复多次的工作.
（5）测试人员,测试项目功能是否符合要求.测试开发人员提交代码-如果测试有问题-需要开发人员修改–再提交代码给测试–测试人员再测试代码-如果还有问题-再交给开发人员-开发人员再提交-再测试直到-测试代码通过. （多次重复的工作.）
1.3 在没有maven之前，开发一个java项目会遇到的问题
（1）很多模块,模块之间有关系, 手工管理关系,比较繁琐
（2）需要很多第三方功能,需要很多jar文件,需要手工从网络中获取各个jar
（3）需要管理jar的版本, 你需要的是mysgl .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类
1.4 为了改进项目的开发和管理，maven应运而生
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）帮你部署项目 （构建）
总结：maven帮忙完成费时费力又麻烦的重复性工作，程序员就可以专心写功能型代码了。
2、maven 构建 项目的构建
构建是面向过程的,就是一些步骤,完成项目代码的编译,测试,运行,打包,部署等等.maven支持的构建包括有:
（1）清理, 把之前项目编译的东西删除掉,为新的编译代码做准备。
（2）编译, 把程序源代码编译为执行代码, 批量将.Java文件变成.class文件, maven可以同时把成千上百的.java文件编译为.class.（传统的javac一次只能编译一个文件）
编译方法：maven工程所在的根目录下，启动cmd（直接windows文件目录那里输入cmd），然后输入命令 mvn compile
（3）测试, maven可以执行测试程序代码,验证你的功能是否正确。maven同时批量执行多个测试代码,同时测试很多功能（传统的测试一次只能测试一个类，那要测试多久才能测试完啊）
（4）报告, 生成测试结果的文件, 告知测试是否通过。
（5）打包, 把你的项目中所有的class文件,配置文件等所有资源放到一个压缩文件中。这个压缩文件就是项目的结果文件,通常Java程序,压缩文件是Jar扩展名的.对于web应用,压缩文件扩展名是.war
（6）安装, 把（5）中生成的文件jar, war安装到本机仓库中
（7）部署， 把程序安装好可以执行。 （一般不用maven部署）
说明：开发中主要做1-6，不用maven部署，maven部署更复杂
3、maven的安装和配置
（1）从maven的官网下载maven的安装包apache-maven-x.x.x-bin.zip
（2）解压安装包,解压到一个目录,非中文目录.
子目录bin :里面有maven执行程序,主要是mvn.cmd
子目录conf :里面有maven工具本身的配置文件settings .xml
（3）配置环境变量在系统的环境变量中,指定一个M2_HOME的名称, 指定它的值是maven工具安装目录,（bin之前的目录)
M2 HOME=安装目录 。再把M2_HOME加入到path之中,在所有路径之前加入%M2_HOME%\bin;4)验证,新的命令行中,执行mvn-v
4、maven 核心概念 （maven中的术语）
（1）POM Project Object Module 项目对象模型
一个文件名，名称是pom.xml，该文件控制maven构建项目的过程，管理jar依赖
（2）约定的目录结构
maven项目的目录和文件位置都是有规定的，不能随便乱放
（3）坐标（gav）
Maven把任何一个插件都作为仓库中的一个项目进行管理,用一组(三个)向量组成的坐标来表示。坐标在仓库中可以唯一定位一个Maven项目。
groupld:组织名,通常是公司或组织域名倒序+项目名
artifactld:模块名,通常是工程名
version：版本号
需要特别指出的是,项目在仓库中的位置是由坐标来决定的、groupld, artifactid和version决定项目在仓库中的路径（groupId对应的包路径/模块名/版本号/jar包）, artifactid和version决定jar包的名称。
进入POM.xml文件，对坐标进行配置。
（4）依赖管理
用于管理项目中可以使用的jar文件
（5）仓库管理（了解即可）
资源存放的位置
（6）生命周期（了解即可）
maven构建项目的过程，就是生命周期。即完成清理、编译,测试,运行、打包等
（7）插件和目标（了解即可）
执行maven构建的相关命令时，比如清理，编译、打包等命令，实际是插件在运作。插件就是Maven的功能类。
（8）继承
和java继承类似，由父及子
（9）聚合
将多个项目汇总到一起
4.1、maven工程约定的目录结构
每一个maven项目在磁盘中都是一个文件夹（就相当于是IDEA项目的文件夹）
| JAVA工程名 | |||||
| src | |||||
| main | |||||
| java | 各种包 | 程序的包和包中的java文件 | |||
| resources | java程序需要的配置文件 | ||||
| test | 放置测试程序的代码和配置文件（如果要求测试，允许没有测试文件） | ||||
| java | 各种包 | 测试程序要使用的包和包中的java文件 | |||
| resources | 测试java程序需要的配置文件 | ||||
| pom.xml | maven的核心文件（maven启动后就通过这个文件了解该做什么） | ||||
|
target (maven自动生成的 结果目录） |
当对src中的java文件进行编译以后，maven自动生成这个文件夹用于存放编译后的class文件 |
4.2 编译方法
进入maven工程的根目录（pom.xml文件所在的位置），启动cmd（直接windows文件目录那里输入cmd），然后输入命令 mvn compile。就会编译main中的所有java文件，并自动在根目录新建一个target文件夹，将编译好的.class文件放入此文件夹。第一次编译，maven会下载一堆插件。
疑问1 第一次执行时，为什么要下载那些插件
maven工具执行的操作是通过很多特定功能的插件(java类–jar文件)来完成的，因此需要网上下载相关插件。
疑问2 下载的插件存放到哪里了.
默认仓库(本机仓库) :C:\Users\ (登录操作系统的用户名) Administrator\.m2\repository
修改本地仓库方法（如果不想放在c盘）：
进入maven安装目录/conf/settings.xml（为了安全，先备份），然后进入settings.xml，找到<localRepository>xxx</localRepository>标签，将标签挪到注释外面，将里面的值改成新目录地址（比如F:/apache-maven-3.6.3）即可,注意，文件里面是 \ ,但是maven标签里面是 /，注意该斜杠方向。
说明：maven默认是从中央仓库下载插件。中央仓库地址就在官网
4.3 仓库
（1）仓库是什么:仓库是存放东西的, 存放maven本身需要使用的jar包，和我们项目需要使用的jar包
① maven本身需要使用的插件(各种jar)
② 项目使用的Jar(第三方的工具)，比如mysql，spring等jar包
（2）仓库的分类
① 本地仓库,
指个人计算机上的文件夹,存放各种jar
② 远程仓库, 在互联网上的,使用网络才能使用的仓库
Ⅰ 中央仓库,最权威的,所有的开发人员都共享使用的一个集中的仓库（因此压力很大），中央仓库地址： https://repo.maven.apache.org
Ⅱ 中央仓库的镜像:中央仓库的备份,在各大洲,重要的城市都是镜像.（为了缓解中央仓库的压力）
说明：当我们项目需要jar包时，maven会先找各大洲maven的镜像，都找不到再去中央仓库
Ⅲ 私服，在公司内部，局域网中使用的仓库，不对外使用。
（3）仓库的使用
开发人员需要使用mysql驱动，maven会首先查找本地仓库——>私服（如果有私服）——>各大洲的镜像——>中央仓库
说明：maven全程自动完成。找到jar包以后，都会自动备份到私服和本地仓库。下次即可直接在本地访问。
4.4 pom文件 Project Object Model
pom文件即Project Object Model项目对象模型。Maven把一个项目的结构和内容抽象成一个模型,在xml文件中进行声明,以方便进行构建和描述, pom.xml是Maven的灵魂。所以, maven环境搭建好之后,所有的学习和操作都是关于pom.xml的。
（1）pom.xml 概述
| modelVeision | Maven模型的版本 | ||
| 坐标 |
groupId (互联网唯一） |
组织id，一般是公司域名的倒写（互联网上域名唯一，所以倒写也唯一），格式可以为： 1.域名倒写。 例如：com.baidu 2.域名倒写+项目名。 例如：com.baidu.appolo |
groupId、artifactId、version三个元素生成了一个Maven项目的坐标，在互联网众多的Maven项目中可以唯一定位到某一个项目。坐标也决定将来项目在仓库中的路径及名称（groupId对应的包路径/模块名/版本号/jar包） |
|
artifactId （公司内部唯一） |
项目名称，也是模块名称，对应groupId中项目的子项目 | ||
| version | 项目的版本号。如果项目还在开发中，是不稳定版本，通常在版本后代-SNAPSHOT version使用三位数字标识，例如1.1.0 |
||
| packaging（打包） | 项目打包的类型，可以是jar、war、rar、ear、pom，默认是jar | ||
| dependencies和dependency（依赖） | Maven的一个重要作用就是管理jar包,为了一个项目可以构建或运行,项目中不可避免的,会依赖很多其他的jar包,在Maven中,这些jar就被称,为依赖,使用标签dependency来配置。而这种依赖的配置正是通过坐标来定位的,由此我们也不难看出, maven把所有的jar包也都视为项目存在了。 | ||
| properties（配置属性） | properties用来定义一些配置属性，例如project.build.sourceEncoding，可以设置为UTF-8,防止中文乱码，也可定义相关构建版本号，便于日后统一升级 | ||
|
build（构建） 配置插件 |
build表示与构建相关的配置，例如设置编译插件的jdk版本。 插件可以在自己的项目中设置,最常使用的是maven编译插件。设置项目使用的jdk版本时通过编译插件指定。pom.xml文件<build>中设置。 |
||
（2）坐标：唯一值, 在互联网中唯一标识一个项目的
<groupId>公司域名的倒写</groupId>
<artifactId>自定义项目名称</artifactId>
<version>自定版本号</version>
（3）packaging
项目的打包类型：pom、jar（默认）、war（web应用）
packing默认是jar类型，
<packaging>pom</packaging> ———> 父类型都为pom类型 （springcloud父项目）
<packaging>jar</packaging> ———> 内部调用或者是作服务使用
<packaging>war</packaging> ———> 需要部署的项目
扩展：pom（没有java代码，也不执行java代码，只是为了聚合工程传递依赖）
所有的父级项目的packaging都为pom，作为父级项目，还有一个重要的属性，那就是modules，通过modules标签将项目的所有子项目引用进来，在build父级项目时，会根据子模块的相互依赖关系整理一个build顺序，然后依次build
<project><packaging>pom</packaging><modules><module>abcd-business</module><!-- pom --><module>abcd-sms</module><!-- pom --></modules>
</project>各个module里面依赖的项目中，子项目pom里面依赖的jar，和war最终都会被maven管理好。
（4）依赖 相当于java代码中的import
即在pom.xml文件中，添加 <dependencies> 标签（一般添加在properties标签下面），粘贴搜索到的插件的jar包的坐标。下面以mysql jar包，log（日志）jar包，junit单元测试jar包为例。添加成功后，会在本地仓库中，找到对应的文件夹
<dependencies>
<!– https://mvnrepository.com/artifact/mysql/mysql-connector-java –>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.22</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
</dependency>
</dependencies>
扩展：IDEA中查看依赖关系小技巧，在IDEA中，进入pom.xml配置文件，右键—Diagrams 即可看到图表版依赖关系
扩展：<dependencyManagement>
其通常用在项目中对顶层的父POM中，它能让其所有子项目引用一个依赖而不用显式的列出版本号。此外，dependencyManagement 只是声明依赖，并不实现引入（像极了接口），子项目如果不声明依赖，则不会从父项目中继承下来。
提供作用：子模块继承之后，可以锁定版本+子module不用写groupId和version。
注意：子模块如果不写，就用父项目的版本，子模块写了，就用自己的版本
<dependencyManagement>
<dependencies>
<!–spring boot 2.2.2–>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.2.2.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
（5）properties
① 设置Maven的常用属性
进入pom.xml 找到properties标签
<properties>
<project.build. sourceEncoding>UTF-8</project. build. sourceEncoding> //<!–maven构建项目使用的是utf-8 ,避免中文的乱码–>
<maven. compiler. source>1.8</maven. compiler.source> //<!–编译java代码使用的jdk版本–>
<maven. compiler.target>1.8</maven. compiler.target> //<!–你的java项目应该运行在什么样的idk版本–>
</properties>
一般应用场景：一般在父项目中写好常用版本号属性，就可以对子项目进行统一管理（需要子项目通过parent标签引入该父项目）
② Maven的全局变量设置
- 自定义属性
Ⅰ 在<properties>通过自定义标签声明变量（标签名就是变量名）
Ⅱ 在pom.xml文件中的其他位置，使用${标签名}使用变量的值
说明：自定义全局变量一般是定义，依赖的版本号，当你的项目中要使用多个相同的版本号，先使用全局变量，定义，再使用${标签名}使用属性值。
exp：spring框架中，很多依赖的jar包都是同一个版本号，如果修改的话，一个一个改很麻烦，改掉了还会导致项目不成功。因此可以在<properties>中自定义属性，然后在<dependency>中使用这个自定义属性
<properties> //在properties标签中自定义<spring.version>属性
….
<spring.version>5.2.0</spring.version>
</properties>
<dependency> //在依赖中，直接调用spring.version属性的值，这样改动properties中的属性值，就可以修改所有依赖里面的属性值
….
<version>${spring.version}</verision>
</dependency>
特别说明：如果子项目的某个依赖中A的某个内部依赖B（A依赖B），父项目也用了B，子项目中的B版本和父项目的B版本不一致，可以在properties中专门写B的版本，这样父子项目B依赖都会统一。
（6）build: maven在进行项目的构建时的配置信息，例如编译java代码使用的jdk版本
扩展： 资源搜索方法
手动搜索资源的地址：https://mvnrepository.com（ps：谷歌浏览器才能打开），使用groupId或者artifactId作为搜索条件
4.5 Maven的生命周期，Maven的命令，Maven的插件
（1）生命周期
就是Maven构建项目的过程，即清理，编译，测试，报告，打包，安装，部署
（2）Maven的命令
Maven通过使用命令，完成项目的生命周期的执行（即通过命令完成清理，编译，测试，报告，打包，安装，部署）
（3）Maven的插件
Maven命令执行时，真正完成功能的是插件，插件就是一些jar文件，即一些类。
（4）单元测试 junit，junit是一个专门测试的框架（工具），用于测试类中的方法
junit测试内容：测试的是类中的方法，每一个方法都是独立测试的。 类中的方法 是测试的基本单位（单元）
maven借助单元测试，批量的测试类中的大量方法是否符合预期的。
- junit 使用步骤：
Ⅰ 在pom.xml加入单元测试依赖。 仓库里面去搜，用使用人数最多的就是了
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
</dependency>
Ⅱ 在maven项目中的 src/test/java 目录下，创建测试程序。
Ⅲ 推荐的创建类和方法的提示：
① 测试类的名称 是：Test + 测试的类名
② 测试的方法名称 是：test + 方法名称
exp：
@Test //必须要用测试注解
public class TestHelloMaven{
public void testAdd(){
方法体;
}
}
说明：
① 其中testAdd叫做测试方法，它的定义规则
② 方法是public的，必须的
③ 方法没有返回值，必须的
④ 方法名称是自定义的，推荐是test+方法名称
⑤ 方法上方加入@Test注解
exp：测试 某工程/src./main/java/com/Huhaha 下的 HelloMaven.java 中的 public void add()方法
在 Maven工程的test目录创建测试类的测试文件，注意包名，路径一致 某工程/src/test/java/com/Huhaha 创建测试类
将测试类按建议规则命名：TestHelloMaven.java
package com.Huhaha; //测试类的路径
import org.junit.Assert; //导入测试包
import org.junit.Test;
public class TestHelloMaven{
@Test
public void testAdd(){
HelloMaven hello = new HelloMaven(); //构造测试类HelloMaven的对象hello
int res = hello.add(10,20); //对象来调用将要测试的方法add()
//assertEquals(期望值,实际值),测试的类方法，如果测试通过，即两个值相等证明正确的。不通过就抛异常
Assert.assertEquals(30,res);
}
}
4.6 Maven的命令
（1）清理 mvn clean 。
清理之前编译时，生成的target目录。
操作步骤：
打开cmd，转到项目根目录下(pom.xml)所在位置。 输入 mvn clean
（2）编译主程序文件 mvn compile
编译main/java/目录下的java为class文件，同时把class拷贝到target/classes目录下面
把main/resources目录下的所有文件，都拷贝到target/classes目录下
操作步骤
打开cmd，转到项目根目录下(pom.xml)所在位置。 输入 mvn compile
（3）编译测试文件 mvn test-compile
编译test./java/目录下的class文件，并将其拷贝到target\test-classes\包 下面
操作步骤：
打开cmd，转到项目根目录下(pom.xml)所在位置。 输入 mvn test-compile
（4）测试 mvn test 测试（会生成一个目录surefire-reports，保存测试结果）
执行测试文件
执行mvn test的时候，会把前面的清理-编译主程序-编译测试程序 三个环节都执行一遍。测试完成可以直接在cmd中看到报告，同时在target/surefire-reports生成一个txt测试报告
操作步骤：
打开cmd，转到项目根目录下(pom.xml)所在位置。 输入 mvn test
测试完成，会直接在cmde中看到报告。
（5）打包主程序 mvn package
编译、编译测试、测试、并且按照pom.xml配置（即以配置文件中的坐标为依据命名，建立类的相关性）把主程序=打包成jar包或war包,并存放在target目录下
jar文件中只包含 src/main中的所有内容，不包含测试文件
操作步骤：
打开cmd，转到项目根目录下(pom.xml)所在位置。 输入 mvn package
（6）安装 mvn install
安装主程序（会把本工程打包，并且按照本工程坐标保存到本地仓库中）
安装以后，公司的其他程序员都可以用这个jar包了（将打包好的jar包从target文件夹保存到本地仓库，并做好相关配置）
存放路径：groupId对应的包路径/模块名/版本号/jar包）
比如：repository/com/Huhaha（groupId）/ch01-maven（模块名）/1.0-SNAPSHOT（版本号）/ch01-maven-1.0-SNAPSHOT.jar
操作步骤：
打开cmd，转到项目根目录下(pom.xml)所在位置。 输入 mvn install
特别注意：执行mvn命令某个步骤的时候，都会把这个命令之前的所有命令都执行一遍。比如执行mvn install，会把前面的1-5步骤都自动执行了
4.7 配置插件
Maven中，实际完成上面项目构建的都是Maven插件，插件可以在自己的项目中设置。最常使用的是maven编译插件。设置项目使用的jdk版本时通过编译插件指定。pom.xml文件<build>中设置。
操作步骤：
进入 pom.xml 一般在最后，开始写build标签
<!–控制配置maven构建项目的参数设置,设置jdk的版本–>
<build>
<!–配置插件–>
<plugins> // 配置具体的多个插件
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugink/artifactId> // <!–插件的名称–>
<version>3.8.1</version> // <!–插件的版本–>
<configuration> // <!–配置插件的信息->
<source>1.8</source> //告诉maven我们的写的代码是在jdk1.8上编译的
<target>1.8</target> //告诉Maven此项目在jdk1.8的运行环境上运行
</configuration>
</plugin>
</plugins>
</build>
特别说明：plugin标签的内容都是直接从Maven的官网上复制来的，不用专门记忆。（直接百度 Maven 插件 进Maven官网即可找到）
5、IDEA中使用Maven （重点）
5.1 IDEA中配置Maven
IDEA中内置了Maven，但内置Maven配置不方便。都用自己下载的Maven。因此首先要在IDEA中设置我们自己的Maven
设置步骤：
进入 IDEA的两个目录设置，一个是 File-Settings（对当前工程有效） ，另一个是 File-Other Settings-Settings for NewProject（对以后的新建工程有效）。两个目录配置方法一模一样（这里以当前工程设置为例）
Step1：设置Maven安装目录
File-Settings-Build，Execution，Deployment-build tools-Maven
Step2：进入Build Tools —Maven—Runner
vm Options: -DarchetypeCatalog=internal
说明：Maven项目创建时，Maven会自动联网去外网下载模板文件，而且比较大，又是外网。效率就非常低。加入这个代码，可以让Maven不下载模板文件，创建项目就会非常快。（有的IDEA版本加了这个会报错，删掉就是了）
JRE：选择jdk的版本
5.3 IDEA中创建基于Maven的项目
5.3.1 IDEA中创建JavaSE项目
Step1:选择一个空工程并命名maven-course （便于以后添加不同技术的模块）
New-Project-EmptyProject
step2：使用模板创建项目
Project Seetings 点击+（Add）-New Module 在Module中 选择左侧的Maven
选择好自己的jdk版本，然后打钩使用模板，接着选择quickstart模板（比较靠后的模板）。这个模板用于创建普通的java项目
最后
项目创建完成
说明： quick-start模板没有recourses文件夹，需要我们手动创建
创建步骤：
step1：点击main文件夹，右键 New-Directory 将文件夹取名Recourses（此时还只是普通文件夹）
step2： 把recourses文件夹变成项目配置文件夹
recourses文件夹 右键 Mark Directory as Resources Root
IDEA中的Maven模块说明：
5.3.2 IDEA中创建JavaWeb项目
step1：仿照上面JavaSe的创建方法 New-Module-Maven （只是和javaSE用的模板不同而已）
选择：maven-archetype-webapp模板
step2：取项目名字，设置项目坐标（仿照前面的javase步骤）
创建完成。
step3：补充缺失目录。main下面补充java（设置为Sources Root），补充recourses（设置为Resources root）
step4：（如果要做测试）：补充test目录，test目录下再补充java（设置为Test Sources Root），补充recourses（设置为Test Resources root）
step5 加入serlvet和jsp的依赖（听说serlvet和jsp已过时）
step6 写serlvet代码，或jsp代码
step7 配置Tomcat服务器
（1）选择Edit Configuration
（2）选择 Local
（3）取名字，并选择好端口号，然后进入部署页面（deployment）
（4）deployment页面部署项目
（5）给项目取名
（6）启动Tomcat
（7）通过本机浏览器，去访问页面
5.4 IDEA中导入别人的maven项目
选择IDEA主窗口右上角的工程结构，选择"+" ，Import Module，选择Module文件夹所在的目录（整个maven项目所在的根目录），点击“ok”，再次向IDEA确认是导入Maven项目，finish
然后，在依赖界面（dependency），选择导入项目的JDK版本
6、依赖管理
（1） 依赖的范围
依赖范围在<dependency>标签下用<scope>的值标签标识，表示依赖使用的范围，也就是在Maven构建项目的哪些阶段有效。
<scope>标签的值有：compile、test、provided、默认采用compile（不写<scope>标签，就是默认<scope>compile</scope>标签）
|
compile 所有阶段都有效 |
test 只在测试阶段有效 |
provided 编译，测试有效。不参与打包 |
|
| 对主程序是否有效 | 是 | 否 | 是 |
| 对测试程序是否有效 | 是 | 是 | 是 |
| 是否参与打包 | 是 | 否 | 否 |
| 是否参与部署 | 是 | 否 | 否 |
| 说明 | 项目生成的jar包或者war包里面有个lib文件，专门放依赖的jar包 | 项目生成jar包或者war包里，没有lib文件夹。依赖的其他jar包只在编译、测试的时候使用，但最终都不参与项目的打包 |
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope> //说明junit只在测试时，这个依赖有效
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope> // 说明编译、测试时会使用，但生成项目的时候，不用这个jar包（Tomcat服务器都会再带serlvet类）
</dependency>
（2）排除传递的某些依赖 <exclusions>
在mavenB项目中引入mavenA项目依赖，A项目中又有多个A相关的依赖，通过依赖传递，会将mavenA中的jar包传递进来,如果B中不需要A中的某个依赖(jar包）就可以使用以下标签
<exclusions><exclusion><groupId></groupId><artifactId></artifactId></exclusion>
</exclusions>exp:
<dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>${spring.version}</version><exclusions><exclusion><artifactId>commons-logging</artifactId><groupId>commons-logging</groupId></exclusion></exclusions>
</dependency>简便方法：
① 进入图表版依赖关系
在IDEA中，进入pom.xml配置文件，右键—Diagrams 即可看到图表版依赖关系
② 选中不想要的依赖，右键—exclude
7、资源插件
（1）背景
没有使用resources的时候，Maven执行编译代码时，会把src/main/resources目录中的文件直接拷贝到target/classes目录中。对于在src/main/java目录下的非java文件，都不会处理，不会将其拷贝到target/classes目录中去。
但实际开发中，比如使用mybatis框架的时候，我们需要把一些文件放在src/main/java中，而且在执行java程序时，需要用这些文件，即需要将其拷贝到target/classes目录中去。此时就需要在pom.xml中的<build>标签加入<resources>，告诉maven该怎么拷贝
（2）配置方法
<build>
<resources>
<resource>
<directory>src/main/java</directory> <!–要拷贝文件所在的目录–>
<includes> <!–该目录下的后缀名为.properties，.xml文件都会被拷贝–>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering> // <false指不启用过滤器, *.property已经过滤后缀名了–>
</resource>
</resources>
</build>