06-JavaWeb开发【使用Maven开发web项目详解】

typora-copy-images-to: img

Maven概述
	1、maven是什么：软件-项目管理工具；
 	2、maven的作用：
		【1】构建标准的项目：java，web
		【2】管理项目的生命周期：
		【3】maven管理项目中的jar包(依赖)；
		【4】maven管理插件；

	3、maven的下载安装与配置：
		【1】JAVA_HOME配置正确；
		【2】MAVEN_HOME配置正确；   mvn -v

maven仓库
	【1】作用：存放jar包和插件；
	【2】分类：
			本地仓库：本地的一个文件夹
 			远程仓库：远程服务器上的一个文件夹
				中央仓库：apache维护的仓库
				私服：自己搭建的远程仓库
     【3】仓库配置：
			本地仓库配置：
             私服配置：阿里云（外网），传智私服（局域网）
	

Maven项目创建
	【1】把maven绑定到IDEA中：
			file->other settings-->default setting 设置maven环境：maven_home,settings.xml
	【2】使用IDEA创建maven项目：掌握
			创建maven的java项目：普通项目  打包方式为jar
					项目结构

			创建maven的web项目： 打包方式为war
				      项目结构

	【3】maven项目的生命周期：
			1、clean：删除项目构建过程中生成的文件(target)
			2、default：
				创建==》编译==》测试==》打包===》安装==》部署上线
			3、site：了解
	 【4】生命周期相关命令：命令调用maven的插件执行任务
			mvn clean：清理
			mvn compile：编译
			mvn  test：测试
			mvn package：打包
			mvn install：安装
			

maven应用详解
		【1】依赖管理：
			1、坐标：定位一个jar包在本地仓库中的位置
					<dependency>
                        <groupId>jstl</groupId>
                        <artifactId>jstl</artifactId>
                        <version>1.2</version>
                    </dependency>

		    2、导入依赖：导入坐标
				本地仓库导入： Alt+Insert
				远程仓库搜索：中央仓库，私服搜索
		 【2】依赖配置：
			 1、依赖作用范围配置：maven有3套运行环境
					编译环境    测试环境    运行环境（tomcat）
			 test      -           是          -                   junit.jar
			 compile   是		是			是                  90%的jar-默认的
  			 runtime   -          是            是                  mysql驱动（实现JDBC结构）
			 provided  是         是            -                    servlet，jsp
			 system   是          是            -


		  2、依赖版本统一维护：
				定义版本信息：
				 <properties>
                      <junit.version>4.12</junit.version>
                  </properties>
				引用版本信息：
				 <version>${junit.version}</version>

		【3】插件管理：
				maven本身是一个插件库：默认的插件（版本低）
				自己配置插件，覆盖默认的插件： 编译插件，测试插件，tomcat7插件

一、maven概述

1.1、项目开发中的问题

注意：在maven中所描述的依赖就是我们平常使用的第三方的jar包。

用maven来管理jar包能解决的问题：

问题一：

我的项目依赖一些jar包，我把他们放在哪里？直接拷贝到项目的lib文件夹中?
如果我开发的第二个项目还是需要上面的那些jar包，再把它们复制到我当前项目lib中？
那如果现在是第三次了，再复制一次吗？
以上操作会出现的问题：

重复存放jar包；容易出现jar包冲突；手动拷贝jar包容易缺少一些jar包。

问题二：

我写了一个数据库相关的通用类，并且推荐给了其他项目组，现在已经有5个项目组使用它了，今天我发现了一个bug，并修正了它，我会把jar包通过邮件发给其他项目组。
以上操作会出现的问题：

需要开发人员每次都手动接收新的jar包并替换掉本地的jar包，太麻烦。

1.2、maven是什么

1.2.1 maven定义

Maven是一个项目管理工具。它包含了一个项目对象模型 (Project Object Model)，一组标准集合，一个项目生命周期(Project Lifecycle)，一个依赖管理系统(Dependency Management System)，和用来运行定义在**生命周期阶段(phase)中插件(plugin)目标(goal)的逻辑。**当你使用Maven的时候，你用一个明确定义的项目对象模型来描述你的项目，然后Maven可以应用横切的逻辑，这些逻辑来自一组共享的（或者自定义的）插件。

maven：本质上是一个软件，用来管理项目的。

1.2.2 mven的作用

项目构建管理： maven提供一套对项目生命周期管理的标准，开发人员、和测试人员统一使用maven进行项目构建。项目生命周期管理：编译、测试、打包、部署、运行。

管理依赖（jar包）： maven能够帮我们统一管理项目开发中需要的jar包；

管理插件： maven能够帮我们统一管理项目开发过程中需要的插件；

