Maven详解

白熊bro

已于 2024-09-07 15:14:02 修改

阅读量1k

点赞数 14

文章标签： maven java

于 2024-09-07 15:11:32 首次发布

本文链接：https://blog.csdn.net/bear_309/article/details/141996476

版权

Maven 依赖管理项目构建工具

一、Maven 简介

1. Maven 能干什么

1.1 Maven 是一个依赖管理工具

没有使用 Maven 之前，我们可能会遇到的问题：

问题1：jar 包的规模越来越大

之前阶段的学习中，我们 jar 包也就 3-5 个，随着后面框架的学习以及上班后项目的开发，那 jar 包的规模是越来越大，一个项目模块中导入成百上千的 jar 包是很正常的。

比如下面的例子，我们只用到 SpringBoot、SpringCloud 框架中的三个功能：

- Nacos 服务注册发现
- Web 框架环境
- 视图模板技术 Thymeleaf

最终却导入了 106 个 jar 包：

org.springframework.security:spring-security-rsa:jar:1.0.9.RELEASE:compilecom.netflix.ribbon: ribbon:jar:2.3.0:compileorg.springframework.boot:spring-boot-starter-thymeleaf:jar:2.3.6.RELEASE:compilecommons-configuration:commons-configuration:jar:1.8:compileorg.apache.logging.log4j:log4j-api:jar:2.13.3:compileorg.springframework:spring-beans:jar:5.2.11.RELEASE:compileorg.springframework.cloud:spring-cloud-starter-netflix-ribbon:jar:2.2.6.RELEASE:compileorg.apache.tomcat.embed:tomcat-embed-websocket:jar:9.0.39:compilecom.alibaba.cloud:spring-cloud-alibaba-commons:jar:2.2.6.RELEASE:compileorg.bouncycastle:bcprov-jdk15on:jar:1.64:compileorg.springframework.security:spring-security-crypto:jar:5.3.5.RELEASE:compileorg.apache.httpcomponents:httpasyncclient:jar:4.1.4:compilecom.google.j2objc:j2objc-annotations:jar:1.3:compilecom.fasterxml.jackson.core:jackson-databind:jar:2.11.3:compileio.reactivex:rxjava:jar:1.3.8:compilech.qos.logback:logback-classic:jar:1.2.3:compileorg.springframework:spring-web:jar:5.2.11.RELEASE:compileio.reactivex:rxnetty-servo:jar:0.4.9:runtimeorg.springframework:spring-core:jar:5.2.11.RELEASE:compile

....

而如果使用 Maven 来引入这些 jar 包只需要配置三个『依赖』：

<!-- Nacos 服务注册发现启动器 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

<!-- web启动器依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- 视图模板技术 thymeleaf -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

问题2：jar 包的来源

- 这个 jar 包所属技术的官网。官网通常是英文界面，网站的结构又不尽相同，甚至找到下载链接还发现需要通过特殊的工具下载
- 第三方网站提供下载。问题是不规范，在使用过程中会出现各种问题

- - jar 包的名称
  - jar 包的版本
  - jar 包内的具体细节

- 而使用 Maven 后，依赖对应的 jar 包能够自动下载，方便、快捷又规范

问题3：jar 包的导入问题

- 在 web 工程中，jar 包必须存放在指定位置：

- 在使用 Maven 之后，通过配置依赖(jar包)的坐标，查找本地仓库中相应 jar 包，若本地仓库没有，则统一从镜像网站或中央仓库中下载即可

问题4：jar 包之间的依赖

框架中使用的 jar 包，不仅数量庞大，而且彼此之间存在错综复杂的依赖关系。另外，jar 包之间有可能产生冲突。进一步增加了我们在 jar 包使用过程中的难度。

下面是前面例子中 jar 包之间的依赖关系：

使用 Maven 则几乎不需要管理这些关系，极个别的地方调整一下即可，极大的减轻了我们的工作量。

1.2 Maven 是一个构建工具

之前我们没用 Maven，但是构建是由 IDEA 帮我们做的
脱离 IDE 环境仍需构建

1.3 小结

管理规模庞大的 jar 包，需要专门工具
脱离 IDE 环境执行构建操作，需要专门工具

2. Maven 介绍

Maven 是一款为 Java 项目管理构建、依赖管理的工具（软件），使用 Maven 可以自动化构建、测试、打包和发布项目，大大提高了开发效率和质量。

依赖管理：

