个人博客
0%

Maven

发表于 更新于

Maven是Apache旗下的一个开源项目，是一款用于管理和构建java项目的工具。

官网：https://maven.apache.org/

Maven的作用:

  • 依赖管理：方便快捷的管理项目依赖的资源(jar包)，避免版本冲突问题
  • 统一项目结构：提供标准、统一的项目结构
  • 项目构建：maven提供了标准的、跨平台(Linux、Windows、MacOS) 的自动化项目构建方式

Maven安装

首先学习Maven，我们需要进行下载与安装

下载地址：https://maven.apache.org/download.cgi

下载安装包如下：

image-20231016151943915

解压安装

将下载的压缩包解压到一个没有中文、特殊字符的路径下（解压即安装）

解压后的目录结构如下：

image-20231016152444373

配置本地仓库

  1. 在自己计算机上新一个目录（本地仓库，用来存储jar包）我这里选择了上图中的mvn_repo

  2. 进入到conf目录下修改settings.xml配置文件

    1. 找到标签，将其粘贴到外面
    2. 复制刚才新建的目录路径，替换掉标签体的内容

配置阿里云私服

由于中央仓库在国外，所以下载jar包速度可能比较慢，而阿里公司提供了一个远程仓库，里面基本也都有开源项目的jar包。

进入到conf目录下修改settings.xml配置文件：

找到标签，在其中添加子标签，内容如下：

1
2
3
4
5
6
<mirror>  
    <id>alimaven</id>  
    <name>aliyun maven</name>  
    <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
    <mirrorOf>central</mirrorOf>          
</mirror>

==注: 只可配置一个(另一个要注释!) ，不然两个可能发生冲突，导致jar包无法下载!!!!!!!==

配置环境变量

Maven环境变量的配置类似于JDK环境变量配置一样

  1. 在系统变量处新建一个变量MAVEN_HOME

MAVEN_HOME环境变量的值，设置为maven的解压安装目录

image-20231016153145408

  1. 在Path中进行配置

PATH环境变量的值，设置为：%MAVEN_HOME%\bin

image-20231016153238989

  1. 打开cmd窗口进行验证，出现如图所示表示安装成功
1
mvn -v

IDEA集成Maven

我们要想在IDEA中使用Maven进行项目构建，就需要在IDEA中集成Maven

配置Maven环境

  1. 选择 IDEA中 File => close project

  2. 打开 All settings , 选择 Build,Execution,Deployment => Build Tools => Maven

image-20231016153556058

  1. 配置工程的编译版本为17

image-20231016153636011

这里所设置的maven的环境信息，并未指定任何一个project，此时设置的信息就属于全局配置信息。 以后，我们再创建project，默认就是使用我们全局配置的信息。

如果需要IDEA导入Maven项目之间添加模块选中对应的pom文件即可导入

Maven基础

Maven模型

  • 项目对象模型 (Project Object Model)
  • 依赖管理模型(Dependency)
  • 构建生命周期/阶段(Build lifecycle & phases)

1). 构建生命周期/阶段(Build lifecycle & phases)

image-20221130142100703

以上图中紫色框起来的部分，就是用来完成标准化构建流程 。当我们需要编译，Maven提供了一个编译插件供我们使用；当我们需要打包，Maven就提供了一个打包插件供我们使用等。

2). 项目对象模型 (Project Object Model)

image-20221130142643255

以上图中紫色框起来的部分属于项目对象模型，就是将我们自己的项目抽象成一个对象模型，有自己专属的坐标，如下图所示是一个Maven项目：

image-20231016154203953

坐标，就是资源(jar包)的唯一标识，通过坐标可以定位到所需资源(jar包)位置

image-20221130230134757

3). 依赖管理模型(Dependency)

image-20221130143139644

以上图中紫色框起来的部分属于依赖管理模型，是使用坐标来描述当前项目依赖哪些第三方jar包

image-20221130174805973

书写在pom.xml文件中的坐标又是怎么能找到所要的jar包文件的呢？

答案：Maven仓库

Maven仓库

仓库：用于存储资源，管理各种jar包

