maven教程 IDEA中使用Maven Tomcat配置依赖管理

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包为例。添加成功后，会在本地仓库中，找到对应的文件夹

<!– 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>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标签

<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> // 配置具体的多个插件

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-compiler-plugink/artifactId> // <!–插件的名称–>

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

<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