【Java】项目管理工具Maven的安装与使用

1. Maven概述

1.Maven简介：maven是一个项目管理工具，将项目开发和管理过程抽象成一个项目对象模型（POM）。

注：POM（Project Object Model）：项目对象模型

maven管理项目流程如下：

2.Maven的作用

• 项目构建：提供标准的、跨平台的自动化项目构建方式
• 依赖管理：方便快捷的管理项目依赖的资源（jar包），避免资源间的版本冲突问题
• 统一开发结构：提供标准的、统一的项目结构

3.Maven仓库

• 仓库：用于存储资源， 包含各种jar包
• 仓库分类：
  • 本地仓库：自己电脑上存储资源的仓库，连接远程仓库获取资源
  • 远程仓库：非本机电脑上的仓库，为本地仓库提供资源
    • 中央仓库：Maven团队维护， 存储所有资源的仓库
    • 私服：部门/公司范围内存储资源的仓库，从中央仓库获取资源
• 私服的作用：
  • 保存具有版权的资源， 包含购买或自主研发的jar（中央仓库中的jar都是开源的， 不能存储具有版权的资源）
  • 一定范围内共享资源，仅对内部开放，不对外共享

4.Maven坐标

• 坐标概念：Maven中的坐标用于描述仓库中资源的位置
• 坐标的主要组成
  • groupId：组织id，定义当前Maven项目隶属组织名称(通常是域名反写， 例如：org.mybatis)
  • artifactld：项目id，定义当前Maven项目名称(通常是模块名称， 例如CRM、SMS)
  • version：版本号，定义当前项目版本号
• 坐标的作用：使用唯一标识，唯一性定位资源位置，通过该标识可以将资源的识别与下载工作交由机器完成

2. Maven的下载与安装

2.1 下载

官网下载：

• 最新版本：https://maven.apache.org/download.cgi
• 历史版本：https://archive.apache.org/dist/maven/maven-3/

最新版本：

历史版本：

2.2 安装

此处下载得到最新的 apache-maven-3.9.3-bin.zip 安装包，放在任意一个文件夹下，右键解压到当前文件夹。

此处我解压到 E:\Applications\apache-maven-3.9.3

配置环境变量：

1.新建 MAVEN_HOME 环境变量，变量值为maven安装路径

• 变量名：MAVEN_HOME
• 变量值：E:\Applications\apache-maven-3.9.3

2.修改 Path 变量

在 系统变量 中选中 Path 变量后，点击 “编辑” 按钮，随后点击“新建”，输入 %MAVEN_HOME%\bin 即可

3.输入命令，测试是否安装成功

mvn -v

出现以下界面，表示安装成功：

3. Maven仓库配置

3.1 修改本地仓库配置

本地仓库：maven启动后，会自动保存下载的资源到本地仓库

• 默认位置：登录用户名所在目录的.m2文件夹中，如 C:\Users\Admin\.m2\repository（默认保存到C盘）

<localRepository>${user.name}\.m2\repository</localRepository>

• 自定义位置：修改本地仓库位置为指定路径，如 D:\repository

<localRepository>D:\repository</localRepository>

由于默认保存到C盘，所以要修改本地仓库配置，步骤如下：

1.找到安装包的conf文件夹下的settings.xml文件，使用 vscode 或者其他工具打开它

2.Ctrl+F搜索 localRepository，复制刚刚的自定义配置到这里即可

3.2 修改远程仓库配置

远程仓库：为本地仓库提供资源的仓库，资源从远程仓库下载到本地仓库。

1.默认远程仓库：

<repositories>
	<repository>
		<id>central</id>
		<name>Central Repository</name>
		<url>https://repo.maven.apache.org/maven2</url>
		<layout>default</layout>
		<snapshots>
			<enabled>false</enabled>
		</snapshots>
	</repository>
</repositories>

2.镜像远程仓库：

镜像仓库配置：

• id：镜像的唯一标识，用来区分不同的mirror元素
• mirrorOf：对哪个仓库进行镜像，简单来说就是替代哪个仓库，此处填为central，也就是替代了默认远程仓库
• name：镜像名称
• url：镜像URL

修改镜像仓库地址：修改镜像仓库地址是为了加快下载速度，此处修改为阿里云镜像，远程仓库的地址从国外转到了国内，下载速度自然就快了

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