仓库的本质就是一个目录(文件夹)，这个目录被用来存储开发中所有依赖(就是jar包)和插件

Maven仓库分为：

  • 本地仓库：自己计算机上的一个目录(用来存储jar包)
  • 中央仓库：由Maven团队维护的全球唯一的。仓库地址：https://repo1.maven.org/maven2/
  • 远程仓库(私服)：一般由公司团队搭建的私有仓库

image-20220616095633552

当项目中使用坐标引入对应依赖jar包后，首先会查找本地仓库中是否有对应的jar包

  • 如果有，则在项目直接引用

  • 如果没有，则去中央仓库中下载对应的jar包到本地仓库

如果还可以搭建远程仓库(私服)，将来jar包的查找顺序则变为： 本地仓库 –> 远程仓库–> 中央仓库

依赖管理

依赖配置

依赖：指当前项目运行所需要的jar包。一个项目中可以引入多个依赖：

例如：在当前工程中，我们需要用到logback来记录日志，此时就可以在maven工程的pom.xml文件中，引入logback的依赖。具体步骤如下：

  1. 在pom.xml中编写标签

  2. 在标签中使用引入坐标

  3. 定义坐标的 groupId、artifactId、version

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<dependencies>
    <!-- 第1个依赖 : logback -->
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.11</version>
    </dependency>
    <!-- 第2个依赖 : junit -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>
  1. 点击刷新按钮，引入最新加入的坐标
    • 刷新依赖：保证每一次引入新的依赖，或者修改现有的依赖配置，都可以加入最新的坐标

image-20221130184402805

注意事项：

  1. 如果引入的依赖，在本地仓库中不存在，将会连接远程仓库 / 中央仓库，然后下载依赖（这个过程会比较耗时，耐心等待）
  2. 如果不知道依赖的坐标信息，可以到mvn的中央仓库（https://mvnrepository.com/）中搜索

依赖传递

在pom.xml文件中只添加了logback-classic依赖，但由于maven的依赖具有传递性，所以会自动把所依赖的其他jar包(logback-

core, slf4j-api)也一起导入。

依赖传递可以分为：

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

image-20231016155000660

比如以上图中：

  • projectA依赖了projectB。对于projectA 来说，projectB 就是直接依赖。
  • 而projectB依赖了projectC及其他jar包。 那么此时，在projectA中也会将projectC的依赖传递下来。对于projectA 来说，projectC就是间接依赖。

排除依赖

问题：之前我们讲了依赖具有传递性。那么A依赖B，B依赖C，如果A不想将C依赖进来，是否可以做到？

答案：在maven项目中，我们可以通过排除依赖来实现。

什么是排除依赖？

  • 排除依赖：指主动断开依赖的资源。（被排除的资源无需指定版本）
1
2
3
4
5
6
7
8
9
10
11
12
13
<dependency>
    <groupId>com.itheima</groupId>
    <artifactId>maven-projectB</artifactId>
    <version>1.0-SNAPSHOT</version>
   
    <!--排除依赖, 主动断开依赖的资源-->
    <exclusions>
    	<exclusion>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </exclusion>
    </exclusions>
</dependency>

依赖排除示例：

  • maven-projectA依赖了maven-projectB，maven-projectB依赖了Junit。基于依赖的传递性，所以maven-projectA也依赖了Junit

image-20221201141929240

  • 使用排除依赖后

image-20221201142501556

依赖范围

在项目中导入依赖的jar包后，默认情况下，可以在任何地方使用。

如果希望限制依赖的使用范围，可以通过标签设置其作用范围。

示例：

1
2
3
4
5
6
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>3.8.1</version>
    <scope>test</scope>
</dependency>

作用范围：

  1. 主程序范围有效（main文件夹范围内）

  2. 测试程序范围有效（test文件夹范围内）

  3. 是否参与打包运行（package指令范围内）

scope值 主程序 测试程序 打包（运行） 范例
compile（默认） Y Y Y log4j
test - Y - junit
provided Y Y - servlet-api
runtime - Y Y jdbc驱动

生命周期

Maven的生命周期就是为了对所有的构建过程进行抽象和统一。 描述了一次项目构建，经历哪些阶段。

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

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