Maven 可以管理项目的依赖，包括自动下载所需依赖库、自动下载需要的依赖并且保证版本没有冲突、依赖版本管理等。通过 Maven，我们可以方便地维护项目所依赖的外部库，避免版本冲突和转换错误等，而我们仅仅需要编写配置即可。

项目构建：

项目构建是指将源代码、配置文件、资源文件等转化为能够运行或部署的应用程序或库的过程。

Maven 可以管理项目的编译、测试、打包、部署等构建过程。通过实现标准的构建生命周期，Maven 可以确保每一个构建过程都遵循同样的规则和最佳实践。同时，Maven 的插件机制也使得开发者可以对构建过程进行扩展和定制。主动触发构建，只需要简单的命令操作即可。

场景1： 例如我们项目需要第三方依赖如：Druid 连接池、MySQL 数据库驱动和 Jackson JSON 等处理。那么我们可以将想要的依赖项的信息编写到 Maven 工程的配置文件，Maven 就会自动下载并复制这些依赖项到项目中，无需自己导入 jar 包，管理 jar!

场景2： 项目完成开发，我们想要打成 war 部署到服务器中，使用 maven 的构建命令可以快速打包！节省大量时间！

二、Maven 的安装和配置

1. Maven 安装

安装条件： Maven 需要本机安装 java 环境、必需包含 java_home 环境变量！

软件安装： 右键解压即可（绿色免安装）

软件结构：

bin：含有 Maven 的运行脚本

boot：含有 plexus-classworlds 类加载器框架

conf：含有 Maven 的核心配置文件

lib：含有 Maven 运行时所需要的 Java 类库

LICENSE、NOTICE、README.txt：针对 Maven 版本，第三方软件等简要介绍

2. Maven 环境配置

配置 MAVEN_HOME

配置 Path

命令测试（cmd 窗口）

mvn -v 
# 输出版本信息即可，如果错误，请仔细检查环境变量即可！

3. Maven 功能配置

我们需要需改 maven/conf/settings.xml 配置文件，来修改 maven 的一些默认配置。我们主要休要修改的有三个配置：

1.依赖本地缓存位置（本地仓库位置）

2.maven 下载镜像

3.maven 选用编译项目的 jdk 版本

配置本地仓库地址

<!-- localRepository
   | The path to the local repository maven will use to store artifacts.
   |
   | Default: ${user.home}/.m2/repository
  <localRepository>/path/to/local/repo</localRepository>
  -->
 <!-- conf/settings.xml 55行 -->
 <localRepository>D:/tools/repo</localRepository>

配置国内阿里镜像

<!--在mirrors节点(标签)下添加中央仓库镜像 160行附近-->
<mirror>
    <id>alimaven</id>
    <name>aliyun maven</name>
    <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
    <mirrorOf>central</mirrorOf>
</mirror>

配置 jdk8 版本项目构建

<!--在profiles节点(标签)下添加jdk编译版本 268行附近-->
<profile>
    <id>jdk-8</id>
    <activation>
      <activeByDefault>true</activeByDefault>
      <jdk>8</jdk>
    </activation>
    <properties>
      <maven.compiler.source>8</maven.compiler.source>
      <maven.compiler.target>8</maven.compiler.target>
      <maven.compiler.compilerVersion>8</maven.compiler.compilerVersion>
    </properties>
</profile>

4. IDEA 配置本地 Maven 软件

我们需要将配置好的 maven 软件，配置到 idea 开发工具中即可！注意：idea 工具默认自带 maven 软件，但是因为没有修改配置，建议替换成本地配置好的 maven！

选择本地 maven 软件

注意：

如果本地仓库地址不变化，只有一个原因，就是 maven/conf/settings.xml 配置文件编写错误！仔细检查即可！
一定保证 User settings file 对应之前修改的 settings.xml 的路径，若不一致，选中 Override 复选框，手动选择配置文件

三、基于 IDEA 创建 Maven 工程

1. Maven 工程的 GAVP 介绍

Maven 工程相对之前的项目，多出一组 gavp 属性，gav 需要我们在创建项目的时候指定，p 有默认值，我们先行了解下这组属性的含义：

Maven 中的 GAVP 是指 GroupId、ArtifactId、Version、Packaging 这四个属性的缩写，其中前三个是必要的，而 Packaging 属性为可选项。这四个属性主要为每个项目在 maven 仓库中做一个标识，类似人的姓-名！有了具体标识，方便后期项目之间相互引用依赖等！