依然还是修改E:\Applications\apache-maven-3.9.3\conf文件夹下的settings.xml文件：

3.3 修改后的settings.xml

<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.2.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.2.0 https://maven.apache.org/xsd/settings-1.2.0.xsd">
    <localRepository>D:\repository</localRepository>
    <mirrors>
        <mirror>
            <id>nexus-aliyun</id>
            <mirrorOf>central</mirrorOf>
            <name>Nexus aliyun</name>
            <url>http://maven.aliyun.com/nexus/content/groups/public</url>
        </mirror>
    </mirrors>
</settings>

4. 使用Maven创建项目

Maven工程的目录结构如下：左边是Java项目，右边是Web项目。

可以发现Web项目就是比Java项目多了个webapp目录

4.1 手工创建Java项目

由于 Idea 创建的maven一开始是没有 settings.xml 的，所以每次创建新 maven工程的时候，会使用默认的 settings.xml配置，也就是使用默认的本地仓库地址和远程仓库地地址。

• 默认本地仓库地址：${user.name}\.m2\repository
• 默认远程仓库地址：https://repo.maven.apache.org/maven2

前置工作：将上述修改好的 apache-maven-3.9.3\conf\settings.xml文件，复制到${user.name}\.m2\repository文件夹下，则每次创建新 maven项目，会默认使用该配置，可以解决刚启动项目时，下载jar包速度慢的问题。

1.New Project，创建新项目

2.填写项目名称等信息，Build System勾选Maven

手工创建Java项目，得到的Maven工程结构如下：

3.修改项目的maven配置，打开 Settings并在搜索框输入maven，修改以下内容即可

注：每次创建或导入一个maven项目的时候，maven配置都会使用默认配置，因此每次都需要重新修改它的maven配置

4.2 原型创建Java项目

ArcheType选择org.apache.maven.archetypes:maven-archetype-quickstart，就能使用原型创建Java工程项目

注：使用原型创建maven项目的方式，会下载一些jar包，所以项目构建需要等待一段时间。

使用原型创建Java项目，得到的Maven工程结构如下：

4.3 原型创建Web项目

ArcheType：选择org.apache.maven.archetypes:maven-archetype-webapp，就能使用原型创建 Web工程项目

注：使用原型创建maven项目的方式，会下载一些jar包，所以项目构建需要等待一段时间。

使用原型创建Web项目，得到的Maven工程结构如下：

以该Web项目为例，由于其结构缺失，需要手动补充文件夹，使其称为完整的Web项目工程：

• main目录下新建java目录，并将其标记为 Sources Root
• src目录下新建test目录，并在test目录下新建java和resources
• 标记test目录下的java为 Test Sources Root，resources为Test Resources Root

最终Web项目结构如下：

5. Tomcat启动Web项目

5.1 使用Tomcat插件启动项目

mvnrepository官网地址：https://mvnrepository.com/

1.搜索框中输入tomcat maven，点击Search进行搜索，找到 Apache Tomcat Maven Plugin :: Common API，然后点击org.apache.tomcat.maven链接进入

注意：是点击org.apache.tomcat.maven蓝色链接，而不是点击 Apache Tomcat Maven Plugin :: Common API黑体字，点击黑体字进去的链接是找不到 tomcat 插件的

2.Apache Tomcat Maven Plugin :: Tomcat 7.x，点击链接进入，继续选择一个版本点击进入

3.得到了Tomcat7插件的 groupId、artifactId、version，并复制到pom.xml中，就完成了插件的安装

4.最终得到pom.xml内容如下

<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>maven-project</artifactId>
  <packaging>war</packaging> <!--打包方式为war包-->
  <version>1.0-SNAPSHOT</version>

  <name>maven-project Maven Webapp</name>
  <url>http://maven.apache.org</url>

  <!--构建项目需要的信息-->
  <build>
    <!--插件列表-->
    <plugins>
        <!--安装tomcat7插件-->
        <plugin>
            <groupId>org.apache.tomcat.maven</groupId>
            <artifactId>tomcat7-maven-plugin</artifactId>
            <version>2.2</version>
        </plugin>
    </plugins>
  </build>

</project>