Maven对项目构建的生命周期划分为3套（相互独立）：

image-20231016155548944

  • clean：清理工作。

  • default：核心工作。如：编译、测试、打包、安装、部署等。

  • site：生成报告、发布站点等。

三套生命周期又包含哪些具体的阶段呢, 我们来看下面这幅图:

image-20231016155606934

我们看到这三套生命周期，里面有很多很多的阶段，这么多生命周期阶段，其实我们常用的并不多，主要关注以下几个：

• clean：移除上一次构建生成的文件

• compile：编译项目源代码

• test：使用合适的单元测试框架运行测试(junit)

• package：将编译后的文件打包，如：jar、war等

• install：安装项目到本地仓库

Maven的生命周期是抽象的，这意味着生命周期本身不做任何实际工作。在Maven的设计中，实际任务（如源代码编译）都交由插件来完成。

image-20231016155658613

IDEA工具为了方便程序员使用maven生命周期，在右侧的maven工具栏中，已给出快速访问通道

image-20231016155917535

生命周期的顺序就是从上往下进行

我们需要关注的就是：clean –> compile –> test –> package –> install

说明：在同一套生命周期中，我们在执行后面的生命周期时，前面的生命周期都会执行。

思考：当运行package生命周期时，clean、compile生命周期会不会运行？

​ clean不会运行，compile会运行。 因为compile与package属于同一套生命周期，而clean与package不属于同一套生命周期。

在需要执行生命周期的时候直接双击生命周期即可执行

Maven进阶

分模块开发

所谓分模块开发，顾名思义指的就是我们在设计一个 Java 项目的时候，将一个 Java 项目拆分成多个模块进行开发。

未分模块的缺点：

  • 不方便项目的维护和管理
  • 项目中的通用组件难以复用

分模块设计就是将项目按照功能/结构拆分成若干个子模块，方便项目的管理维护、拓展，也方便模块键的相互调用、资源共享。

image-20231016161937513

例如：我们观察若依的目录，最外层是整个项目的父工程，其他则是各个模块，核心内容在admin，common则是一些通用的代码，system是系统模块，framework则是核心架构，二次开发的students功能也是单独放在了一个模块里

继承与聚合

继承

  • 概念：继承描述的是两个工程间的关系，与java中的继承相似，子工程可以继承父工程中的配置信息，常见于依赖关系的继承。
  • 作用：简化依赖配置、统一管理依赖

例如：上面若依就是通过一个RuoYi-Vue作为整个项目的父工程

与java语言类似，Maven不支持多继承，一个maven项目只能继承一个父工程，如果继承了spring-boot-starter-parent，就没法继

承我们自己定义的父工程了，这时我们可以让自己创建的模块都继承父工程，父工程继承spring-boot-starter-parent即可

实现:

  1. 父工程pom文件
1
2
3
4
5
6
7
8
9
10
11
12
13
    <modules>
        <module>ruoyi-admin</module>
        <module>ruoyi-framework</module>
        <module>ruoyi-system</module>
        <module>ruoyi-quartz</module>
        <module>ruoyi-generator</module>
        <module>ruoyi-common</module>
        <module>ruoyi-student</module>
    </modules>

<groupId>love.jiahao</groupId>
<artifactId>bookExample</artifactId>
<version>0.0.1-SNAPSHOT</version>
  1. 在子工程的pom.xml文件中，配置继承关系。
1
2
3
4
5
6
7
8
9
<parent>
    <groupId>love.jiahao</groupId>
    <artifactId>bookExample</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <relativePath>../bookExample/pom.xml</relativePath>
</parent>

<artifactId>tlias-utils</artifactId>
<version>1.0-SNAPSHOT</version>

注意：

  • 在子工程中，配置了继承关系之后，坐标中的groupId是可以省略的，因为会自动继承父工程的 。
  • relativePath指定父工程的pom文件的相对位置（如果不指定，将从本地仓库/远程仓库查找该工程）。
  1. 在父工程中配置各个工程共有的依赖（子工程会自动继承父工程的依赖）。

版本锁定

