Maven

Maven 简介

Maven 是 Apache 下的一个纯 Java 开发的项目管理和整合工具。它将项目的开发和管理过程抽象成一个项目对象模型（POM）。开发人员只需要做一些简单的配置，Maven 就可以自动完成项目的编译、测试、打包、发布以及部署等工作。

通过Maven，可以帮助我们做：

• 项目的自动构建，包括代码的编译、测试、打包、安装、部署等操作。
• 依赖管理，项目使用到哪些依赖，可以快速完成导入。

之前我们导入依赖的时候，每次都要去下载对应的 Jar 包，这样其实是很麻烦的，并且还有可能一个 Jar 包依赖于另一个 Jar 包，因此我们需要一个更加方便的包管理机制。

Maven安装

下载 Maven

• 安装前请确认 JDK 已安装完毕
• 官网下载地址：Maven – Download Apache Maven
• 下载 apache-maven-3.8.5-bin.zip，解压后移动到 /opt目录下

配置环境变量

配置 .bash_profile 环境变量，但是如果你安装了 iterm zsh 就需要在 .zshrc 环境变量文件中配置

代码语言：javascript复制

$ vim ~/.zshrc

#注意将路径修改为你的maven文件路径
export MAVEN_HOME=/opt/maven/apache-maven-3.8.4 
export PATH=$PATH:$MAVEN_HOME/bin

$ source ~/.zshrc #更新环境变量

$ mvn -v  #测试maven

Maven目录结构

代码语言：javascript复制

$ tree -L 1
.
├── LICENSE
├── NOTICE
├── README.txt
├── bin
├── boot
├── conf
└── lib

• bin：该目录包含了 mvn 运行的脚本
• boot：该目录只包含一个文件，该文件为plexus-classworlds-2.6.0.jar
  • plexus-classworlds 是一个类加载器框架，相对于默认的 java 类加载器，它提供了更加丰富的语法以方便配置，Maven 使用该框架加载自己的类库。
• conf：该目录包含了一个非常重要的文件 settings.xml
  • 直接修改该文件，就能在机器上全局地定制 Maven的行为，一般情况下，我们可以直接复制该文件至~/.m2/目录下，然后修改该文件，在用户范围定制Maven的行为
• lib：该目录包含了所有 Maven 运行时需要的Java类库和 Maven 用到的第三方依赖

更换镜像

全局配置

打开apache-maven-3.8.4/conf/setting.xml 文件，大概在150行左右，找到mirrors，添加如下代码：

代码语言：javascript复制

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

注：IDEA自带的Maven的配置文件在/User/.m2/settings.xml 位置下

使用IDEA创建时，在偏好设置下的构建工具中进行修改Maven配置

代码语言：javascript复制

Maven主路径：/opt/maven/apache-maven-3.8.4
用户设置文件：/opt/maven/apache-maven-3.8.4/conf/settings.xml
本地仓库：/opt/maven/repository

单项目配置

单项目配置时，需要修改pom文件。在pom文件中，通过覆盖默认的中央仓库的配置，实现中央仓库地址的变更。 修改项目的pom文件：

代码语言：javascript复制

<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.test</groupId>
    <artifactId>conifg</artifactId>
    <packaging>war</packaging>
    <version>0.0.1-SNAPSHOT</version>

    <repositories>
        <repository>
            <id>central</id>
            <name>aliyun maven</name>
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
            <layout>default</layout>
            <!-- 是否开启发布版构件下载 -->
            <releases>
                <enabled>true</enabled>
            </releases>
            <!-- 是否开启快照版构件下载 -->
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>

</project>

Maven项目结构

我们可以来看一下，一个 Maven 项目和我们普通的项目有什么区别：

代码语言：javascript复制

$ tree -L 3
.
├── pom.xml #配置文件
├── src
│   ├── main
│   │   ├── java #Java源代码
│   │   └── resources #资源文件
│   └── test测试资源文件
│       ├── java #Java源代码
│       └── resources #测试资源文件
└── target #项目输出位置，用于存放编译后的文件
    ├── classes #编译输出文件
    └── generated-sources

Maven POM

POM文件，它相当于是我们整个Maven项目的配置文件，是使用XML编写的：

代码语言：javascript复制

<?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>org.example</groupId>
    <artifactId>MavenTest</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

</project>

我们可以看到，Maven的配置文件是以project为根节点，而modelVersion定义了当前模型的版本，一般是4.0.0，我们不用去修改。