二、maven的下载安装与配置

2.1、maven的下载与安装

下载

官方网站：http://maven.apache.org/
下载页面：http://maven.apache.org/download.cgi

安装

​ maven安装包下载完成后是一个压缩文件

​ 我们需要将压缩包解压到一个没有中文，空格或其他特殊字符的文件夹内即可使用

2.2、maven安装目录简介

目录名	功能说明
bin	二进制的可执行文件，如：mvn.cmd是maven的核心可执行文件
boot	第三方类加载器插件，类似于ClassLoader
conf	配置文件夹，其中的settings.xml是用于配置本地仓库的
lib	maven自身运行所需要的jar包

2.3、maven配置-MAVEN_HOME

2.3.1 配置JAVA_HOME

3版本的maven软件依赖1.7或以上版本的JDK，

所以安装maven之前需要确认jdk的版本和JAVA_HOME是否正确配置

注意：JAVA_HOME路径需要设置成bin目录的上一级目录；

2.3.2配置MAVEN_HOME

按照上面JAVA_HOME的配置方式，将maven的安装目录配置到环境变量中。

MAVEN_HOME：maven压缩包解压目录，就是bin的上一级目录。

第一步：新增环境变量：MAVEN_HOME

第二步：在path环境变量中添加：%MAVEN_HOME%\bin

第三步：测试：在cmd控制台中输入命令： mvn -version ；

如果出现以下maven的版本信息，则说明maven的安装与环境变量的配置均正确；

2.4、maven仓库介绍

仓库就是一个目录(文件夹)，这个目录被用来存储我们项目的所有依赖（就是jar包）和插件。

仓库包括两类仓库：

​ 1）本地仓库

​ 2）远程仓库

​ 远程仓库又包括两类：

​ a:中央仓库

​ b:私服

2.4.1、maven本地仓库配置

2.4.1.1 本地仓库是什么

​ 本地仓库就是本地目录(文件夹)，这个目录被用来存储我们项目的所有依赖（就是jar包），本地仓库供你电脑上所有项目使用，maven所有的jar包都是从远程仓库下载到本地仓库.

2.4.1.2 配置本地仓库

​ 本地仓库的位置是通过maven的核心配置文件（settings.xml）来配置的。settings.xml文件位于maven安装目录：apache-maven-3.3.9\conf\settings.xml 。

​ 打开settings.xml文件：

发现本地仓库默认的地址为当前用户的/.m2/repository目录。

一般情况下，我们需要自己重新设置本地仓库的地址，设置方法如下

1. 第一步：在maven的安装目录下创建一个repository文件夹

   （一般习惯将仓库地址和maven安装目录放置在一起）。

2. 第二步：在核心配置文件setting.xml中，将仓库存放的位置设置成：
3. D:\MySoft\maven\apache-maven-3.3.9\repository（以自己的安装路径为准）；

2.4.2、远程仓库

2.4.2.1、中央仓库

中央仓库默认是apache提供的，位于国外。(中央仓库的地址：http://mvnrepository.com/)

2.4.2.2、私服

2.4.2.2.1 什么是私服

​ 私服是可以架设在局域网的一种特殊的远程仓库，目的是代理中央仓库来部署第三方构件。有了私服之后，当 Maven 需要下载构件时，直接请求私服，私服上存在则下载到本地仓库；否则，私服请求外部的远程仓库(中央仓库)，将构件下载到私服，再提供给本地仓库下载。

例如：阿里云私服(连接外网)

公司都会有自己的私服。私服就是一个服务器。我们的maven项目到私服服务器上去下载jar包到本地仓库供maven项目使用。

2.4.2.2.2 配置私服

​ 打开settins.xml文件，找到标签节点，在这个标签中添加以下配置信息中的任意一个：

注: 千万注意, 只可配置一个(另一个要注释!) 不然两个可能发生冲突 ,导致jar包下不下来 !!!

【阿里云私服】–连外网时使用

<mirror>
     <id>nexus-aliyun</id>
     <mirrorOf>*</mirrorOf>
     <name>Nexus aliyun</name>
     <url>http://maven.aliyun.com/nexus/content/groups/public</url>
</mirror>

三、IDEA创建maven工程

​ 在创建maven工程之前一定要保证上述的仓库都是配置成功了，否则无法创建maven项目，因为创建maven项目都要到仓库中去下载插件。那么上面我们已经配置好maven仓库了，接下来我们就要创建maven工程了。

1、IDEA配置本地maven

​ 因为idea和maven是没有直接关系的。所以**使用idea创建maven工程之前需要将本地的maven配置到idea环境中，这样才可以在idea中创建maven工程。**配置方法如下：

1.1 配置本地maven

1. 第一步：打开default settings：

说明：通常修改idea的配置都是修改settings设置，这里我们修改other settings，因为在这里修改settings只是对于当前maven工程有效，创建其他工程设置无效了，我们需要所有maven工程都有效，所以修改other settings。（无other settings，可到idea界面 的setting设置）

​ 2.第二步：配置maven_home和settings.xml的路径

在搜索框里搜索maven，然后按照下面操作即可。

1.2 配置maven参数

​ 使用idea创建maven项目后，默认会去网络中的中央仓库中下载一些配置资源，那么会很慢，这里需要设置下，那么就不会到中央仓库去下载了一些资源，而是到本地仓库下载。需要设置参数archetypeCatalog。设置方法如下：将-DarchetypeCatalog=internal 设置到Maven–Runner–VM Options中。

参数：-DarchetypeCatalog=internal

说明：
1)-D：在maven中表示设置参数的意思
2)archetypeCatalog:表示设置参数的名字
3)internal:表示设置参数的值

