maven多模块项目管理（帮助你解决许多的依赖版本问题）

会飞的小蜗

已于 2022-01-25 15:22:49 修改

阅读量1.5k

点赞数

分类专栏：工具 java 文章标签： maven java

于 2022-01-23 15:49:31 首次发布

本文链接：https://blog.csdn.net/YL3126/article/details/122651092

版权

java 同时被 2 个专栏收录

86 篇文章 4 订阅

订阅专栏

工具

14 篇文章 1 订阅

订阅专栏

文章目录

一、第一种创建方式

博客：https://blog.csdn.net/qq_40925189/article/details/103842208

1、创建空项目，然后起个名字

在这里插入图片描述

2、然后在创建好的空项目中，创建父工程

在这里插入图片描述

3、名词解析

名词解释：

GroupID 是项目组织唯一的标识符，实际对应JAVA的包的结构，是main目录里java的目录结构。

ArtifactID是项目的唯一的标识符，实际对应项目的名称，就是项目根目录的名称。

-----------------1 基础知识必备----------------------------

<groupId>com.yucong.commonmaven</groupId> 
<artifactId>commonmaven</artifactId> 
<version>0.0.1-SNAPSHOT</version> 
<packaging>jar</packaging> 
<name>common_maven</name>

groupId

定义了项目属于哪个组，举个例子，如果你的公司是mycom，有一个项目为myapp，那么groupId就应该是com.mycom.myapp.

artifacted
定义了当前maven项目在组中唯一的ID,比如，myapp-util,myapp-domain,myapp-web等。

version
指定了myapp项目的当前版本，SNAPSHOT意为快照，说明该项目还处于开发中，是不稳定的版本。

name
声明了一个对于用户更为友好的项目名称，不是必须的，推荐为每个pom声明name，以方便信息交流。

-----------------2 何为mave坐标----------------------------

maven的世界中拥有数量非常巨大的构件，也就是平时用的一些jar,war等文件。 
maven定义了这样一组规则： 
世界上任何一个构件都可以使用Maven坐标唯一标志，maven坐标的元素包括groupId, artifactId, version，package，classifier。 
只要在pom.xml文件中配置好dependancy的groupId，artifact，verison，classifier, 
maven就会从仓库中寻找相应的构件供我们使用。那么，"maven是从哪里下载构件的呢？" 
答案很简单，maven内置了一个中央仓库的地址（http://repol.maven.org/maven2）,该中央仓库包含了世界上大部分流行的开源项目构件，maven会在需要的时候去那里下载。

-----------------3 坐标详解----------------------------

<groupId>org.sonatype.nexus</groupId> 
<artifactId>nexus-indexer</artifactId> 
<version>2.0.0</version> 
<packaging>jar</packaging>

groupId
定义当前maven项目隶属的实际项目。
groupId的表示方式与Java包名的表示方式类似，如： org.sonatype.nexus

artifactId
该元素定义实际项目中的一个Maven项目（模块），推荐的做法是使用实际项目的名称作为artifactId的前缀。
如：nexus-indexer
在默认情况下，maven生成的构件，其文件名会以artifactId作为开头，如：nexus-indexer-2.0.0.jar。

packaging【可选的，默认为jar】：
当不定义packaging时，maven会使用默认值jar。

classifier:
该元素用来帮助定义构件输出的一些附属构件。
项目构件的文件名是坐标相对应的，一般的规则为：artifact-version.packing

4、父工程创建好后，必须遵循两个原则

<!--
    maven父工程必须遵循以下两点要求：
    1、packaging的标签文本内容必须设置为pom
    2、父工程必须删除掉src包
-->

在这里插入图片描述

5、创建子工程

在这里插入图片描述

在这里插入图片描述
这时候我们可以看到，子工程已经创建好了，且 parent 标签指向了父工程：

6、依赖版本控制（重要）

这里我留下两个 pom ，供大家参考，里面会有详细的注释