groupId、artifactId、version这三个元素合在一起，用于唯一区别每个项目，别人如果需要将我们编写的代码作为依赖，那么就必须通过这三个元素来定位我们的项目

节点	描述
groupId	项目组 ID，定义当前 Maven 项目隶属的组织或公司，通常是唯一的。它的取值一般是项目所属公司或组织的网址或 URL 的反写，例如 net.biancheng.www。
artifactId	项目 ID，通常是项目的名称。groupId 和 artifactId 一起定义了项目在仓库中的位置。
version	项目版本。

properties中一般都是一些变量和选项的配置，我们这里指定了JDK的源代码和编译版本为1.8，无需进行修改。

Maven依赖导入

现在我们尝试使用Maven来帮助我们快速导入依赖，我们尝试导入 JUnit 依赖

我们可以创建一个dependencies节点：

代码语言：javascript复制

<dependencies>
    //里面填写的就是所有的依赖
</dependencies>

那么现在就可以向节点中填写依赖了，如何获取依赖的坐标呢？

• 可以在：https://mvnrepository.com/ 进行查询
• 直接搜索 JUnit 即可，选择合适的版本，依赖详情页的最下方就是该版本依赖的 Maven 坐标

代码语言：javascript复制

<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
    <scope>test</scope>
</dependency>

我们直接将其添加到dependencies节点中即可

Maven 仓库

那么，Maven是如何进行依赖管理呢，以致于如此便捷的导入依赖，我们来看看Maven项目的依赖管理流程：

通过流程图我们得知

• 一个项目依赖一般是存储在中央仓库中
• 也有可能存储在一些其他的远程仓库（私服）

几乎所有的依赖都被放到了中央仓库中，因此，Maven可以直接从中央仓库中下载大部分的依赖（Maven第一次导入依赖是需要联网的）

远程仓库中下载之后 ，会暂时存储在本地仓库，我们会发现我们本地存在一个.m2文件夹，这就是Maven本地仓库文件夹，在下次导入依赖时，如果Maven发现本地仓库中就已经存在某个依赖，那么就不会再去远程仓库下载了。

使用 IDEA 在导入依赖时，会出现卡顿的问题，建议配置一下IDEA自带的Maven插件远程仓库地址，我们打开IDEA的安装目录，找到安装根目录/plugins/maven/lib/maven3/conf文件夹，找到settings.xml文件，打开编辑，找到mirros标签，添加以下内容：

代码语言：javascript复制

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

这样，我们就将默认的远程仓库地址（国外），配置为国内仓库地址了，依赖的下载速度就会快起来了

Maven依赖作用域

除了三个基本的属性用于定位坐标外，依赖还可以添加以下属性：

• type：依赖的类型，对于项目坐标定义的packaging。大部分情况下，该元素不必声明，其默认值为jar
• scope：依赖的范围（作用域，着重讲解）
• optional：标记依赖是否可选
• exclusions：用来排除传递性依赖（一个项目有可能依赖于其他项目，就像我们的项目，如果别人要用我们的项目作为依赖，那么就需要一起下载我们项目的依赖，如Lombok）

我们着重来讲解一下scope属性，它决定了依赖的作用域范围：

• compile ：默认的依赖有效范围，在编译、运行、测试时均有效。如果在定义依赖关系的时候，没有明确指定依赖有效范围的话，则默认采用该依赖有效范围。
• provided ：在编译、测试时有效，但是在运行时无效，也就是说，项目在运行时，不需要此依赖，比如 Lombok，我们只需要在编译阶段使用它，编译完成后，实际上已经转换为对应的代码了，因此Lombok不需要在项目运行时也存在。
• runtime ：在运行、测试时有效，但是在编译代码时无效。比如我们如果需要自己写一个JDBC实现，那么肯定要用到JDK为我们指定的接口，但是实际上在运行时是不用自带JDK的依赖，因此只保留我们自己写的内容即可。
• test ：只在测试时有效，例如：JUnit，我们一般只会在测试阶段使用JUnit，而实际项目运行时，我们就用不到测试了，那么我们来看看，导入JUnit的依赖：

同样的，我们可以在网站上搜索Junit的依赖，我们这里导入最新的JUnit5作为依赖：

代码语言：javascript复制

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.8.1</version>
    <scope>test</scope>
</dependency>

我们所有的测试用例全部编写到Maven项目给我们划分的test目录下，位于此目录下的内容不会在最后被打包到项目中，只用作开发阶段测试使用，因此，一般仅用作测试的依赖如JUnit只保留在测试中即可