2、创建maven的java工程

使用maven创建的项目可分为3种类型

​ 1）普通maven项目，就是之前的javase项目–》java project，项目打成jar包运行

​ 2）maven的web项目，项目打成war包运行

​ 3）maven的pom项目，也称为maven的聚合项目

2.1 创建步骤

1. 第一步：File–New–Project

2. 第二步：选择maven然后下一步：

3. 第三步：填写项目的坐标信息：

附：

GroupID是项目组织唯一的标识符， 比如我的项目组叫maven01 那么GroupID应该是 com.itheima.sh.maven01   域名.项目组名

ArtifactID就是项目的唯一的标识符，表示项目名。 一般是 xxx-xxx   比如maven-java 
version:项目版本号 第一次就是1.0.0  第二次比较多的修改 2.0.0  第三次小的修改 2.1.0 第四次修改很小的bug2.1.1 ....

4. 第四步：指定项目名称和路径：idea会把项目名中的- 去掉，我们给添加上即可。

2.2 java工程目录简介

说明：

​ 1）.idea和maven-java1.iml只要在idea中创建工程都会存在的，idea生成的，不用关心

​ 2）**pom.xml是maven的核心配置文件，**我们会在这个配置文件配置依赖。

​ 3）main：主代码，在实际开发中是项目上线运行的

​ a:java:存放java代码的

​ b:resources：存放配置文件的，相当于以前创建的java工程中的src。

例如存放mybatis、数据库连接池的配置文件。这个目录只能存放配置文件。

​ 4）test:存放测试的代码，项目上线之前先进行测试，然后在上线。

​ a:java:存放编写java的测试的代码，例如junit测试

2.3 运行java代码

1.在main目录的java目录上右键创建包

2.在创建好的包上右键创建java类

3.编写以下代码进行测试

package com.itheima.sh.maven_helloworld_01;
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("hello maven..");
    }
} 

运行结果：如果控制台上能够正常打印如下信息，则说明工程创建没问题。

3、创建与发布web项目

3.1 创建步骤

idea中创建maven的web项目一共分为四个步骤：

1、创建一个普通的maven工程，就是上述创建的工程，和上述创建的一样
2、给maven添加一个打包方式，打成war包
3、创建web项目的webapp目录以及web.xml文件。相当于之前javaweb工程的web目录
4、配置tomcat

第一步：创建普通java项目

​ 参照创建maven的java项目步骤进行创建。

第二步：配置打包方式

web项目的打包方式为war，打开maven项目的pom文件。在项目的坐标信息下添加标签，设置打包方式。

<packaging>war</packaging>

第三步：配置webapp目录和web.xml

打开Project Structure 视图

新增web.xml文件：按照数字图标的顺序操作

说明：复制上述弹出框的整体路径,下面设置web.xml的位置会用到

F:\ideawork\beike\maven\maven-java02\src\main\webapp

设置web.xml的路径 ：

上述在main目录下创建webapp之后，我们点击右上角的加号然后选择web.xml。点击web.xml后会自动弹出一个窗口设置路径

上面弹出框的路径不对，是将WEB-INF\web.xml放到项目根目录了，我们需要修改，将WEB-INF\web.xml前面的路径替换为：F:\ideawork\beike\maven\maven-java02\src\main\webapp。整体路径应该变为：

F:\ideawork\beike\maven\maven-java02\src\main\webapp\WEB-INF\web.xml

点击Applay，OK即可：

注意：我为什么这么麻烦，直接在main目录创建右键创建一个webapp目录不也可以吗？

答案是不可以的，我们发现上述创建的webapp目录上有个蓝点，这说明是正确的的，

下面配置完tomcat我们是可以发布和访问的。如果直接创建普通目录是不可以访问的。