父工程 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>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.8.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.devtest.test</groupId>
    <artifactId>maven-parent</artifactId>
    <version>1.0.0</version>

    <packaging>pom</packaging>
    <!--
        maven父工程必须遵循以下两点要求：
        1、packaging的标签文本内容必须设置为pom
        2、父工程必须删除掉src包
    -->

    <!--
        packaging标签 是设置打包方式，默认如果没有 packaging 标签，则打 jar 包
    -->

    <!--所有依赖的版本管理-->
    <!--通常管理版本依赖的标签名字构成由： 项目名+字段 version   来自定义-->
    <properties>
        <mysql.version>8.0.19</mysql.version> <!--用“ . ” 拼接-->
        <junit-version>4.12</junit-version> <!--用“ - ” 拼接，你随意选-->
        <spring-boot-web.version>2.1.8.RELEASE</spring-boot-web.version>
    </properties>

    <!--父模块加强管理子模块的所有依赖-->
    <dependencyManagement>
        <dependencies>
            <!--MySQL 依赖 -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <!--junit 依赖-->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit-version}</version>
            </dependency>
  <!--starter-web-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <version>${spring-boot-web.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <!--JDK8 编译插件 ，制定了这个才能保证编译时用1.8-->
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</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>maven-parent</artifactId>
        <groupId>com.devtest.test</groupId>
        <version>1.0.0</version>
        <relativePath>../mavenparent/pom.xml</relativePath>
    </parent>

    <modelVersion>4.0.0</modelVersion>
    <artifactId>son01</artifactId>

    <!--指定继承父工程的依赖-->
    <!--
        你点开右侧的 maven看一下 ，是不是版本一致，大功告成！
        这样做之后，所有的父工程中的 依赖版本 就把子工程的控制住了，
        当然，如果你强行不想用父工程的依赖，也可以自己加上 依赖的 <version>
        标签。
    -->
    <dependencies>
        <!--MySQL 依赖 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <!--junit 依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.8.2</version> <!--不使用父工程的依赖版本-->
        </dependency>
        
        <!--starter-web-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
	<!--打包必须放在子项目中-->
    <build>
        <plugins>
            <!--打包插件-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.dev.test</groupId>
    <artifactId>parent</artifactId>
    <version>1.0.0</version>
    <packaging>pom</packaging>

    <modules>
        <module>common</module>
        <module>product</module>
    </modules>

</project>

common 的 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>parent</artifactId>
        <groupId>com.dev.test</groupId>
        <version>1.0.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>common</artifactId>

    <properties>
        <mysql.version>8.0.19</mysql.version> <!--用“ . ” 拼接-->
        <junit-version>4.12</junit-version> <!--用“ - ” 拼接，你随意选-->
        <skipTests>true</skipTests> <!--跳过测试类-->
    </properties>

    <dependencyManagement>
        <dependencies>
            <!--MySQL 依赖 -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <!--junit 依赖-->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit-version}</version>
            </dependency>

            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <!--JDK8 编译插件 ，制定了这个才能保证编译时用1.8-->
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</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>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.8.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>product</artifactId>

    <dependencies>
        <dependency>
            <groupId>com.dev.test</groupId>
            <artifactId>common</artifactId>
            <version>1.0.0</version>
        </dependency>
        <!--MySQL 依赖 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--junit 依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <!--spring web-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!--打包插件-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

三、打包

先执行父工程 clean 、install
在这里插入图片描述
再执行打包工程的：

其他的使用基本和第一种一模一样，快去试试吧！！！

会飞的小蜗

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
maven多模块项目管理（帮助你解决许多的依赖版本问题）

文章目录一、第一种创建方式（推荐）1、创建空项目，然后起个名字2、然后在创建好的空项目中，创建父工程3、名词解析4、父工程创建好后，必须遵循两个原则5、创建子工程6、依赖版本控制（重要）二、第二种创建方式（推荐）一、第一种创建方式（推荐）1、创建空项目，然后起个名字2、然后在创建好的空项目中，创建父工程3、名词解析名词解释：GroupID 是项目组织唯一的标识符，实际对应JAVA的包的结构，是main目录里java的目录结构。ArtifactID是项目的唯一的标识符，实际对应项目的
复制链接

扫一扫