Maven导入本地jar包

实际的开发过程中，经常会遇到一种情况：某一个项目需要依赖于存储在本地的某个 jar 包，该 jar 包无法从任何仓库中下载的，这种依赖被称为外部依赖或本地依赖。那么这种依赖是如何声明的呢？

可以使用第四种依赖作用域：

• system：作用域和provided是一样的，但是它不是从远程仓库获取，而是直接导入本地Jar包：

代码语言：javascript复制

<dependency>
     <groupId>javax.jntm</groupId>
     <artifactId>lbwnb</artifactId>
     <version>2.0</version>
     <!--依赖范围-->
     <scope>system</scope>
     <!--依赖所在位置-->
     <systemPath>C://学习资料/4K高清无码/test.jar</systemPath>
</dependency>

Maven可选依赖

当项目中的某些依赖的依赖不希望被使用时，我们可以给依赖添加optional标签表示此依赖是可选的，默认在导入依赖时，不会导入可选的依赖：

代码语言：javascript复制

<optional>true</optional>

比如Mybatis的POM文件中，就存在大量的可选依赖：

代码语言：javascript复制

<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-api</artifactId>
  <version>1.7.30</version>
  <!--设置可选依赖  -->
  <optional>true</optional>
</dependency>
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-log4j12</artifactId>
  <version>1.7.30</version>
  <!--设置可选依赖  -->
  <optional>true</optional>
</dependency>
<dependency>
  <groupId>log4j</groupId>
  <artifactId>log4j</artifactId>
  <version>1.2.17</version>
  <!--设置可选依赖  -->
  <optional>true</optional>
</dependency>
 ...

由于Mybatis要支持多种类型的日志，需要用到很多种不同的日志框架，因此需要导入这些依赖来做兼容，但是我们项目中并不一定会使用这些日志框架作为Mybatis的日志打印器，因此这些日志框架仅Mybatis内部做兼容需要导入使用，而我们可以选择不使用这些框架或是选择其中一个即可，也就是说我们导入Mybatis之后想用什么日志框架再自己加就可以了。

Maven排除依赖

如果存在那种不是可选依赖，但是我们导入此项目又不希望使用此依赖该怎么办呢，这个时候我们就可以通过排除依赖来防止添加不必要的依赖：

代码语言：javascript复制

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.8.1</version>
    <scope>test</scope>
  
    <!--排除依赖  -->
    <exclusions>
        <exclusion>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
        </exclusion>
    </exclusions>
  
</dependency>

这里演示了排除JUnit的engine依赖，我们可以在外部库中观察排除依赖之后和之前的效果。

Maven继承关系

一个Maven项目可以继承自另一个Maven项目，比如多个子项目都需要父项目的依赖，我们就可以使用继承关系来快速配置。

我们右键左侧栏，新建一个模块，来创建一个子项目：

代码语言：javascript复制

<?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>MavenTest</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>ChildModel</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

</project>

我们可以看到，IDEA默认给我们添加了一个parent节点，表示此Maven项目是父Maven项目的子项目，子项目直接继承父项目的groupId，子项目会直接继承父项目的所有依赖，除非依赖添加了optional标签

我们还可以让父Maven项目统一管理所有的依赖，包括版本号等，子项目可以选取需要的作为依赖，而版本全由父项目管理，我们可以将dependencies全部放入dependencyManagement节点，这样父项目就完全作为依赖统一管理。

代码语言：javascript复制

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>5.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.27</version>
        </dependency>
    </dependencies>
</dependencyManagement>

现在子项目不能直接继承父项目的依赖了，因为现在父项目将所有的依赖进行集中管理，子项目需要什么拿什么即可，同时子项目无需指定版本，所有的版本全部由父项目决定，子项目只需要使用即可：

代码语言：javascript复制

<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <scope>provided</scope>
    </dependency>
</dependencies>

当然，父项目如果还可以存在dependencies节点的话，里面的内依赖依然是直接继承

代码语言：javascript复制

<dependencies>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>5.8.1</version>
        <scope>test</scope>
    </dependency>
</dependencies>

<dependencyManagement>
    <dependencies>
      ...

Maven常用命令

我们可以看到在IDEA右上角Maven板块中，每个Maven项目都有一个生命周期，实际上这些是Maven的一些插件，每个插件都有各自的功能，比如：