第四步：创建完成

​ 设置完成之后，main目录下会创建webapp-WEB-INF-web.xml。

3.2 发布web项目

第一步：Edit Configurations

第二步：添加local tomcat

​ 按照下图数字图标顺序操作： –> Tomcat Server --> Local

第三步：配置tomcat

点击OK.

第四步：启动测试

在webapp目录下新建一个index.html文件

文件内容如下：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>测试</title>
</head>
<body>
    <h1>Hello Maven!</h1>
</body>
</html>

​ 启动tomcat后，访问index.html。如果能正确访问到。说明项目创建OK。

四、maven项目构建的生命周期【了解】

1、maven项目构建的生命周期

1.1 生命周期是什么

​ 在Maven出现之前，项目构建的生命周期就已经存在，软件开发人员每天都在对项目进行清理，编译，测试及部署。虽然大家都在不停地做构建工作，但公司和公司间，项目和项目间，往往使用不同的方式做类似的工作。

​ Maven的生命周期就是为了对所有的构建过程进行抽象和统一。Maven从大量项目和构建工具中学习和反思，然后总结了一套高度完美的，易扩展的生命周期。这个生命周期包含了项目的清理，初始化，编译，测试，打包，集成测试，验证，部署和站点生成等几乎所有构建步骤。

Maven的生命周期是抽象的，这意味着生命周期本身不做任何实际工作，

在Maven的设计中，实际任务（如源代码编译）都交由插件来完成。

1.2 maven的三套生命周期

​ maven拥有三套相互独立的生命周期，分别是clean，default和site。

clean 生命周期的目的是清理项目 ，

default 生命周期的作用是构建项目 ，

site 生命周期的目的是构建项目站点 。

maven的生命周期都对应着具体的命令如下：

clean生命周期

​ clean生命周期的目的是清理项目，它包含三个阶段：

1. pre-clean 执行一些清理前需要完成的工作；
2. clean 清理上一次构建生成的文件；
3. post-clean 执行一些清理后需要完成的工作；

default生命周期

​ default生命周期定义了真正构建项目需要执行的所有步骤，它是所有生命周期中最核心的部分。其中的重要阶段如下：

1. compile ：编译项目的源码，一般来说编译的是src/main/java目录下的java文件至项目输出的主classpath目录中；
2. test ：使用单元测试框架运行测试，测试代码不会被打包或部署；
3. package ：接收编译好的代码，打包成可以发布的格式，如jar和war；
4. install： 将包安装到本地仓库，供其他maven项目使用；
5. deploy ：将最终的包复制到远程仓库，供其他开发人员或maven项目使用；

site生命周期

​ site生命周期的目的是建立和发布项目站点，maven能够基于pom文件所包含的项目信息，自动生成一个友好站点，方便团队交流和发布项目信息。该生命周期中最重要的阶段如下：

1. site ：生成项目站点文档；

2、maven生命周期相关命令演示

​ 我们使用以下命令可以完成maven生命周期，演示生命周期的命令必须在pom.xml所在的目录下打开dos窗口然后输入如下命令进行演示。

1.找到pom.xml文件位置

2.在pom.xml文件位置输入cmd打开dos窗口

mvn clean：调用clean生命周期的clean阶段，清理上一次构建项目生成的文件；
mvn compile ：编译src/main/java中的java代码；
mvn test ：编译并运行了test中内容 ；
mvn package：将项目打包成可发布的文件，如jar或者war包； 
mvn install ：发布项目到本地仓库 ；

2.1、mvn clean

​ clean命令的作用是清理项目编译或打包后生成的文件，具体对应maven项目中的target目录；

需求：清理存储上一次构建项目生成的文件target.

未清理前：

清理之后：

我们发现不存在target目录了。

2.2、mvn compile

​ compile命令的作用是编译src/main/java中的java代码编译成可直接运行的class文件。编译完成后maven项目会自动创建一个target目录来存储这些文件。

2.3、mvn test

​ test命令的作用是编译并运行maven项目的src/test目录下的junit测试代码。注意：只能运行junit测试代码。 并且使用test运行的测试类的类名必须以Test结尾，否则不会运行，不会看到结果。

在test/java目录下创建一个测试类，书写测试方法，代码如下：

import org.junit.Test;
public class MavenTest {
    @Test
    public void show() {
        System.out.println("show....");
    }
}

在dos窗口输入的测试命令：

mvn test

编译后生成的文件：

运行日志：

注意：

​ 1.test命令只能运行test目录下的junit包下的类

​ 2.test命令也可以运行多个测试方法：

import org.junit.Test;

