Maven项目管理工具

君问归期魏有期

已于 2023-03-02 15:26:42 修改

阅读量1.1k

点赞数 1

分类专栏： Java 文章标签： maven intellij-idea java

于 2022-05-06 21:43:50 首次发布

本文链接：https://blog.csdn.net/LongLiveThePRC/article/details/124618719

版权

Java 专栏收录该内容

140 篇文章 2 订阅

订阅专栏

Maven项目管理工具

引言

`为什么要使用Maven管理项目？`

当把项目作为jar包运行，或者使用一些接口需要导入各种jar包，很繁琐也很头大
然而maven，正是一款包管理机制，通过它可以实现：

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

IDEA自带Maven环境，所以直接创建一个新的Maven项目即可。

正文

1. Maven项目结构

Maven项目和普通的项目有什么区别：
在这里插入图片描述

首先看一下POM文件，整个Maven项目的配置文件，它也是使用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>groupId</groupId>
    <artifactId>Step_Two</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这三个元素合在一起，用于唯一区别每个项目，如需要将的代码作为依赖，须通过这三个元素来定位项目，所以称此为项目的基本坐标。一般地，项目都有自己的Maven坐标，因此通过Maven导入其他的依赖只需要填写这三个基本元素即可，无需再下载Jar文件，Maven自动下载依赖并导入。

groupId一般用于指定组名称，命名规则一般和包名一致，比如当使用的是groupId，一个组下面可以有很多个项目。
artifactId 一般用于指定项目在当前组中的唯一名称，也就是说在组中用于区分于其他项目的标记。
version代表项目版本，随着目的开发和改进，版本号也会不断更新，同时可以手动指定当前项目的版本号，当引用项目作为依赖时，可以根本版本号进行选择

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

2. Maven依赖导入

首先创建一个dependencies节点：

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

具体的依赖可以在：https://mvnrepository.com/ 进行查询

以lombok依赖为例，使用方法如下：

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
        </dependency>
    </dependencies>

Maven项目的依赖管理流程：

在这里插入图片描述

通过流程图可知，一个项目依赖一般是存储在中央仓库中，也有可能存储在一些其他的远程仓库（私服），几乎所有的依赖都被放到了中央仓库中，因此，Maven可以直接从中央仓库中下载大部分的依赖，远程仓库中下载之后，会暂时存储在本地仓库

在下次导入依赖时，如果Maven发现本地仓库中就已经存在某个依赖，那么就不会再去远程仓库下载了。

注：可能在导入依赖时，会出现卡顿的问题，可以使用阿里云镜像来解决：打开IDEA的安装目录，找到安装根目录/plugins/maven/lib/maven3/conf文件夹，找到settings.xml文件，打开编辑：

找到mirros标签，添加以下内容：

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

3. Maven依赖作用域

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

type：依赖的类型，对于项目坐标定义的packaging。默认值为jar
scope：依赖的范围（作用域，着重讲解）
optional：标记依赖是否可选
exclusions：用来排除传递性依赖（如果我们）

需要特别注意一下scope属性，它决定了依赖的作用域范围：

compile：此种依赖，在编译、运行、测试时均有效，为默认的依赖有效范围。
provided：在编译、测试时有效。
system：作用域和provided是一样的，但是它不是从远程仓库获取，而是直接导入本地Jar包：
runtime：在运行、测试时有效。
test：只在测试时有效。

4. Maven可选依赖

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

<optional>true</optional>

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

<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之后想用什么日志框架再自己加就可以了。

5. Maven排除依赖

了解了可选依赖，就可以让使用此项目作为依赖的项目默认不使用可选依赖，但是如果存在那种不是可选依赖，但是导入此项目后不希望使用此依赖就可以通过排除依赖来防止添加不必要的依赖：

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

6. Maven继承关系

1.maven项目之间的继承

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

给该项目添加两个子项目：Chilegirl和Childboy，此时父项目会多出来几个标签：

父项目pom文件：

<?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>groupId</groupId>
    <artifactId>Step_Two</artifactId>
    <!--        添加子项目就会有这个标签-->
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>

    <modules>
<!--        这里面是该项目的子项目-->
        <module>Chile_boy</module>
        <module>Child_girl</module>
    </modules>

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

子项目pom文件：

<?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>Step_Two</artifactId>
        <groupId>groupId</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
<!--    模块版本号-->
    <modelVersion>4.0.0</modelVersion>
<!--    id-->
    <artifactId>Chile_boy</artifactId>

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

</project>

子项目pom文件：

<?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>Step_Two</artifactId>
        <groupId>groupId</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>Child_girl</artifactId>

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


    <dependencies>
<!--        这里把别的模块作为自己的依赖加载进项目-->
        <dependency>
            <artifactId>Chile_boy</artifactId>
            <groupId>groupId</groupId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>

可以看到，子项目直接继承父项目的groupId，子项目会直接继承父项目的所有依赖。

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

<!--此处存放不可被继承的依赖-->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.25</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>3.5.7</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>2.0.6</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>5.3.13</version>
            </dependency>
            <!--单元测试的依赖-->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
            </dependency>

        </dependencies>
    </dependencyManagement>

此时子项目中的依赖全部失效，因为子项目只可以继承dependencies下的依赖。

2. 把模块作为依赖

如：这里把boy子项目加载入girl子项目，只需在girl子项目下面加上dependencies即可

    <dependencies>
<!--        这里把别的模块作为自己的依赖加载进项目-->
        <dependency>
            <artifactId>Chile_boy</artifactId>
            <groupId>groupId</groupId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

此时girl项目即可使用boy项目下的类了。

7. Maven常用命令

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

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

8. Maven测试项目

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

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

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

<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也能使用了。

9. Maven打包项目

把项目当作一个可执行文件，在控制台运行，只需要直接执行package命令就可以直接对项目的代码进行打包，生成jar文件。此方式仅适用于作为Jar依赖的情况

如果需要打包一个可执行文件，还需要将依赖也一并打包到Jar中，则需要以下插件来实现。

    <build>
        <plugins>
<!--            打包依赖插件-->
            <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>

        </plugins>
    </build>

此时可以点击package来打包或者手动执行Maven命令：mvn package -Dmaven.test.skip=true

得到Jar文件，在同级目录下输入java -jar xxxx.jar即可运行打包好的Jar可执行程序

比如：把项目的jar文件demo.jar通过Xftp复制到服务器/and目录，可以用Xshell直接进入目录`cd /and`,然后运行项目：`java -jar demo.jar`

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

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

君问归期魏有期

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Maven项目管理工具

作为父级项目，还有一个重要的属性，那就是modules，通过modules标签将项目的所有子项目引用进来，在build父级项目时，会根据子模块的相互依赖关系整理一个build顺序，然后依次build。通过流程图可知，一个项目依赖一般是存储在中央仓库中，也有可能存储在一些其他的远程仓库（私服），几乎所有的依赖都被放到了中央仓库中，因此，Maven可以直接从中央仓库中下载大部分的依赖，远程仓库中下载之后，会暂时存储在本地仓库。当项目中的某些依赖不希望被使用此项目作为依赖的项目使用时，可以给依赖添加。
复制链接

扫一扫