• clean命令，执行后会清理整个target文件夹，在之后编写Springboot项目时可以解决一些缓存没更新的问题。
• validate命令可以验证项目的可用性。
• compile命令可以将项目编译为.class文件。
• install命令可以将当前项目安装到本地仓库，以供其他项目导入作为依赖使用
• verify命令可以按顺序执行每个默认生命周期阶段（validate，compile，package等）

在IDEA Maven 工具窗口中，我们可以通过以下 3 种方式中执行 Maven 命令：

• 1、使用 Run Anything 窗口
  • 在 Maven 工具窗口的工具栏上，点击“m”按钮，或在 IntelliJ IDEA 中连续两次按下 Ctrl 键，即可打开 Run Anything 窗口
• 2、使用 Maven 工具窗口的上下文菜单
  • 在 Maven 工具窗口，点击项目名下面的 LifeCycle
  • 右键单击 Maven 目标，在上下文菜单选择 Run ‘项目名 [Maven 目标]’（例如：Run ‘secondEclipse [clean]’），即可执行该目标
• 3、为一个或一组 Maven 目标创建运行配置。
  • 在 Maven 工具窗口，点击项目名下面的 LifeCycle
  • 按住 Ctrl/Command 键同时选择一个或多个 Maven 目标，然后单击鼠标右键，在下拉菜单中选择 Create Run Configuration… 或者 Modify Run Configuration…
  • 在创建运行配置窗口，我们可以为 Maven 目标指定 Maven 命令和参数等，设置完成后，点击 OK 按钮保存该运行配置
  • 配置完成后，在 Maven 工具窗口下自动生成了一个 Run Configurations 节点，在该节点下可以看到运行配置列表
  • 在运行配置列表中，双击目标，或右键点击该目标然从上下文菜单中选择 Run，即可运行该目标。

Maven测试项目

通过使用test命令，可以一键测试所有位于test目录下的测试案例，请注意有以下要求：

• 测试类的名称必须是以Test结尾，比如MainTest
• 测试方法上必须标注@Test注解，实测@RepeatedTest无效

这是由于JUnit5比较新，我们需要重新配置插件升级到高版本，才能完美的兼容Junit5：

代码语言：javascript复制

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <!-- JUnit 5 requires Surefire version 2.22.0 or higher -->
            <version>2.22.0</version>
        </plugin>
    </plugins>
</build>

现在@RepeatedTest、@BeforeAll也能使用了。

Maven打包项目

我们的项目在编写完成之后，要么作为Jar依赖，供其他模型使用，要么就作为一个可以执行的程序，在控制台运行，我们只需要直接执行package命令就可以直接对项目的代码进行打包，生成jar文件。

当然，以上方式仅适用于作为Jar依赖的情况，如果我们需要打包一个可执行文件，那么我不仅需要将自己编写的类打包到Jar中，同时还需要将依赖也一并打包到Jar中，我们需要使用另一个插件来实现一起打包：

代码语言：javascript复制

<plugin>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>3.1.0</version>
    <configuration>
        <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
        <archive>
            <manifest>
                <addClasspath>true</addClasspath>
                <mainClass>com.test.Main</mainClass>
            </manifest>
        </archive>
    </configuration>
    <executions>
        <execution>
            <id>make-assembly</id>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
        </execution>
    </executions>
</plugin>

在打包之前也会执行一次test命令，来保证项目能够正常运行，当测试出现问题时，打包将无法完成，我们也可以手动跳过，选择执行Maven目标来手动执行Maven命令，输入mvn package -Dmaven.test.skip=true 来以跳过测试的方式进行打包。

最后得到我们的Jar文件，在同级目录下输入java -jar xxxx.jar来运行我们打包好的Jar可执行程序（xxx代表文件名称）

• deploy命令用于发布项目到本地仓库和远程仓库，一般情况下用不到。
• site命令用于生成当前项目的发布站点，暂时不需要了解。

多模块下父项目存在一个packing打包类型标签，所有的父级项目的packing都为pom，packing默认是jar类型，如果不作配置，maven会将该项目打成jar包。作为父级项目，还有一个重要的属性，那就是modules，通过modules标签将项目的所有子项目引用进来，在build父级项目时，会根据子模块的相互依赖关系整理一个build顺序，然后依次build。

参考

• Maven教程
• JavaWeb笔记（三）
• JavaWeb 教程 哔哩哔哩_bilibili（51p～55p）

maven 项目管理 git github jar

0 人点赞