public class MavenTest {
    @Test
    public void show() {
        System.out.println("show............");
    }
    @Test
    public void show1() {
        System.out.println("show1............");
    }
    @Test
    public void show2() {
        System.out.println("show2............");
    }
}

2.4、 mvn package

​ package命令是将项目打包成可以发布的包。maven项目常见的打包方式有两种:

​ 1)maven的java project会打成jar包。

​ 2)maven的web project会打成war包。

打包完成后将生成的文件存放在target目录中。

命令使用格式：

mvn package

注意：每次打包前还会再次执行所有test命令

2.5、 mvn install

​ install命令是将当前的项目打包并发布到本地仓库中，供本地的其他maven项目使用。

项目发布的路径：本地仓库路径/groupId/artifactId/

注意：每次安装前还会再次执行所有test命令

2.6、mvn tomcat:run

tomcat:run表示部署项目，项目上线运行。能够部署项目都是web项目。

这里演示部署web项目。启动的tomcat并不是使用idea中的tomcat，而是maven自带的。所以我们部署好项目之后发现idea中的tomcat并没有启动。

停止服务器：

**注意：**使用maven在命令行中部署项目，一定要停止idea中的tomcat。否则，在命令行中不会启动成功tomcat。

3、maven生命周期相关插件

​ **maven的核心包只有几兆大小，核心包中仅仅定义了抽象的生命周期。**生命周期的各个阶段都是由插件完成的，它会在需要的时候下载并使用插件，例如我们在执行mvn compile命令时实际是在调用maven的compile插件来编译java源码：

​ 我们使用IDEA创建maven项目后，就不需要再手动输入maven的命令来构建maven的生命周期了。IDEA给每个maven构建项目生命周期各个阶段都提供了图形化界面的操作方式。具体操作如下：

3.1 打开maven视图

​ 依次打开：View–》Tool Windows–》Maven Projects

打开IDEA编辑区右侧:Maven Projects会弹出如下窗口，打开窗口中的Lifecycle即可看到相关命令。

3.2 执行命令

​ 双击Lifecycle下的相关命令图标即可执行对应的命令。或者点击运行按钮：

五、maven应用详解【重点】

​ maven是一个项目管理工具，其中依靠于一个很重要的xml文件：pom.xml。我们接下来学习下pom.xml文件的配置。

1、pom配置详解

​ pom（Project Object Model）指的是项目对象模型，用来描述当前的maven项目。使用pom.xml文件来实现。

pom.xml

<?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.heima.maven</groupId>
    <artifactId>maven-web2</artifactId>
    <version>1.0-SNAPSHOT</version>
  	<packaging>war</packaging>
</project>

【pom文件详解】

1. <project> ：pom文件的根标签，表示当前maven项目；
2. <modelVersion>： 声明项目描述符遵循哪一个POM模型版本。模型本身的版本很少改变，虽然如此，但它仍然是必不可少的，目前POM模型版本是4.0.0；
3. 坐标：定位项目在本地仓库中的位置，下面三个标签组成一个坐标。
    1）<groupId>:maven项目组织id标识符，一般是公司域名倒过来写<groupId>com.heima.maven</groupId>
	2）<artifactId>：项目的标识符--项目名。<artifactId>maven-web2</artifactId>
	3) <version>：项目的版本号；<version>1.0-SNAPSHOT</version>
4. <packaging>：maven项目的打包方式一般配置jar或者war；

2、依赖管理【重点】

Maven的作用：

1.构建项目(maven项目在任何一个开发工具中结构都是一样的)及项目的生命周期；

2.依赖管理；

3.插件管理；

​ Maven的一个核心的作用就是管理项目的依赖，引入我们所需的各种jar包等。为了能自动化的解析任何一个Java构件，**Maven必须将这些Jar包或者其他资源进行唯一标识，这是管理项目的依赖的基础，也就是我们之前说的坐标。**包括我们自己开发的项目，也是要通过坐标进行唯一标识的，这样才能在其它项目中进行依赖引用。

2.1 Maven坐标

坐标的定义元素如下：

1. groupId：定义当前项目（jar包）隶属的实际项目组。
2. artifactId：定义当前项目（jar包）的名称；
3. version：定义当前项目（jar包）的版本号；

通过上面三个参数我们就能够确定一个唯一版本号的jar包。

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>4.1.2.RELEASE</version>
</dependency>

2.2 依赖导入

1、使用IDEA工具导入：

​ IDEA中给我们提供了一种搜索jar包的方式，帮助我们快速导入jar包。使用方法如下：

1. 第一步：在pom.xml文件中书写dependencies标签，鼠标光标移入到dependencies标签中，按Alt+Insert键。会弹出一个选择框：