GAV 遵循以下规则：

GroupID 格式：com.{公司/BU }.业务线.[子业务线]，最多 4 级

说明：{公司/BU} 例如：alibaba/taobao/tmall/aliexpress 等 BU 一级；子业务线可选。

正例：com.taobao.pay 或 com.alibaba.sourcing.multilang

ArtifactID 格式：产品线名-模块名

正例：tc-client / uic-api / tair-tool / bookstore

Version 版本号格式推荐：主版本号.次版本号.修订号

- 主版本号：当做了不兼容的 API 修改，或者增加了能改变产品方向的新功能。
- 次版本号：当做了向下兼容的功能性新增（新增类、接口等）。
- 修订号：修复 bug，没有修改方法签名的功能加强，保持 API 兼容性。
- 例如：初始→1.0.0 修改bug → 1.0.1 功能调整 → 1.1.1等

Packaging 定义规则：

指示将项目打包为什么类型的文件，idea 根据 packaging 值，识别 maven 项目类型！
packaging 属性为 jar（默认值），代表普通的 Java 工程，打包以后是 .jar 结尾的文件。
packaging 属性为 war，代表 Java 的 web 工程，打包以后 .war 结尾的文件。
packaging 属性为 pom，代表不会打包，用来做继承的父工程。

2. IDEA 构建 Maven Java SE 工程

创建工程之后，若第一次使用 maven，或者使用的是新的本地仓库，idea 右下角会出现以下进度条，表示 maven 正在下载相关插件，等待下载完毕，进度条消失即可。

3. IDEA 构建 Maven Java Web 工程

3.1 手动方式创建

第一步：创建一个 maven 的 javase 工程

第二步：修改 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.xszx</groupId>
    <artifactId>maven_web</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!-- 新增一行打包方式packaging -->
    <packaging>war</packaging>
</project>

第三步：设置 web 资源路径 和 web.xml 路径

然后点击 OK 即可。

最后的效果：

webapp 目录上必须出现小圆圈，否则表示创建失败，需要删掉重来一次。

然后 WEB-INF 以及 web.xml 自己从之前的 JavaWeb 项目中复制一个粘贴进来即可。

3.2 插件方式创建

第一步：安装插件 JBLJavaToWeb

file / settings / plugins / marketplace

第二步：创建一个 javase maven工程

第三步：右键--->使用插件快速补全 web 项目（如果你的 IDEA 中没有出现下图这个菜单选项，很可能是你的 JDK 版本太低了，最起码 JDK8 是不行的）

4. Maven 工程项目结构说明

Maven 是一个强大的构建工具，它提供一种标准化的项目结构，可以帮助开发者更容易地管理项目的依赖、构建、测试和发布等任务。以下是 Maven Web 程序的文件结构及每个文件的作用：