在maven中，可以在父工程的pom文件中通过 <dependencyManagement> 来统一管理依赖版本。

父工程：

1
2
3
4
5
6
7
8
9
10
11
<!--统一管理依赖版本-->
<dependencyManagement>
    <dependencies>
        <!--JWT令牌-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>
    </dependencies>
</dependencyManagement>

子工程：

1
2
3
4
5
6
7
<dependencies>
    <!--JWT令牌-->
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
    </dependency>
</dependencies>

注意：

  • 在父工程中所配置的 <dependencyManagement> 只能统一管理依赖版本，并不会将这个依赖直接引入进来。 这点和 <dependencies> 是不同的。

  • 子工程要使用这个依赖，还是需要引入的，只是此时就无需指定 <version> 版本号了，父工程统一管理。变更依赖版本，只需在父工程中统一变更。

属性配置

我们也可以通过自定义属性及属性引用的形式，在父工程中将依赖的版本号进行集中管理维护。 具体语法为：

1). 自定义属性

1
2
3
<properties>
	<lombok.version>1.18.24</lombok.version>
</properties>

2). 引用属性

1
2
3
4
5
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>${lombok.version}</version>
</dependency>

接下来，我们就可以在父工程中，将所有的版本号，都集中管理维护起来。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
<properties>
    <maven.compiler.source>17</maven.compiler.source>
    <maven.compiler.target>17</maven.compiler.target>

    <lombok.version>1.18.24</lombok.version>
    <jjwt.version>0.9.1</jjwt.version>
    <aliyun.oss.version>3.15.1</aliyun.oss.version>
    <jaxb.version>2.3.1</jaxb.version>
    <activation.version>1.1.1</activation.version>
    <jaxb.runtime.version>2.3.3</jaxb.runtime.version>
</properties>


<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>${lombok.version}</version>
    </dependency>
</dependencies>

<!--统一管理依赖版本-->
<dependencyManagement>
    <dependencies>
        <!--JWT令牌-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>${jjwt.version}</version>
        </dependency>

        <!--阿里云OSS-->
        <dependency>
            <groupId>com.aliyun.oss</groupId>
            <artifactId>aliyun-sdk-oss</artifactId>
            <version>${aliyun.oss.version}</version>
        </dependency>
        <dependency>
            <groupId>javax.xml.bind</groupId>
            <artifactId>jaxb-api</artifactId>
            <version>${jaxb.version}</version>
        </dependency>
        <dependency>
            <groupId>javax.activation</groupId>
            <artifactId>activation</artifactId>
            <version>${activation.version}</version>
        </dependency>
        <!-- no more than 2.3.3-->
        <dependency>
            <groupId>org.glassfish.jaxb</groupId>
            <artifactId>jaxb-runtime</artifactId>
            <version>${jaxb.runtime.version}</version>
        </dependency>
    </dependencies>
</dependencyManagement>

版本集中管理之后，我们要想修改依赖的版本，就只需要在父工程中自定义属性的位置，修改对应的属性值即可。

面试题：<dependencyManagement> 与 <dependencies> 的区别是什么?

  • <dependencies> 是直接依赖，在父工程配置了依赖，子工程会直接继承下来。
  • <dependencyManagement> 是统一管理依赖版本，不会直接依赖，还需要在子工程中引入所需依赖(无需指定版本)

聚合

试想一下，如果开发一个大型项目，拆分的模块很多，模块之间的依赖关系错综复杂，那此时要进行项目的打包、安装操作，是非常繁琐的。 而我们接下来，要讲解的maven的聚合就是来解决这个问题的，通过maven的聚合就可以轻松实现项目的一键构建（清理、编译、测试、打包、安装等）。

  • 聚合：将多个模块组织成一个整体，同时进行项目的构建。
  • 聚合工程：一个不具有业务功能的“空”工程（有且仅有一个pom文件） 【PS：一般来说，继承关系中的父工程与聚合关系中的聚合工程是同一个】
  • 作用：快速构建项目（无需根据依赖关系手动构建，直接在聚合工程上构建即可）