5.打开maven侧边栏，找到tomcat7插件，点击tomcat7:run，启动tomcat服务器

6.运行后会在末尾出显示一个链接，就是本地项目的地址，点击该链接即可查看web项目。

点击 http://localhost:8080/maven-project，弹出页面如下：

之所以页面会显示Hello World!，是因为使用原型创建web项目时，自动创建了一个index.jsp，内容如下：

注：如果不想使用默认的8080端口和默认路径，可以进行以下配置修改

<!--构建项目需要的信息-->
<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>

再次启动 tomcat，访问以下地址即可：http://localhost:80/

另外，还可以进行如下配置操作，用于简化tomcat服务器的启动：

idea右上角，Current File 下拉框选择 Edit Configurations

点击 + 号，选择 Maven

填写配置名称、命令行以及选择应用到哪个工程

以后就可以使用如下方式启动tomcat服务器了

5.2 本地安装Tomcat启动项目

5.2.1 下载并安装Tomcat

1.下载 tomcat，此处以tomcat9为例

官网地址：https://tomcat.apache.org/

点击左边栏Download下的Tomcat9

点击 64-bit Windows zip (pgp, sha512)链接进行下载，得到apache-tomcat-9.0.78-windows-x64.zip压缩包

2.安装 tomcat，把压缩包放到任意一个文件夹下解压，选择解压到当前文件夹，即可安装成功

此处我解压到 E:\Applications\apache-tomcat-9.0.78

3.配置tomcat环境变量

新建一个变量如下：

• 变量名：CATALINA_HOME
• 变量值：E:\Applications\apache-tomcat-9.0.78

修改path变量，新增 %CATALINA_HOME%\bin

4.验证是否配置成功：打开cmd，输入 startup.bat回车

注：执行这步之前，先检查其他地方是否关闭了tomcat，否则会出现端口号（8080）占用的情况，导致启动失败（如检查Idea中是否停止运行了tomcat插件）

启动完成后，打开浏览器输入 http://localhost:8080，出现如图所示，说明安装配置成功了

注：上述运行 startup.bat脚本时，出现的乱码问题，可以通过修改 apache-tomcat-9.0.78\conf\logging.properties解决

打开logging.properties文件，搜索 java.util.logging.ConsoleHandler.encoding = UTF-8，把 UTF-8改为GBK即可：

java.util.logging.ConsoleHandler.encoding = GBK

此时再重启 startup.bat脚本，就没有了乱码问题：

5.2.2 本地Tomcat启动项目

本地tomcat安装配置完成后，再进行以下三步即可启动web项目：

• 打包war包
• 把war包放到 webapps 目录下
• 启动 startup.bat 脚本

1.打包war包：打开maven侧边栏，找到 Lifecycle，并点击 package，等待构建完成会在target文件夹下生成一个war包，此处为maven-project-1.0-SNAPSHOT.war

2.将 maven-project-1.0-SNAPSHOT.war 放到 apache-tomcat-9.0.78\webapps文件夹下

3.启动 startup.bat脚本，启动完成后，在浏览器输入项目地址，即可查看web项目

项目地址组成： http://localhost:8080/，后面再加上war包名称

以我刚刚运行的项目为例，地址就是 http://localhost:8080/maven-project-1.0-SNAPSHOT

6. Maven的依赖管理

6.1 依赖配置

依赖：指的是当前项目运行所需的jar包，一个项目可以设置多个依赖

<!-- 设置当前项目所依赖的所有jar -->
<dependencies>
    <!-- 设置具体的依赖 -->
    <dependency>
        <groupId>junit</groupId> <!-- 依赖所属群组id -->
        <artifactId>junit</artifactId> <!-- 依赖所属项目id -->
        <version>3.8.1</version> <!-- 依赖版本号 -->
    </dependency>
</dependencies>

6.2 依赖传递

6.2.1 依赖传递演示

依赖具有传递性：

• 直接依赖：在当前项目中通过依赖配置建立的依赖关系
• 间接依赖：被依赖具的资源如果依赖其他资源，当前项目间接依赖其他资源

1.创建一个空项目maven-project，然后在项目下面创建三个模块，分别取名project01、project02、project03

创建空工程：

创建三个模块：右键 maven-project -> New -> Module