2. 选择Dependency后会弹出一个搜索框：输入要添加的jar包的名字

​ 选择需要的jar包后按回车键即可自动添加此依赖；

注意：在idea中还可以直接输入要使用的包。

2、从远程仓库中获取坐标：

如果我们导入的依赖本地仓库中没有，使用IDEA搜索就搜索不到了，我们需要从网络中查找这个依赖的坐标，然后将其添加到pom文件中。添加完成之后，maven会帮我们从私服或中央仓库中下载该依赖。

​ 搜索依赖坐标的方法：

1.从私服中获取，联网的情况下可以使用阿里云私服，在教室使用局域网可以连接传智私服。

​ 阿里云私服地址：

http://maven.aliyun.com/nexus/content/groups/public

​ 1）.这里访问阿里云私服

https://maven.aliyun.com

​ 2）.复制上述的依赖到pom.xml文件中。

如果私服中也没有找到那么就只能到中央仓库中查找了。

2.在中央仓库中查找：

网址：

http://mvnrepository.com/

​ 将以下坐标复制到pom文件中即可：

pom文件中引入依赖后，会去私服或者中央仓库中下载依赖：

如果项目结构的External Librarites中出现刚引入的依赖，则说明依赖引入成功。

3、依赖配置

​ 我们通过坐标引入需要的依赖之后，有时候不能直接使用当前的依赖。需要对这些依赖进行配置。这些配置包括：依赖范围设置，依赖版本维护。

maven包括3套运行环境：

1、编译环境:书写完的java代码要进行编译，称为编译环境。

2、测试环境：表示运行test目录下的内容需要的哪些依赖。

3、线上环境：tomcat运行项目时的环境需要哪些依赖。

3.1 依赖范围设置

3.1.1 依赖范围是什么

​ maven在编译 项目主代码的时候需要使用一套环境，在编译和执行测试 的时候需要使用另外一套环境。最后，在实际运行 maven项目的时候又会用到另外一套环境。不同阶段的环境下需要的依赖不同。所以，我们在导入依赖之后，往往会设置依赖的作用范围。

3.1.2 5种依赖范围

依赖范围就是用来控制依赖（jar包）与这三种环境（编译环境，测试环境，运行环境）之间的关系的。各种依赖范围与三种classpath的关系如下图所示：

Maven有以下几种依赖范围：

**compile ：编译依赖范围。**如果没有指定，默认就是这种依赖范围。使用此依赖范围的Maven依赖，对于编译、测试、运行三种环境都有效。

test ：测试依赖范围。使用此依赖范围的Maven依赖，只对测试环境有效。在编译主代码和运行项目期间都不需要使用此依赖。典型的例子就是Junit，它只在编译和运行 测试代码时有效。

provided ：已提供依赖范围。使用此依赖范围的maven依赖在编译和测试环境有效，但运行时无效。典型的例子就是servlet-api。编译和测试的时候需要使用servlet-api中的方法，但是使用tomcat运行项目的时候不需要，因为tomcat在运行期间会提供这个依赖。

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

system ：系统依赖范围。该依赖与三种环境的关系和provided依赖范围完全一致。但是，使用system范围的依赖时必须通过systemPath元素显式地指定依赖文件的路径。由于此依赖不是通过Maven仓库解析的，而且往往与本机系统绑定**，可能造成构建的不可移植**，因此应该谨慎使用。systemPath元素可以引用环境变量。
例如：oracle的驱动包，从中央仓库无法下载，需要先下载到本地，再通过本地路径引入。

3.1.3 指定依赖范围的方法和演示

​ 我们在导入依赖的时候，在标签中使用设置即可，如下所示：

1.test依赖范围

​ 注意:

​ 1）这里强调的运行指的是项目已经发布到tomcat中上线运行。所以不需要测试了，肯定已经测试完毕，没问题了才可以上线运行。

​ 2）编译指的是编译 main目录下的java代码，即即将上线的代码，不是test目录的代码

代码演示如下：

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13</version>
    <!--设置作用范围-->
    <scope>test</scope>
</dependency>

2.compile依赖范围

编译依赖范围。如果没有指定，默认就是这种依赖范围。

使用此依赖范围的Maven依赖，对于编译、测试、运行三种环境都有效。

说明**：对于c3p0数据库连接池的依赖来说，编译如果没有该依赖，那么编译不会通过，那么也不会运行。测试的时候如果没有该依赖那么测试会报错，同样项目上线运行时也必须有该依赖。**

演示代码如下：

<dependency>
    <groupId>com.mchange</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.2</version>
    <scope>compile</scope>
</dependency>

3.provided 依赖范围

说明：编译的时候不提供相关servlet的依赖，那么编译就会报错。而测试的时候没有该依赖，则测试也不会成功。