在maven中，我们可以在聚合工程中通过 <moudules> 设置当前聚合工程所包含的子模块的名称。我们可以在 tlias-parent中，添加如下配置，来指定当前聚合工程，需要聚合的模块：

1
2
3
4
5
6
<!--聚合其他模块-->
<modules>
    <module>./book-pojo</module>
    <module>./book-utils</module>
    <module>./book-web-management</module>
</modules>

那此时，我们要进行编译、打包、安装操作，就无需在每一个模块上操作了。只需要在聚合工程上，统一进行操作就可以了。

对比

  • 作用

    • 聚合用于快速构建项目

    • 继承用于简化依赖配置、统一管理依赖

  • 相同点：

    • 聚合与继承的pom.xml文件打包方式均为pom，通常将两种关系制作到同一个pom文件中

    • 聚合与继承均属于设计型模块，并无实际的模块内容

  • 不同点：

    • 聚合是在聚合工程中配置关系，聚合可以感知到参与聚合的模块有哪些

    • 继承是在子模块中配置关系，父模块无法感知哪些子模块继承了自己

私服

  • 私服：是一种特殊的远程仓库，它是架设在局域网内的仓库服务，用来代理位于外部的中央仓库，用于解决团队内部的资源共享与资源同步问题。
  • 依赖查找顺序：
    • 本地仓库
    • 私服仓库
    • 中央仓库
  • 注意事项：私服在企业项目开发中，一个项目/公司，只需要一台即可（无需我们自己搭建，会使用即可）。

image-20231016164322742

资源上传与下载

image-20231016164400531

源上传与下载，我们需要做三步配置，执行一条指令。

第一步配置：在maven的配置文件中配置访问私服的用户名、密码。

第二步配置：在maven的配置文件中配置连接私服的地址(url地址)。

第三步配置：在项目的pom.xml文件中配置上传资源的位置(url地址)。

配置好了上述三步之后，要上传资源到私服仓库，就执行执行maven生命周期：deploy。

私服仓库说明：

  • RELEASE：存储自己开发的RELEASE发布版本的资源。
  • SNAPSHOT：存储自己开发的SNAPSHOT发布版本的资源。
  • Central：存储的是从中央仓库下载下来的依赖。

项目版本说明：

  • RELEASE(发布版本)：功能趋于稳定、当前更新停止，可以用于发行的版本，存储在私服中的RELEASE仓库中。
  • SNAPSHOT(快照版本)：功能不稳定、尚处于开发中的版本，即快照版本，存储在私服的SNAPSHOT仓库中。

多环境配置与应用

多环境配置有什么好处？

  • maven提供配置多种环境的设定，帮助开发者使用过程中快速切换环境

image-20210805124805979

多环境配置步骤

定义多环境

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<!--定义多环境-->
<profiles>
    <!--定义具体的环境：生产环境-->
    <profile>
        <!--定义环境对应的唯一名称-->
        <id>env_dep</id>
        <!--定义环境中专用的属性值-->
        <properties>
            <jdbc.url>jdbc:mysql://127.0.0.1:3306/ssm_db</jdbc.url>
        </properties>
        <!--设置默认启动-->
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
    </profile>
    <!--定义具体的环境：开发环境-->
    <profile>
        <id>env_pro</id>
        ……
    </profile>
</profiles>

使用多环境（构建过程）

1
2
3
4
5
【命令】：
mvn 指令 –P 环境定义id

【范例】：
mvn install –P pro_env

附录

更新依赖索引

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

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

image-20231016160820355

清理Maven仓库

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

image-20231016160850612

如果本地仓库中有很多这样的以lastUpadted结尾的文件，可以定义一个批处理文件，在其中编写如下脚本来删除： 

1
2
3
4
5
6
7
set REPOSITORY_PATH=E:\develop\apache-maven-3.6.1\mvn_repo
rem 正在搜索...

del /s /q %REPOSITORY_PATH%\*.lastUpdated

rem 搜索完毕
pause

操作步骤如下：

  1. 定义批处理文件del_lastUpdated.bat (直接创建一个文本文件，命名为del_lastUpdated，后缀名直接改为bat即可 )

image-20221214154949482

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

image-20231016160938645

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