最终得到项目结构如下：

2.对三个模块的pom.xml进行以下修改

• project01、project02、project03中分别添加 log4j 的 1.2.12、1.2.13、1.2.14 的版本依赖
• project01中添加junit 4.12版本的依赖
• 把project03作为依赖资源添加到project02中

注：如果当前项目，想使用另一个项目的东西，那么就把另一个项目作为依赖资源添加到当前项目中

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

    <!--project01的项目坐标-->
    <groupId>com.example</groupId>
    <artifactId>project01</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!--添加log4j依赖-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>
        <!--添加junit依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

</project>

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

    <!--project02的项目坐标-->
    <groupId>com.example</groupId>
    <artifactId>project02</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!--添加log4j依赖-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.13</version>
        </dependency>
        <!--添加project03依赖-->
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>project03</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>

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

    <!--project03的项目坐标-->
    <groupId>com.example</groupId>
    <artifactId>project03</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!--添加log4j依赖-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.14</version>
        </dependency>
    </dependencies>

</project>

3.以上配置完成后，点击Maven的刷新按钮，可以看到最终依赖的结构如下：

• 使用红色框圈中的依赖jar包为直接依赖
• 使用紫色框圈中的依赖jar包为间接依赖

解释：
1.对于project01项目而言，直接依赖了log4j:log4j:1.2.12和junit:junit:4.12，间接依赖了 org:hamcrest:hamcrest-core:1.3
2.对于project02项目而言，直接依赖了log4j:log4j:1.2.13和com.example:project03:1.0-SNAPSHOT，间接依赖了log4j:log4j:1.2.14
3.对于project03项目而言，直接依赖了log4j:log4j:1.2.14

6.2.2 依赖传递冲突

依赖传递冲突问题：

• 路径优先：当依赖中出现相同资源时，层级越深，优先级越低，反之优先级越高。
• 声明优先：当资源在相同层级被依赖时，配置顺序靠前的覆盖顺序靠后的。

特殊优先：当同级配置了相同资源的不同版本，后配置的覆盖先配置的

1.路径优先：当依赖中出现相同资源时，层级越深，优先级越低，反之优先级越高。

此处project02项目中同时依赖了log4j的1.2.13和1.2.14版本，由于1.2.13是直接依赖，层级更浅，优先级更高，所以最终使用的是1.2.13的版本依赖。

注：idea中log4j的1.2.14版本依赖颜色显示灰色，表示它未生效。

2.声明优先：当资源在相同层级被依赖时，配置顺序靠前的覆盖顺序靠后的。

对 project01、project02、project03，3个模块项目的pom.xml进行以下修改：

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

    <!--project01的项目坐标-->
    <groupId>com.example</groupId>
    <artifactId>project01</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!--添加project03依赖-->
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>project03</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <!--添加project02依赖-->
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>project02</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>

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

    <!--project02的项目坐标-->
    <groupId>com.example</groupId>
    <artifactId>project02</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!--添加log4j依赖-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.13</version>
        </dependency>
    </dependencies>

</project>

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

    <!--project03的项目坐标-->
    <groupId>com.example</groupId>
    <artifactId>project03</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!--添加log4j依赖-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.14</version>
        </dependency>
    </dependencies>

</project>

最终的依赖结构如下：在project01 的pom.xml中，先添加了project03的依赖，后添加了project02的依赖，它们的log4j依赖在同一个层级，由于project03先添加，所以project03的log4j 1.2.14依赖生效了。

3.特殊优先：当同级配置了相同资源的不同版本，后配置的覆盖先配置的

对project02的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>

    <!--project02的项目坐标-->
    <groupId>com.example</groupId>
    <artifactId>project02</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!--添加log4j依赖，1.2.13版本-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.13</version>
        </dependency>
        <!--添加log4j依赖，1.2.14版本-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.14</version>
        </dependency>
    </dependencies>

</project>

同一个pom.xml里写了两份一样的依赖，后配置的依赖覆盖前面的，所以此处最终是1.2.14版本的log4j生效。

6.3 可选依赖

可选依赖：指对外隐藏当前所依赖的资源（不透明）

也就是说，其他使用该依赖资源的人，不知道使用了它，因为该依赖资源被隐藏了