演示代码如下：

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.5</version>
    <scope>provided</scope>
</dependency>

4.runtime 依赖范围

举例：JDBC的连接接口Connection以及方法不属于mysql驱动包中，属于jdk中。对于mysql驱动编译的时候不需要提供。

					 编译		     测试		  运行
runtime依赖范围	      不需要	      需要       需要  mysql驱动

演示代码如下：

<!--
     JDBC:JDK提供一套接口
     编译：javac  jdk
-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.0.8</version>
    <scope>runtime</scope>
</dependency>

5.system 依赖范围(了解)
例如：oracle的驱动包，从中央仓库无法下载，需要到官网先下载到本地，再通过本地路径引入。先下载oracle的包到本地：

					编译		测试		 运行
system依赖范围	     需要	      需要       不需要  

system ：系统依赖范围：

​ 然后在pom文件中导入依赖：

<dependency>
  <groupId>oracle</groupId>
  <artifactId>ojdbc</artifactId>
  <version>1.0</version>
  <scope>system</scope>
  <systemPath>D:/software/maven/apache-maven-3.5.2/repository/ojdbc6.jar</systemPath>
</dependency>

说明：上述这种方式可移植性不好。因为ojdbc6.jar只存在于本地，如果其他人也使用，那么无法下载使用。

3.2 依赖版本维护

​ 如果pom文件中引入的依赖太多，各种依赖又有不同的版本，为了统一维护版本。我们可以将依赖的版本号抽取出来进行统一管理。

依赖版本统一维护：
1)统一管理jar包;
2)统一管理版本;

抽取方法如下：

第一步 ：在pom.xml中使用属性定义jar包的版本

  <!--统一管理版本-->
    <properties>
        <c3p0.version>0.9.2</c3p0.version>
        <junit.version>4.13</junit.version>
    </properties>

第二步 ：在依赖的中使用**${}**引入前面定义好的版本

<properties>
    <c3p0.version>0.9.2</c3p0.version>
    <junit.version>4.13</junit.version>
</properties>
<dependencies>
    <dependency>
        <groupId>com.mchange</groupId>
        <artifactId>c3p0</artifactId>
        <version>${c3p0.version}</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>${junit.version}</version>
        <!--设置作用范围-->
        <scope>test</scope>
    </dependency>
</dependencies>

好处：

​ 1.方便对项目中使用的jar包版本的统一管理。

​ 2.如果pom.xml文件中具有很多个依赖，那么查找某个依赖版本时还是比较方便的，

​ 同时修改版本号也很方便。

4、maven插件

4.1问题演示

我们在运行javase项目的时候，发现控制台会显示一些1.5已过时的警告。

说明：

当我们点击compile编译的时候发现maven编译的时候使用的插件是：maven-compiler-plugin:3.1:compile (default-compile) 。该插件默认编译的jdk版本是1.5.编译生成的.class文件，让idea中的jdk1.8运行，1.8的jdk运行1.5编译的class文件，会显示已过时字样。所以这里我们需要手动配置下jdk的编译版本，使用jdk1.8.

我们这里需要配置maven的插件。

4.2maven插件介绍

​ 我们都知道Maven本质上是一个插件框架，它的核心并不执行任何具体的构建任务，所有这些任务都交给插件来完成。

​ 例如编译源代码是由maven-compiler-plugin完成的，但是这些插件都是maven默认的插件，如果需要配置自己的插件，则需要通过插件的坐标来引入插件。

插件的坐标可以从maven官方提供的插件列表进行下载：

Maven官方有两个插件列表：

第一个列表的GroupId为org.apache.maven.plugins，这里的插件最为成熟，具体地址为：http://maven.apache.org/plugins/index.html

第二个列表的GroupId为org.codehaus.mojo，这里的插件没有那么核心，但也有不少十分有用，其地址为：http://mojo.codehaus.org/plugins.html

1.访问网址，找到maven插件，然后点击编译compiler

2.点击用量信息页

3.复制插件

4.将上述复制的内容放到build标签里面

<!--插件管理-->
    <build>
        <plugins>
            <!--编译插件：jdk1.8-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <!-- put your configurations here -->
                    <!--源码-->
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

5.清除target编译和运行

使用的编译插件是我们自己配置的版本。

直接运行java代码就不会出现警告信息了。jdk的编译和运行版本统一了。

小结：常用的插件有编译插件和tomcat插件，这两个插件的坐标及配置如下：

4.3 编译插件 maven-compiler-plugin

			<!--JDK编译插件-->
            <!--编译插件：jdk1.8-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <!-- put your configurations here -->
                    <!--源码-->
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>

说明：插件都要放在 plugins标签里面。