|-- pom.xml                               # Maven 项目管理文件 
|-- src
    |-- main                              # 项目主要代码
    |   |-- java                          # Java 源代码目录
    |   |   `-- com/example/myapp         # 开发者代码主目录
    |   |       |-- controller            # 存放 Controller 层代码的目录
    |   |       |-- service               # 存放 Service 层代码的目录
    |   |       |-- dao                   # 存放 DAO 层代码的目录
    |   |       `-- model                 # 存放数据模型的目录
    |   |-- resources                     # 资源目录，存放配置文件、静态资源等
    |   |   |-- log4j.properties          # 日志配置文件
    |   |   |-- spring-mybatis.xml        # Spring Mybatis 配置文件
    |   |   `-- static                    # 存放静态资源的目录
    |   |       |-- css                   # 存放 CSS 文件的目录
    |   |       |-- js                    # 存放 JavaScript 文件的目录
    |   |       `-- images                # 存放图片资源的目录
    |   `-- webapp                        # 存放 WEB 相关配置和资源
    |       |-- WEB-INF                   # 存放 WEB 应用配置文件
    |       |   |-- web.xml               # Web 应用的部署描述文件
    |       |   `-- classes               # 存放编译后的 class 文件
    |       `-- index.html                # Web 应用入口页面
    `-- test                              # 项目测试代码
        |-- java                          # 单元测试目录
        `-- resources                     # 测试资源目录

pom.xml：Maven 项目管理文件，用于描述项目的依赖和构建配置等信息。
src/main/java：存放项目的 Java 源代码。
src/main/resources：存放项目的资源文件，如配置文件、静态资源等。
src/main/webapp/WEB-INF：存放 Web 应用的配置文件。
src/main/webapp/index.jsp：Web 应用的入口页面。
src/test/java：存放项目的测试代码。
src/test/resources：存放测试相关的资源文件，如测试配置文件等。

四、基于 IDEA 进行 Maven 工程构建

1. 构建概念和构建过程

项目构建是指将源代码、依赖库和资源文件等转换成可执行或可部署的应用程序的过程，在这个过程中包括编译源代码、链接依赖库、打包和部署等多个步骤。

项目构建是软件开发过程中至关重要的一部分，它能够大大提高软件开发效率，使得开发人员能够更加专注于应用程序的开发和维护，而不必关心应用程序的构建细节。

同时，项目构建还能够将多个开发人员的代码汇合到一起，并能够自动化项目的构建和部署，大大降低了项目的出错风险和提高开发效率。常见的构建工具包括 Maven、Gradle、Ant 等。

2. 命令方式项目构建

命令	描述
mvn compile	编译项目，生成 target 目录
mvn package	打包项目，生成 jar 或 war 文件
mvn clean	清理编译或打包后的项目结构
mvn install	打包后上传到 maven 本地仓库
mvn deploy	只打包，上传到 maven 私服仓库
mvn site	生成站点
mvn test	执行测试源码

war 包打包插件和 jdk 版本不匹配：pom.xml 添加以下代码即可

<build>
    <!-- jdk17 和 war包版本插件不匹配 -->
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-war-plugin</artifactId>
            <version>3.2.2</version>
        </plugin>
    </plugins>
</build>

命令触发练习：

mvn 命令 命令

#清理
mvn clean
#清理，并重新打包
mvn clean package
#执行测试代码
mvn test

3. 可视化方式项目构建

注意：打包（package）和安装（install）的区别是什么

打包是将工程打成 jar 或 war 文件，保存在 target 目录下

安装是将当前工程所生成的 jar 或 war 文件，安装到本地仓库，会按照坐标保存到指定位置

五、基于 IDEA 进行 Maven 依赖管理

1. 依赖管理概念

Maven 依赖管理是 Maven 软件中最重要的功能之一。Maven 的依赖管理能够帮助开发人员自动解决软件包依赖问题，使得开发人员能够轻松地将其他开发人员开发的模块或第三方框架集成到自己的应用程序或模块中，避免出现版本冲突和依赖缺失等问题。

我们通过定义 POM 文件，Maven 能够自动解析项目的依赖关系，并通过 Maven 仓库自动下载和管理依赖，从而避免了手动下载和管理依赖的繁琐工作和可能引发的版本冲突问题。

总之，Maven 的依赖管理是 Maven 软件的一个核心功能之一，使得软件包依赖的管理和使用更加智能和方便，简化了开发过程中的工作，并提高了软件质量和可维护性。

2. Maven 工程核心信息配置和解读（GAVP）

位置：pom.xml

<!-- 模型版本 -->
<modelVersion>4.0.0</modelVersion>
<!-- 
	公司或者组织的唯一标志，并且配置时生成的路径也是由此生成， 如com.companyname.project-group，	 maven会将该项目打成的jar包放本地路径：/com/companyname/project-group 
-->
<groupId>com.companyname.project-group</groupId>
<!-- 项目的唯一ID，一个groupId下面可能多个项目，就是靠artifactId来区分的 -->
<artifactId>project</artifactId>
<!-- 版本号 -->
<version>1.0.0</version>

<!--
	打包方式
    默认：jar
    jar指的是普通的java项目打包方式！ 项目打成jar包！
    war指的是web项目打包方式！项目打成war包！
    pom不会将项目打包！这个项目作为父工程，被其他工程聚合或者继承！后面会讲解两个概念
-->
<packaging>jar/pom/war</packaging>

3. Maven 工程依赖管理配置

位置：pom.xml

依赖管理和依赖添加

<!-- 
   通过编写依赖jar包的gav必要属性，引入第三方依赖！
   scope属性是可选的，可以指定依赖生效范围！
   依赖信息查询方式：maven仓库信息官网 https://mvnrepository.com/
 -->
<dependencies>
    <!-- 引入具体的依赖包 -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
        <!-- 依赖范围 -->
        <scope>runtime</scope>
    </dependency>
</dependencies>

依赖版本统一提取和维护

<!--声明版本-->
<properties>
  <!--命名随便,内部制定版本号即可！-->
  <junit.version>4.12</junit.version>
  <!-- 也可以通过 maven规定的固定的key，配置maven的参数！如下配置编码格式！-->
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
</properties>

<dependencies>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <!--引用properties声明版本 -->
    <version>${junit.version}</version>
  </dependency>
</dependencies>

4. 依赖范围

通过设置坐标的依赖范围(scope)，可以设置对应 jar 包的作用范围：编译环境、测试环境、运行环境

依赖范围	描述
compile	编译依赖范围，scope 元素的缺省值。使用此依赖范围的 Maven 依赖，对于三种 classpath 均有效，即该 Maven 依赖在上述三种 classpath 均会被引入。例如，log4j 在编译、测试、运行过程都是必须的。
test	测试依赖范围。使用此依赖范围的 Maven 依赖，只对测试 classpath 有效。例如，Junit 依赖只有在测试阶段才需要。
provided	已提供依赖范围。使用此依赖范围的 Maven 依赖，只对编译 classpath 和测试 classpath 有效。例如，servlet-api 依赖对于编译、测试阶段而言是需要的，但是运行阶段，由于外部容器已经提供，故不需要 Maven 重复引入该依赖。
runtime	运行时依赖范围。使用此依赖范围的 Maven 依赖，只对测试 classpath、运行 classpath 有效。例如，JDBC 驱动实现依赖，其在编译时只需 JDK 提供的 JDBC 接口即可，只有测试、运行阶段才需要实现了 JDBC 接口的驱动。
system	系统依赖范围，其效果与 provided 的依赖范围一致。其用于添加非 Maven 仓库的本地依赖，通过依赖元素 dependency 中的 systemPath 元素指定本地依赖的路径。鉴于使用其会导致项目的可移植性降低，一般不推荐使用。
import	导入依赖范围，该依赖范围只能与 dependencyManagement 元素配合使用，其功能是将目标 pom.xml 文件中 dependencyManagement 的配置导入合并到当前 pom.xml 的 dependencyManagement 中。

5. Maven 工程依赖下载失败错误解决（重点）

在使用 Maven 构建项目时，可能会发生依赖项下载错误的情况，主要原因有以下几种：

下载依赖时出现网络故障或仓库服务器宕机等原因，导致无法连接至 Maven 仓库，从而无法下载依赖
依赖项的版本号或配置文件中的版本号错误，或者依赖项没有正确定义，导致 Maven 下载的依赖项与实际需要的不一致，从而引发错误
本地 Maven 仓库或缓存被污染或损坏，导致 Maven 无法正确地使用现有的依赖项

解决方案：

检查网络连接和 Maven 仓库服务器状态。
确保依赖项的版本号与项目对应的版本号匹配，并检查 POM 文件中的依赖项是否正确。
清除本地 Maven 仓库缓存（lastUpdated 文件），因为只要存在 lastUpdated 缓存文件，刷新也不会重新下载。本地仓库中，根据依赖的 gav 属性依次向下查找文件夹，最终删除内部的文件，刷新重新下载即可！

例如： pom.xml 依赖

<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>druid</artifactId>
  <version>1.2.11</version>
</dependency>

文件：

或者可以将清除 lastUpdated文件 的操作写在一个脚本文件中，手动创建文件 "clearLastUpdated.bat"，名字任意，但是后缀必须是 bat，将以下内容复制到文件中:

cls 
@ECHO OFF 
SET CLEAR_PATH=D: 
SET CLEAR_DIR=D:\maven-repository(本地仓库路径)
color 0a 
TITLE ClearLastUpdated For Windows 
GOTO MENU 
:MENU 
CLS
ECHO. 
ECHO. * * * *  ClearLastUpdated For Windows  * * * * 
ECHO. * * 
ECHO. * 1 清理*.lastUpdated * 
ECHO. * * 
ECHO. * 2 查看*.lastUpdated * 
ECHO. * * 
ECHO. * 3 退 出 * 
ECHO. * * 
ECHO. * * * * * * * * * * * * * * * * * * * * * * * * 
ECHO. 
ECHO.请输入选择项目的序号： 
set /p ID= 
IF "%id%"=="1" GOTO cmd1 
IF "%id%"=="2" GOTO cmd2 
IF "%id%"=="3" EXIT 
PAUSE 
:cmd1 
ECHO. 开始清理
%CLEAR_PATH%
cd %CLEAR_DIR%
for /r %%i in (*.lastUpdated) do del %%i
ECHO.OK 
PAUSE 
GOTO MENU 
:cmd2 
ECHO. 查看*.lastUpdated文件
%CLEAR_PATH%
cd %CLEAR_DIR%
for /r %%i in (*.lastUpdated) do echo %%i
ECHO.OK 
PAUSE 
GOTO MENU

6. Maven 工程 Build 构建配置

默认情况下，构建不需要额外配置，都有对应的缺省配置。当然了，我们也可以在 pom.xml 定制一些配置，来修改默认构建的行为和产物！

例如：

指定构建打包文件的名称，非默认名称
指定构建打包时，包含文件格式和排除文件
打包插件版本过低，配置更高版本插件

构建配置是在 pom.xml / build 标签中指定！

指定打包命名

<!-- 默认的打包名称：artifactid+verson.打包方式 -->
<build>
  <finalName>定义打包名称</finalName>
</build>

指定打包文件

如果在 java 文件夹中添加 java 类，会自动打包编译到 classes 文件夹下！

但是在 java 文件夹中添加 xml 文件，默认不会被打包！

默认情况下，按照 maven 工程结构放置的文件会默认被编译和打包！

除此之外，我们可以使用 resources 标签，指定要打包资源的文件夹要把哪些静态资源打包到 classes 根目录下！

应用场景：mybatis 中有时会将用于编写 SQL 语句的映射文件和 mapper 接口都写在 src/main/java 下的某个包中，此时映射文件就不会被打包，使用下面方式解决：

<build>
    <!--设置要打包的资源位置-->
    <resources>
        <resource>
            <!--设置资源所在目录-->
            <directory>src/main/java</directory>
            <includes>
                <!--设置包含的资源类型-->
                <include>**/*.xml</include>
            </includes>
        </resource>
    </resources>
</build>

配置依赖插件

dependencies 标签下引入开发需要的 jar 包！我们可以在 build/plugins/plugin 标签引入插件！

常用的插件：修改 jdk 版本、tomcat 插件、mybatis 分页插件、mybatis 逆向工程插件等等！

<build>
    <plugins>
        <!-- java编译插件，配jdk的编译版本 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>
        <!-- tomcat插件 -->
        <plugin>
            <groupId>org.apache.tomcat.maven</groupId>
            <artifactId>tomcat7-maven-plugin</artifactId>
            <version>2.2</version>
            <configuration>
                <port>8090</port>
                <path>/</path>
                <uriEncoding>UTF-8</uriEncoding>
                <server>tomcat7</server>
            </configuration>
        </plugin>
    </plugins>
</build>

六、Maven 依赖传递和依赖冲突

1. Maven 依赖传递特性

概念

假如有 Maven 项目 A，项目 B 依赖 A，项目 C 依赖 B。那么我们可以说 C 依赖 A。也就是说，依赖的关系为：C—>B—>A，那么我们执行项目 C 时，会自动把 B、A 都下载导入到 C 项目的 jar 包文件夹中，这就是依赖的传递性。

作用

简化依赖导入过程
确保依赖版本正确

传递的原则

在 C 依赖 B，B 依赖 A 的前提下，A 是否能够传递到 C，取决于 B 依赖 A 时使用的依赖范围以及配置

B 依赖 A 时使用 compile 范围：可以传递
B 依赖 A 时使用 test 或 provided 范围：不能传递，所以需要这样的 jar 包时，就必须在需要的地方明确配置依赖才可以
B 依赖 A 时，若配置了以下标签，则不能传递

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.15</version>
    <optional>true</optional>
</dependency>

依赖传递终止的情况

非 compile 范围进行依赖传递
使用 optional 配置终止传递
依赖冲突（传递的依赖已经存在）

案例：导入 jackson 依赖

分析：jackson 需要三个依赖

依赖传递关系：data-bind 中，依赖其他两个依赖：

最佳导入：直接可以导入 data-bind，自动依赖传递需要的依赖

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.10.0</version>
</dependency>

2. Maven 依赖冲突特性

当直接引用或者间接引用出现了相同的 jar 包! 这时呢，一个项目就会出现相同的重复 jar 包，这就算作冲突！依赖冲突会终止依赖传递！

maven 自动解决依赖冲突问题能力，会按照自己的原则，进行重复依赖选择。同时也提供了手动解决的冲突的方式。

解决依赖冲突（如何选择重复依赖）方式：

方式一：自动选择原则

短路优先原则（第一原则）

A—>B—>C—>D—>E—>X(version 0.0.1)

A—>F—>X(version 0.0.2)

则 A 依赖于X(version 0.0.2)。

依赖路径长度相同情况下，则“先声明优先”（第二原则）

A—>E—>X(version 0.0.1)

A—>F—>X(version 0.0.2)

在<dependencies></dependencies>中，先声明的，路径相同，会优先选择！

方式二：手动排除

<dependency>
    <groupId>com.xszx</groupId>
    <artifactId>pro01-maven-java</artifactId>
    <version>1.0-SNAPSHOT</version>
    <scope>compile</scope>
    <!-- 使用excludes标签配置依赖的排除  -->
    <exclusions>
        <!-- 在exclude标签中配置一个具体的排除 -->
        <exclusion>
            <!-- 指定要排除的依赖的坐标（不需要写version） -->
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>

七、Maven 工程继承和聚合关系

1. Maven 工程继承关系

1.1 继承概念

Maven 继承是指在 Maven 的项目中，让一个项目从另一个项目中继承配置信息的机制。继承可以让我们在多个项目中共享同一配置信息，简化项目的管理和维护工作。

1.2 继承作用

在父工程中统一管理项目中的依赖信息。

它的背景是：

对一个比较大型的项目进行了模块拆分
一个 project 下面，创建了很多个 module
每一个 module 都需要配置自己的依赖信息

它背后的需求是：

在每一个 module 中各自维护各自的依赖信息很容易发生出入，不易统一管理
使用同一个框架内的不同 jar 包，它们应该是同一个版本，所以整个项目中使用的框架版本需要统一
使用框架时所需要的 jar 包组合（或者说依赖信息组合）需要经过长期摸索和反复调试，最终确定一个可用组合。这个耗费很大精力总结出来的方案不应该在新的项目中重新摸索。通过在父工程中为整个项目维护依赖信息的组合既保证了整个项目使用规范、准确的 jar 包；又能够将以往的经验沉淀下来，节约时间和精力。

1.3 继承语法

父工程

<groupId>com.xszx.maven</groupId>
  <artifactId>pro03-maven-parent</artifactId>
  <version>1.0-SNAPSHOT</version>
  <!-- 当前工程作为父工程，它要去管理子工程，所以打包方式必须是 pom -->
  <packaging>pom</packaging>

子工程

<!-- 使用parent标签指定当前工程的父工程 -->
<parent>
  <!-- 父工程的坐标 -->
  <groupId>com.xszx.maven</groupId>
  <artifactId>pro03-maven-parent</artifactId>
  <version>1.0-SNAPSHOT</version>
</parent>

<!-- 子工程的坐标 -->
<!-- 如果子工程坐标中的groupId和version与父工程一致，那么可以省略 -->
<!-- <groupId>com.xszx.maven</groupId> -->
<artifactId>pro04-maven-module</artifactId>
<!-- <version>1.0-SNAPSHOT</version> -->

父工程依赖统一管理

父工程声明版本

<!-- 使用dependencyManagement标签配置对依赖的管理 -->
<!-- 被管理的依赖并没有真正被引入到工程 -->
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>6.0.10</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>6.0.10</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>6.0.10</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>6.0.10</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>6.0.10</version>
    </dependency>
  </dependencies>
</dependencyManagement>

子工程引用版本

<!-- 子工程引用父工程中的依赖信息时，可以把版本号去掉。  -->
<!-- 把版本号去掉就表示子工程中这个依赖的版本由父工程决定。 -->
<!-- 具体来说是由父工程的dependencyManagement来决定。 -->
<dependencies>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-expression</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
  </dependency>
</dependencies>

2. Maven 工程聚合关系

2.1 聚合概念

Maven 聚合是指将多个项目组织到一个父级项目中，以便一起构建和管理的机制。聚合可以帮助我们更好地管理一组相关的子项目，同时简化它们的构建和部署过程。

2.2 聚合作用

管理多个子项目：通过聚合，可以将多个子项目组织在一起，方便管理和维护。
构建和发布一组相关的项目：通过聚合，可以在一个命令中构建和发布多个相关的项目，简化了部署和维护工作。
优化构建顺序：通过聚合，可以对多个项目进行顺序控制，避免出现构建依赖混乱导致构建失败的情况。
统一管理依赖项：通过聚合，可以在父项目中管理公共依赖项和插件，避免重复定义。

2.3 聚合语法

父项目中包含的子项目列表。

<project>
  <groupId>com.example</groupId>
  <artifactId>parent-project</artifactId>
  <packaging>pom</packaging>
  <version>1.0.0</version>
  <modules>
    <module>child-project1</module>
    <module>child-project2</module>
  </modules>
</project>

八、Maven 综合案例

1. 项目需求和结构分析

需求案例：搭建一个电商平台项目，该平台包括用户服务、订单服务、通用工具模块等。

项目架构：

用户服务：负责处理用户相关的逻辑，例如用户信息的管理、用户注册、登录等。

- spring-context 6.0.6
- spring-core 6.0.6
- spring-beans 6.0.6
- common-service

订单服务：负责处理订单相关的逻辑，例如订单的创建、订单支付、退货、订单查看等。

- spring-context 6.0.6
- spring-core 6.0.6
- spring-beans 6.0.6
- spring-security 6.0.6
- common-service

通用模块：负责存储其他服务需要通用工具类，其他服务依赖此模块。

- commons-io 2.11.0
- junit 5.9.2

2. 项目搭建和统一构建

2.1 父模块 (micro-shop)

2.1.1 创建项目

2.1.2 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.xszx</groupId>
    <artifactId>micro-shop</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--知识点：父工程的打包方式为pom-->
    <packaging>pom</packaging>

    <properties>
        <spring.version>6.0.6</spring.version>
        <jackson.version>2.15.0</jackson.version>
        <commons.version>2.11.0</commons.version>
        <junit.version>5.9.2</junit.version>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <!-- 依赖管理 -->
    <dependencyManagement>
        <dependencies>
            <!-- spring-context会依赖传递core/beans -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>

            <!-- jackson-databind会依赖传递core/annotations -->
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>${jackson.version}</version>
            </dependency>

            <!-- commons-io -->
            <dependency>
                <groupId>commons-io</groupId>
                <artifactId>commons-io</artifactId>
                <version>${commons.version}</version>
            </dependency>

            <!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
            <dependency>
                <groupId>org.junit.jupiter</groupId>
                <artifactId>junit-jupiter-api</artifactId>
                <version>${junit.version}</version>
                <scope>test</scope>
            </dependency>

        </dependencies>
    </dependencyManagement>

    <!-- 统一更新子工程打包插件-->
    <build>
        <!-- jdk17 和 war 包版本插件不匹配 -->
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>3.2.2</version>
            </plugin>
        </plugins>
    </build>
</project>

可选操作：删除 src 目录。

2.2 通用模块 (common-service)

2.2.1 创建模块

2.2.2 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">
    <parent>
        <artifactId>micro-shop</artifactId>
        <groupId>com.xszx</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>common-service</artifactId>

    <!--知识点：打包方式默认就是jar，因此可以省略-->
    <packaging>jar</packaging>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- 配置spring-context，继承父工程版本，自动传递 core / beans -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
        <!-- 配置jackson-databind，继承父工程版本，自动传递 core / annotations -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
        <!-- 配置commons-io，继承父工程版本 -->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
        </dependency>
        <!-- 配置junit，继承父工程版本 -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

2.3 用户模块 (user-service)

2.3.1 创建模块

步骤和上面一样的，不再具体截图演示。

2.3.2 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">
    <parent>
        <artifactId>micro-shop</artifactId>
        <groupId>com.xszx</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>user-service</artifactId>

    <!-- web工程打包方式为war -->
    <packaging>war</packaging>

    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- 配置common-service，所需依赖会传递到当前工程（仅限compile范围） -->
        <dependency>
            <groupId>com.xszx</groupId>
            <artifactId>common-service</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
</project>

依赖传递的结果：

2.3.3 使用插件转为 web 工程

在该模块上右击鼠标进行转换。

2.4 订单模块 (order-service)

2.4.1 创建模块

2.4.2 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">
    <parent>
        <artifactId>micro-shop</artifactId>
        <groupId>com.xszx</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>order-service</artifactId>

    <!-- web工程打包方式为war -->
    <packaging>war</packaging>

    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- 配置common-service，所需依赖会传递到当前工程（仅限compile范围） -->
        <dependency>
            <groupId>com.xszx</groupId>
            <artifactId>common-service</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
</project>

2.4.3 使用插件转为 web 工程

在该模块上右击鼠标进行转换。

2.5 观察父项目

此时，查看父工程的 pom.xml，会发现其中已经自动聚合了子工程：

<modules>
    <module>common-service</module>
    <module>user-service</module>
    <module>order-service</module>
</modules>

白熊bro

关注

14
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