依赖中添加optional配置为true，即可隐藏依赖：

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <optional>true</optional> <!--隐藏依赖-->
</dependency>

演示：原始的project01和project02的pom.xml配置如下

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

    <!--project01的项目坐标-->
    <groupId>com.example</groupId>
    <artifactId>project01</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!--添加project02依赖-->
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>project02</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>

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

    <!--project02的项目坐标-->
    <groupId>com.example</groupId>
    <artifactId>project02</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!--添加junit依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

</project>

此时能看见junit依赖：

然后修改project02的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>

    <!--project02的项目坐标-->
    <groupId>com.example</groupId>
    <artifactId>project02</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!--添加junit依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <optional>true</optional> <!--隐藏依赖-->
        </dependency>
    </dependencies>

</project>

点击刷新按钮后，发现junit依赖不见了（被隐藏了）：

6.4 排除依赖

排除依赖：指主动断开依赖的资源，被排除的资源无需指定版本（不需要）

也就是说，自己不需要使用别人的依赖资源，主动排除了它

依赖中添加exclusion，并指定groupId 和 artifactId，即可排除依赖：

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <exclusions>
        <!--排除依赖-->
        <exclusion>
            <groupId>org.hamcrest</groupId>
            <artifactId>hamcrest-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>

演示：修改project01和project02的pom.xml配置为以下
project01的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>

    <!--project01的项目坐标-->
    <groupId>com.example</groupId>
    <artifactId>project01</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!--添加project02依赖-->
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>project02</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>

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

    <!--project02的项目坐标-->
    <groupId>com.example</groupId>
    <artifactId>project02</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!--添加junit依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

</project>

此时能看见junit中还依赖了org.hamcrest:hamcrest-core:1.3：

然后修改project02的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>

    <!--project02的项目坐标-->
    <groupId>com.example</groupId>
    <artifactId>project02</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!--添加junit依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <exclusions>
                <!--排除依赖-->
                <exclusion>
                    <groupId>org.hamcrest</groupId>
                    <artifactId>hamcrest-core</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

</project>

点击刷新按钮后，发现org.hamcrest:hamcrest-core:1.3依赖不见了（被排除了）：

6.5 依赖范围

依赖范围：依赖的jar包默认情况下，可以在任何地方使用，可以通过scope标签设定其作用范围。

作用范围：

• 主程序范围内有效（main文件夹范围内）
• 测试程序范围内有效（test文件夹范围内）
• 是否参与打包（package指令范围内）

范围	主代码	测试代码	打包	例子
compile	√	√	√	log4j
test		√		junit
provided	√	√		servlet-api
runtime			√	jdbc

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope> <!--测试范围-->
</dependency>

注：带有依赖范围的资源在进行传递时，作用范围将受到影响

7. 生命周期与插件

maven项目构建命令如下：

# 编译
mvn compile

# 清理
mvn clean 

# 测试
mvn test 

# 打包
mvn package 

# 安装到本地仓库
mvn install 

这些maven项目构建命令在Idea中对应的位置如下：

7.1 构建生命周期

一个典型的 Maven 构建（build）生命周期是由以下几个阶段的序列组成的：

阶段	处理	描述
validate	验证项目	验证项目是否正确且所有必须信息是可用的
compile	执行编译	源代码编译在此阶段完成
test	测试	使用适当的单元测试框架（例如junit）运行测试
package	打包	创建 jar/war 包如在 pom.xml 中定义提及的包
verify	检查	对集成测试的结果进行检查，以保证质量达标
install	安装	安装打包的项目到本地仓库，以供其他项目使用
deploy	部署	拷贝最终的工程包到远程仓库中，以共享给其他开发人员和工程

Maven 有以下三个标准的生命周期：

• clean：项目清理的处理，清理工作
• default：项目部署的处理，核心工作，例如编译、测试、打包、部署等
• site：项目站点文档创建的处理，产生报告，发布站点

1.clean 生命周期

生命周期阶段	描述
pre-clean	执行一些需要在clean之前完成的工作
clean	移除所有上一次构建生成的文件
post-clean	执行一些需要在clean之后立刻完成的工作

2.default (build) 生命周期

