第一章 Maven 简介
1.1、Maven 概述
Maven 是一个软件项目管理工具，可以对 Java 项目进行全自动构建，管理项目所需要的依赖。
Maven 曾是 Jakarta 项目的子项目，现为由 Apache 软件基金会主持的独立 Apache 项目。
1.2、Maven 特点
- 遵循最佳实践的简单项目设置，数秒内即可启动新项目或模块
- 在所有项目中使用一致，意味着新开发人员无需花费更多时间来参与项目
- 出色的依赖项管理，包括自动更新，依赖项关闭（也称为传递依赖项）
- 能够轻松同时处理多个项目
- 开箱即用的庞大且不断增长的依赖库，并与最大的开源项目进行了安排，以实时提供其最新版本
- 可扩展，能够轻松用 Java 或脚本语言编写插件
- 几乎无需额外配置即可立即访问新功能
- 用于 Maven 之外的依赖项管理和部署的 Ant 任务
- 基于模型的构建，Maven 能够将任何数量的项目构建为预定义的输出类型，例如 JAR，WAR
- 无需太多额外配置，Maven 将与您的源代码控制系统（例如 Git）集成，并基于特定标签管理项目的发布
1.3、Maven 官网
Maven 官方网址：https://maven.apache.org/
Maven 依赖搜索：https://mvnrepository.com/
第二章 Maven 项目结构
2.1、标准结构
maven-demo（项目名称） |---------pom.xml（项目配置文件） |---------src |---------main（主程序目录） |---------java（主程序的Java源文件目录） |---------resources（主程序的资源文件目录） |---------test（测试程序目录） |---------java（测试程序的Java源文件目录） |---------resources（测试程序的资源文件目录）复制代码 -----------------------------------
接下来，我们就按照标准目录创建一个 Maven工程 ，创建位置，你可以任意。
创建完标准结构以后，我们需要一些代码和配置，来帮助我们完成接下来的学习，在这里，你可以不理解这些代码和配置的含义。
这些代码和配置在这一章节不是重点，后边会讲，重点是标准结构长什么样子，这些代码和配置主要是为了学习接下来的 Maven命令。
找到 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/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <!-- groupId一般为公司或者组织域名的反写 --> <groupId>com.caochenlei</groupId> <!-- artifactId一般为当前项目或者模块的名称 --> <artifactId>maven-demo</artifactId> <!-- version代表当前项目或者模块的版本号 --> <version>0.0.1-SNAPSHOT</version> </project>复制代码
以上仅仅演示了一个标准的 maven 工程应该长什么样子，具体的配置等内容会在后边讲解。
2.2、POM 文件
POM 是 Maven 工程的基本工作单元，是一个 XML 文件，包含了项目的基本信息，用于描述项目如何构建，声明项目依赖等等。
执行任务或目标时，Maven 会在当前目录中查找 POM，读取 POM，获取所需的配置信息，然后执行目标。
POM 中可以指定以下配置等等：
- 项目配置
- 项目版本
- 依赖管理
- 插件管理
- 版本管理
- 构建设置
所有 POM 文件一般都需要 project 根元素和三个必需字段：groupId，artifactId，version。
第三章 Maven 依赖管理
3.1、依赖导入
比如说，我们现在需要导入一个专门处理 JSON 字符串的依赖。
我们只需要知道，你所要导入的工具包的 groupId 、artifactId 、version 这三个标签的信息就可以了。
因为一个真正的项目中，依赖绝不止一个，所以在 pom.xml 就用了依赖的英文单词的复数形式来管理依赖信息，具体格式如下：
<project> ... <dependencies> <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.75</version> </dependency> ... ... 可添加多个依赖 ... ... </dependencies> ... </project>复制代码
3.2、依赖原理
为什么上边知道 groupId 、artifactId 、version 这三个信息 maven 就能自动管理这个依赖了，其实原理很简单。
如果你引入了依赖，maven 就会使用这个依赖的信息拼接字符串，到 maven 的中央仓库去寻找这个依赖，并把它下载下来。
默认下载是下载到了用户的根目录下，也就是 ~/.m2/repository 这个目录中，我们也称这个目录为本地仓库。
maven 中央仓库的地址是： https://repo.maven.apache.org/maven2/
maven 拼接字符串的格式：仓库地址/{groupId}/{artifactId}/{version}/{artifactId}-{version}.jar
注意：groupId 需要把所包含的所有点替换成斜杠
如果是导入上边的 fastjson ，那么这个依赖在 maven 中央仓库的地址也就是：
https://repo.maven.apache.org/maven2/com/alibaba/fastjson/1.2.75/fastjson-1.2.75.jar
这个地址是一个网络地址，你可以把它复制到浏览器地址栏中，然后回车访问一下，这个依赖就能下载下来了。
也有可能你并不能访问，因为 maven 的中央仓库是在外网，在国内访问会很慢，甚至打不开等情况。
3.3、更换仓库
为了解决这些不稳定的情况，国内很多知名的大公司，比如：阿里，它们就自己创建了一个仓库，相当是把 maven 中央仓库里边所有的依赖全部拷到了他们自己的仓库中，并实时更新，同时，向国人也开放了这个仓库的地址，也就是 阿里的maven库 。
现在，maven 默认是从中央仓库去下载，我们想要改变它，就必须告诉他，说你不要去找中央仓库了，太慢了，你去阿里的 maven 库下载吧，既然要告诉他，我们就需要配置一下远程仓库地址。
找到解压后的 maven 目录，进入 conf 目录，找到 settings 文件，在里边找到 mirrors 节点，替换成以下信息：
例如我的是在： C:\DevTools\apache-maven-3.3.9\conf\settings.xml ，强烈建议使用 VSCode 编辑器打开，它会高亮文字。
<mirrors> <mirror> <id>alimaven</id> <mirrorOf>central</mirrorOf> <name>aliyun maven</name> <url>http://maven.aliyun.com/nexus/content/groups/public/</url> </mirror> </mirrors>
同时，因为 maven 默认使用的 JDK 编译版本为 JDK1.5，显然也并不符合我们的要求。
我们需要重新指定版本，只需要找到 profiles 节点，替换成以下信息即可：
<profiles> <profile> <id>jdk1.8</id> <activation> <activeByDefault>true</activeByDefault> <jdk>1.8</jdk> </activation> <properties> <maven.compiler.source>1.8</maven.compiler.source> <maven.compiler.target>1.8</maven.compiler.target> <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion> </properties> </profile> </profiles>
好了，现在仓库地址也更改了，那当他下载 fastjson 依赖的时候，下载地址就应该是：
http://maven.aliyun.com/nexus/content/groups/public/com/alibaba/fastjson/1.2.75/fastjson-1.2.75.jar
为了验证，你也可以把这个地址粘贴到浏览器中，回车，看看它会不会下载。
在上边我们还提到了一个本地仓库，在本地仓库中，你要是想要找到这个依赖也是遵循 maven 的拼接字符串原则，那就成了以下：
C:/Users/CaoChenLei/.m2/repository/com/alibaba/fastjson/1.2.75/fastjson-1.2.75.jar
C:/Users/{自己的用户名}/.m2/repository/ 代表的就是本地仓库的地址。
当然，现在的你可找不到这个文件甚至目录，因为，在上边我们只是讲解了依赖是怎么下载的。
但是现在，我们并没有导入依赖，也没有对 maven 项目（‘maven-demo’）进行任何操作。
他可不知道，你有这么一个依赖需要下载。
3.4、小结一下
到这里，简单梳理一下，本章节你学会了：
- maven 项目如何导入依赖？
在 pom.xml 中添加以下标签
<project> ... <dependencies> <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.75</version> </dependency> ... </dependencies> ... </project>
- maven 是怎么下载依赖的？
利用 groupId 、artifactId 、version 拼接字符串，然后访问下载
http://maven.aliyun.com/nexus/content/groups/public/com/alibaba/fastjson/1.2.75/fastjson-1.2.75.jar
- 中央仓库： maven 官方的、最大的依赖（第三方开源项目、工具、框架、插件等等）存放仓库，但是，国内用户访问速度慢
- 阿里仓库： 阿里仓库也称为远程仓库，它是中央仓库的一份实时拷贝，访问速度快，建议使用此仓库
- 本地仓库： maven 下载依赖后，用于存放依赖的地方，在项目的依赖管理中，首先去本地仓库中查找，本地仓库中有，则使用，没有，则下载，然后存放到本地仓库中，避免每一次都下载，浪费网络带宽
3.5、内心疑问
你怎么知道 groupId 、artifactId 、version 这三个标签的信息？
我们给大家一个网站： mvnrepository.com/
现在访问，好像需要验证码，挺烦人的，我们就以 fastjson 为例，为大家进行演示。
3.6、依赖范围
一个依赖是有自己的作用范围的，一般主要有以下几种情况：
如何设置一个依赖的作用范围，请参考：
<dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.75</version> <!-- 设置依赖范围，主要可取值：compile、test、provided，默认不配就是compile --> <scope>compile</scope> </dependency>复制代码
3.7、依赖的传递性
假设，现在有一个 Hello 项目，它导入了 spring-core 依赖，而开发 spring-core 需要依赖 commons-logging 依赖；
还存在另外一个项目 HelloFriend 他依赖了 Hello 项目，关系如图所示：
依赖的传递有什么好处？
可以传递的依赖不必在每个模块工程中都重复声明，在 “最下面” 的工程中依赖一次即可。
3.8、依赖的排除
假设，现在 commons-logging 这个依赖包是有问题的包，我不想继续使用了，该如何排除呢？
我们这里有一份参考代码，请您参考：
在 HelloFriend 工程的 pom.xml 文件的 dependencies 标签内写入以下代码
<dependency> <groupId>com.hello</groupId> <artifactId>hello</artifactId> <version>0.0.1-SNAPSHOT</version> <!-- 用来排除不想要的依赖包 --> <exclusions> <exclusion> <groupId>commons-logging</groupId> <artifactId>commons-logging</artifactId> </exclusion> </exclusions> </dependency>
3.9、依赖的原则
依赖的原则：它是为了解决工程模块之间的 jar 包冲突的问题的，我们无法设置，maven 有默认的原则，我们需要了解。
- 原则一：路径最短者优先
- 原则二：验证路径相同时，先声明者优先
3.10、依赖的继承
由于非 compile 范围的依赖信息是不能在 “依赖链” 中传递的，所以有需要的工程只能单独配置。例如：
<dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.0</version> <scope>test</scope> </dependency>
此时如果项目需要将各个模块的 junit 版本统一为 4.9，那么到各个工程中手动修改无疑是非常不可取的。
使用继承机制就可以将这样的依赖信息统一提取到父工程模块中进行统一管理。
创建父工程和创建一般的 Java 工程操作一致，唯一需要注意的是：打包方式处要设置为 pom。
而在子工程中只需要引入父工程的工程坐标就可以了。
<parent> <!-- 父工程坐标 --> <groupId>...</groupId> <artifactId>Parent</artifactId> <version>0.0.1-SNAPSHOT</version> <!-- 指定从当前子工程的pom.xml文件出发，查找父工程的pom.xml的路径 --> <relativePath>../Parent/pom.xml</relativePath> </parent>
此时如果子工程的 groupId 和 version 和父工程重复则可以删除。
将 Parent 项目中的 dependencies 标签，用 dependencyManagement 标签括起来。
<dependencyManagement> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.9</version> <scope>test</scope> </dependency> </dependencies> </dependencyManagement>复制代码
在子项目中重新指定需要的依赖，删除范围和版本号。
<dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> </dependency> </dependencies>
第四章 Maven 生命周期
注意：以下是一个简略版的生命周期，足够我们学习了。
清理：删除以前的编译结果，为重新编译做好准备。 编译：将 Java 源程序编译为字节码文件。 测试：针对项目中的关键点进行测试，确保项目在迭代开发过程中关键点的正确性，在每次测试后以标准格式记录和展示测试结果。 打包：将一个包含诸多文件的工程封装为一个压缩文件用于安装或部署。Java 工程对应 jar 包，Web 工程对应 war 包。 安装：在 Maven 环境下特指将打包的结果（jar 包或 war 包）安装到本地仓库中。 发布：将打包的结果部署到远程仓库或将 war 包部署到服务器上运行。
当执行 compile 的时候，会执行从左向右依次执行 compile
当执行 test 的时候，会执行从左向右依次执行 compile、test
当执行 package 的时候，会执行从左向右依次执行 compile、test、package
当执行 install 的时候，会执行从左向右依次执行 compile、test、package、install
当执行 deploy 的时候，会执行从左向右依次执行 compile、test、package、install、deploy
运行任何一个阶段的时候，它前面的所有阶段都会被运行，例如我们运行 mvn install 的时候，代码会被 编译，测试，打包。
这就是 Maven 为什么能够自动执行构建过程的各个环节的原因。
此外，Maven 的插件机制是完全依赖 Maven 的生命周期的，因此理解生命周期至关重要。
第五章 Maven 插件管理
5.1、插件概述
Maven 的核心仅仅定义了抽象的生命周期，具体的任务都是交由插件完成的。
每个插件都能实现多个功能，每个功能就是一个插件目标。
Maven 的生命周期与插件目标相互绑定，以完成某个具体的构建任务。
例如：compile 就是插件 maven-compiler-plugin 的一个目标
Maven 有以下三个标准的生命周期：
clean：项目清理的处理 default(或 build)：项目部署的处理 site：项目站点文档创建的处理（一般不用，所以生命周期没提）
每个生命周期中都包含着一系列的阶段。
这些阶段就相当于 Maven 提供的统一的接口，然后这些阶段的实现由 Maven 的插件来完成。
我们在输入 mvn 命令的时候 比如 mvn clean，clean 对应的就是 Clean 生命周期中的 clean 阶段。
但是 clean 的具体操作是由 maven-clean-plugin （内置了，不用我们手动添加）来实现的。
所以说 Maven 生命周期的每一个阶段的具体实现都是由 Maven 插件实现的。
Maven 实际上是一个依赖插件执行的框架，每个任务实际上是由插件完成。
Maven 插件通常被用来：
- 创建 jar 文件
- 创建 war 文件
- 编译代码文件
- 代码单元测试
- 创建工程文档
- 创建工程报告
Maven 提供了下面两种类型的插件：
5.2、插件配置
我们接下来主要讲解在工程 POM.XML 文件中如何配置一个插件？
找到 POM.XML 在根标签内添加以下代码，插件名和版本仅供参考，具体添加什么插件，取决于你。
<build> <plugins> <!-- 编译插件 --> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.2</version> <configuration> <source>1.8</source> <target>1.8</target> <encoding>UTF-8</encoding> </configuration> </plugin> ... ... </plugins> </build>
5.3、常用插件
- maven-resources-plugin
插件描述：该插件处理项目的资源文件拷贝到输出目录，可以分别处理 main resources 和 test resources。
<build> <plugins> <!-- 依赖插件 --> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-resources-plugin</artifactId> <version>3.0.1</version> <configuration> <encoding>UTF-8</encoding> </configuration> </plugin> </plugins> </build>
- maven-compiler-plugin
插件描述：设置 maven 编译的 jdk 版本，maven3 默认用 jdk1.5，maven2 默认用 jdk1.3，除了配置maven安装目录/config/settings.xml文件，也可以使用 maven-compiler-plugin 进行指定
<build> <plugins> <!-- 依赖插件 --> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.2</version> <configuration> <source>1.8</source> <target>1.8</target> <encoding>UTF-8</encoding> </configuration> </plugin> </plugins> </build>
- maven-source-plugin
插件描述：该插件处理打包项目的源代码。
<build> <plugins> <!-- 依赖插件 --> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-source-plugin</artifactId> <executions> <execution> <id>attach-sources</id> <goals> <goal>jar</goal> </goals> </execution> </executions> </plugin> </plugins> </build>
- maven-dependency-plugin
<build>
<plugins>
<!-- 依赖插件 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<version>2.6</version>
<executions>
<execution>
<id>copy-dependencies</id>
<phase>compile</phase>
<goals>
<goal>copy-dependencies</goal>
</goals>
<configuration>
<!-- ${project.build.directory}为Maven内置变量，缺省为target -->
<outputDirectory>${project.build.directory}/lib</outputDirectory>
<!-- 表示是否不包含间接依赖的包 -->
<excludeTransitive>false</excludeTransitive>
<!-- 表示复制的jar文件去掉版本信息 -->
<stripVersion>true</stripVersion>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
第六章 Maven 变量信息
6.1、内置变量
主要有两个常用内置属性：${basedir}项目的根目录 (包含 pom.xml 文件的目录)，${version}项目版本
#用户可以使用该属性引用POM文件中对应元素的值，常用的POM属性包括：
${project.build.sourceDirectory}：项目的主源码目录，默认为 src/main/java
${project.build.testSourceDirectory}：项目的测试源码目录，默认为 src/test/java
${project.build.directory}：项目构件输出目录，默认为 target/
${project.outputDirectory}：项目主代码编译输出目录，默认为 target/classes/
${project.testOutputDirectory}：项目测试代码编译输出目录，默认为 target/test-classes/
${project.groupId}：项目的 groupId
${project.artifactId}：项目的 artifactId
${project.version}：项目的 version，与${version}等价
${project.build.fianlName}：项目打包输出文件的名称。默认为${project.artifactId}-${project.version}
#获取环境变量属性，所有环境变量都可以使用以env.开头的Maven属性引用
${env.xxx}：获取系统环境变量；
#获取Settings属性，用户使用settings.开头的属性引用 settings.xml 文件中XML元素的值
${settings.xxx}：获取settings.xml中对应元素的值；复制代码
6.2、自定义变量
如何定义
<project> ... <properties> <变量名>变量值</变量名> </properties> ... </project>
如何引用
${变量名}
案例演示
<project>
...
<properties>
<junit.version>3.8.1</junit.version>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
...
</project>
第七章 Maven 模块化开发
7.1、概述
为什么要模块化开发？
一个工程往往会有很多代码文件，也会分为很多层，比如传统的 mvc：controller、service、dao 等等。
时间一场，随着项目开发的越来越大，这些文件和层次越来越多，放到一个工程中也越来越难管理。
而且，比如 dao 层，可能不止这一个项目用到了，其他项目也有可能用到，以前的所有代码放到一个工程中，你在抽取的时候会很麻烦。
现在经过模块化划分之后，各个层次结构之间可以相互依赖，大大提高了项目的开发进度。
在未来的微服务架构中，这一点也有很好的体现。
值得一提的是，模块与模块之间可以相互依赖，由父工程进行所有依赖版本的管理，减少了开发中很多不必要的工作。
模块化开发是在依赖继承的基础上进行的，所以你有必要去了解一下依赖继承。
7.2、Eclipse 中演示
7.2.1、创建父项目
9.2.2、创建子项目
父工程的 pom.xml：
子工程的 pom.xml：