4.4 测试插件maven-surefire-plugin

maven的test指令运行测试代码存在中文乱码问题, 用这个插件可以解决

<!--test插件-->
<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-surefire-plugin</artifactId>
  <version>2.16</version>
  <configuration>
    <forkMode>once</forkMode>
    <argLine>-Dfile.encoding=UTF-8</argLine>
  </configuration>
</plugin>

4.5 tomcat插件

注意：tomcat插件一定配置在web项目中。现在tomcat官方给我们最高版本的插件是7.

<!-- tomcat7插件 -->
<plugin>
  <groupId>org.apache.tomcat.maven</groupId>
  <artifactId>tomcat7-maven-plugin</artifactId>
  <version>2.2</version>
  <configuration>
    <port>80</port>
    <path>/</path>
  </configuration>
</plugin>

将上述插件导入web项目中并运行项目步骤：

1.将上述插件导入到web项目中的pom.xml中

<build>
        <plugins>
            <!-- tomcat7插件 -->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <port>80</port>
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
</build>

2.运行插件中的内容

在idea中打开maven

3.在浏览器中访问页面

4.6 插件完整配置

​ 所有的插件必须配置在–>中

 <build>
        <plugins>
           <!--编译插件：jdk1.8-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <!-- put your configurations here -->
                    <!--源码-->
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            
             <!--test插件-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.16</version>
                <configuration>
                    <forkMode>once</forkMode>
                    <argLine>-Dfile.encoding=UTF-8</argLine>
                </configuration>
            </plugin>
            
            <!-- tomcat7插件 -->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <port>80</port>
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
 </build>

附一：完整的pom.xml配置

<?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.sh.heima33</groupId>
    <artifactId>maven-usermanager</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <!--
        依赖管理：
            1、导入依赖：
                idea导入
                私服搜索坐标
            2、依赖范围设置
            3、依赖版本统一维护
       插件管理：
            1、编译插件
    -->
    <!--依赖版本统一管理-->
    <properties>
        <junit.version>4.13</junit.version>
        <servlet.version>3.0.1</servlet.version>
        <jsp.version>2.3.3</jsp.version>
        <beanutils.version>1.8.3</beanutils.version>
        <commons.logging.version>1.1.1</commons.logging.version>
        <jstl.version>1.2</jstl.version>
        <log4j.version>1.2.17</log4j.version>
        <mabatis.version>3.5.0</mabatis.version>
        <mysql.version>8.1.12</mysql.version>
    </properties>

    <!--依赖管理：-->
    <dependencies>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <!--<version>4.13</version>-->
            <version>${junit.version}</version>
            <!--范围：测试存在-->
            <!--<scope>test</scope>-->
        </dependency>
        <!--servlet-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>${servlet.version}</version>
            <!--编译 测试需要，运行时不需要-->
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>${jsp.version}</version>
            <scope>provided</scope>
        </dependency>
        <!--commons-beanutils-->
        <dependency>
            <groupId>commons-beanutils</groupId>
            <artifactId>commons-beanutils</artifactId>
            <version>${beanutils.version}</version>
        </dependency>
        <!--commons-logging-->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>${commons.logging.version}</version>
        </dependency>
        <!--jstl-->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>${jstl.version}</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>${mabatis.version}</version>
        </dependency>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
            <!--编译不需要。测试和运行需要-->
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
    </dependencies>

    <!--插件管理-->
    <build>
        <plugins>
            <!--JDK编译插件-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <!-- put your configurations here -->
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            
            <!--测试插件-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.12.4</version>
                <configuration>
                    <forkMode>once</forkMode>
                    <argLine>-Dfile.encoding=UTF-8</argLine>
                </configuration>
            </plugin>
            
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <port>80</port>
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

附二：清理maven仓库

​ 初始情况下，我们的本地仓库是没有任何jar包的，此时会从私服去下载（如果没有配置，就直接从中央仓库去下载），可能由于网络的原因，jar包下载不完全，这些不完整的jar包都是以lastUpdated结尾。此时，maven不会再重新帮你下载，需要你删除这些以lastUpdated结尾的文件。如果本地仓库中有很多这样的以lastUpadted结尾的文件，可以执行如下脚本来删除：

在上面的bat文件上右键—》编辑 。修改文件：

修改完毕后，双击运行即可删除maven仓库中的残留文件。

附三：更新依赖索引

有时候给idea配置完maven仓库信息后，在idea中依然搜索不到仓库中的jar包。这是因为仓库中的jar包索引尚未更新到idea中。这个时候我们就需要更新idea中maven的索引了，具体做法如下：

打开设置----搜索maven----Repositories----选中本地仓库-----点击Update