生命周期阶段	描述
validate（校验）	校验项目是否正确并且所有必要的信息可以完成项目的构建过程
initialize（初始化）	初始化构建状态，比如设置属性值
generate-sources（生成源代码）	生成包含在编译阶段中的任何源代码
process-sources（处理源代码）	处理源代码，比如说，过滤任意值
generate-resources（生成资源文件）	生成将会包含在项目包中的资源文件
process-resources （处理资源文件）	复制和处理资源到目标目录，为打包阶段最好准备
compile（编译）	编译项目的源代码
process-classes（处理类文件）	处理编译生成的文件，比如说对Java class文件做字节码改善优化
generate-test-sources（生成测试源代码）	生成包含在编译阶段中的任何测试源代码
process-test-sources（处理测试源代码）	处理测试源代码，比如说，过滤任意值
generate-test-resources（生成测试资源文件）	为测试创建资源文件
process-test-resources（处理测试资源文件）	复制和处理测试资源到目标目录
test-compile（编译测试源码）	编译测试源代码到测试目标目录
process-test-classes（处理测试类文件）	处理测试源码编译生成的文件
test（测试）	使用合适的单元测试框架运行测试（Juint是其中之一）
prepare-package（准备打包）	在实际打包之前，执行任何的必要的操作为打包做准备
package（打包）	将编译后的代码打包成可分发格式的文件，比如JAR、WAR或者EAR文件
pre-integration-test（集成测试前）	在执行集成测试前进行必要的动作，比如说，搭建需要的环境
integration-test（集成测试）	处理和部署项目到可以运行集成测试环境中
post-integration-test（集成测试后）	在执行集成测试完成后进行必要的动作。比如说，清理集成测试环境
verify （验证）	运行任意的检查来验证项目包有效且达到质量标准
install（安装）	安装项目包到本地仓库，这样项目包可以用作其他本地项目的依赖
deploy（部署）	将最终的项目包复制到远程仓库中与其他开发者和项目共享

3.site 生命周期

生命周期阶段	描述
pre-site	执行一些需要在生成站点文档之前完成的工作
site	生成项目的站点文档
post-site	执行一些需要在生成站点文档之后完成的工作，并且为部署做准备
site-deploy	将生成的站点文档部署到特定的服务器上

7.2 插件

插件：每个生命周期中都包含着一系列的阶段(phase)，这些 phase 就相当于 Maven 提供的统一的接口，然后这些 phase 的实现由 Maven 的插件来完成。

• 插件与生命周期内的阶段绑定，在执行到对应生命周期时执行对应的插件功能
• 默认maven在各个生命周期上绑定有预设的功能
• 通过插件可以自定义其他功能

我们在输入 mvn 命令的时候 比如 mvn clean，clean 对应的就是 Clean 生命周期中的 clean 阶段，但是 clean 的具体操作是由 maven-clean-plugin 来实现的，所以说 Maven 生命周期的每一个阶段的具体实现都是由 Maven 插件实现的。

插件类型：

类型	描述
Build plugins	在构建时执行，并在 pom.xml 的 元素中配置
Reporting plugins	在网站生成过程中执行，并在 pom.xml 的 元素中配置

常用插件的列表：

插件	描述
clean	构建之后清理目标文件，删除目标目录
compiler	编译 java 源文件
surefile	运行 junit单元测试，创建测试报告
jar	从当前工程中构建 jar 文件
war	从当前工程中构建 war 文件
javadoc	为工程生成 javadoc
antrun	从构建过程的任意一个阶段中运行一个 ant 任务的集合

插件示例：

<build>
    <plugins>
    	<!--生成源代码的插件-->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-source-plugin</artifactId>
            <version>3.2.1</version>
            <executions>
                <execution>
                    <goals>
                        <goal>jar</goal>
                    </goals>
                    <phase>generate-test-resources</phase> <!--到生成测试源代码阶段，执行该插件-->
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

点击刷新后可以发现 Plugins下多了个 source插件，就是刚刚添加 maven-source-plugin插件

测试插件是否有效：由于generate-test-resources阶段在test阶段之前，也就是说执行到test阶段，也必然执行了generate-test-resources阶段，所以，我们点击 Lifecycle下的test按钮，使项目执行到test阶段。

可以看到，左侧生成了一个源码的jar包，打开该jar包，就能查看项目的源码。