maven项目多模块好还是但模块好 maven多模块依赖规范

目录

• 
  
• 
  
• Maven管理多模块：

• Maven多模块管理的方式一：
• 各个子模块的依赖版本管理：
• Maven多模块管理的方式二：
• 子工程继承父工程的编译插件：
• Maven多模块管理的方式三（混用方式一和方式二）：

Maven管理多模块：

上图就是利用maven的统一管理依赖版本。

Maven多模块管理的方式一：

案例演示：继承

pom: 即Project Object Model：项目对象模型,该 文件是可以被子工程被继承的。
maven的多模块管理，其实就是让它的子模块的pom文件来继承父工程的pom文件。

（1）创建一个空项目：项目名称：maven-modules-project

File–>New -->Project–>Empty Project : maven-modules-project

（2）创建总maven模块: 模块名称：001-maven-parent

保证我们的所有模块都是在空项目的根目录下：

（3）删除总maven模块的src文件：并将packaging设置为pom：

（4）创建子maven模块：
File–>New–>Module–>Maven(记得选择jdk):

子maven模块名字：002-maven-java

idea2020创建子模块方式：

其他idea创建子模块方式：

创建完成后的效果：

父模块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>

    <!--父模块的gav-->
    <groupId>com.fan</groupId>
    <artifactId>001-maven-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--通过modules标签自动来聚合子模块-->
    <modules>
        <module>../002-maven-java</module>
    </modules>
    <!--父工程/模块打包成pom-->
    <packaging>pom</packaging>
    
</project>

子模块pom.xml:

注意：子模块这里没有自己的groupId、version，只有自己的artifactId,子模块没必要声明groupId，version因为父工程已经声明了。

<?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标签用于指向父模块的gav-->
    <parent>
        <artifactId>001-maven-parent</artifactId>
        <groupId>com.fan</groupId>
        <version>1.0-SNAPSHOT</version>
        <!--指向父模块pom相对位置：上一级目录出去然后到001-maven-parent/pom.xml知道父模块pom-->
        <relativePath>../001-maven-parent/pom.xml</relativePath>
    </parent>
    <!--maven模块版本，对于maven2和maven3的值都只能是4.0.0-->
    <modelVersion>4.0.0</modelVersion>
    <!--子模块的模块名称，注意：这里没有groupId、version，只有a,子模块没必要声明groupId，version-->
    <artifactId>002-maven-java</artifactId>
    
</project>

效果说明：

①.parent标签:
在Maven中,如果多个模块都需要声明相同的配置,例如：groupId、version、有相同的依赖、或者相同的组件配置等,也有类似Java的继承机制,用parent声明要继承的父工程的pom配置(继承)。

②.relativePath标签：
父项目的pom.xml文件的相对路径。默认值为…/pom.xml。maven首先从当前构建项目开始查找父项目的pom文件,然后从本地仓库找,然后从远程仓库找。RelativePath允许你选择一个不同的位置。

如果默认…/pom.xml没找到父元素的pom,不配置relativePath指向父项目的pom则会报错。

创建maven的web子模块：

使子maven模块002-maven-java变成父模块：

遵循两点：打包方式变成pom和父模块删除src文件

爷爷模块名称：001-maven-parent

父模块名称： 002-maven-java

孙子模块名称：002-son-maven-java

各个子模块的依赖版本管理：

父工程添加的依赖，所有子模块会无条件的去继承：

在我们项目顶层的POM文件中，我们会看到dependencyManagement元素。通过它来管理jar包的版本，让子项目中引用一个依赖而不用显式的列出版本号。Maven会沿着父子层次向上走，直到找到一个拥有dependencyManagement元素的项目，然后它就会使用在这个dependencyManagement元素中指定的版本号。

这样做的好处：统一管理项目的版本号，确保应用的各个项目的依赖和版本一致，才能保证测试的和发布的是相同的成果，因此，在顶层pom中定义共同的依赖关系。同时可以避免在每个使用的子项目中都声明一个版本号，这样想升级或者切换到另一个版本时，只需要在父类容器里更新，不需要任何一个子项目的修改；如果某个子项目需要另外一个版本号时，只需要在dependencies中声明一个版本号即可。子类就会使用子类声明的版本号，不继承于父类版本号。

dependencyManagement里只是声明依赖，并不实现引入，因此子项目需要显示的声明需要用的依赖。如果不在子项目中声明依赖，是不会从父项目中继承下来的；只有在子项目中写了该依赖项，并且没有指定具体版本，才会从父项目中继承该项，并且version和scope都读取自父pom;另外如果子项目中指定了版本号，那么会使用子项目中指定的jar版本。

想要成为父工程必须遵循以下两点要求：

a. packaging标签的文本内容必须设置为pom
b. 必须删除src目录
3. dependencyManagement：依赖管理标签，其管理的依赖，子工程可通过声明式依赖继承，若无此标签管理依赖，则子工程自动继承父工程所有依赖

4.一个标准的父工程应该是这样的：

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <!--1、描述这个POM文件是遵从哪个版本的项目描述符-->
    <modelVersion>4.0.0</modelVersion>

    <!--2、添加parent标签，表示这是一个springboot项目-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <!--3、项目信息，注意为了不让父模块也打包成jar包或war包就需要把打包方式改为pom类型-->
    <groupId>com.wang</groupId>
    <artifactId>guli</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>pom</packaging>

    <!--4、版本参数-->
    <properties>
        <java.version>1.8</java.version>

    </properties>

    <!--5、依赖管理：统一子模块的依赖版本-->
    <dependencyManagement>
        <dependencies>

        </dependencies>
    </dependencyManagement>
      <!--6、插件-->
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

</project>

为了不让每个模块定制化自己独有的依赖，而不是父工程所有的依赖都拿过来使用，造成依赖冗余。
这里使用dependencyManagement标签来加强管理(dependencyManagement本质就是管理了一堆的版本号)：

父工程pom:

子工程pom:

父工程本质是管理的一堆版本号，那我们把版本号单独拿出来定义并管理，这里使用标签properties来定义：

⑧.properties:使用properties标签内使用自定义标签统一声明版本号,例如project.build.sourceEncoding（项目构建源码编码方式）,可以设置为UTF-8,防止中文乱码,也可定义相关构建版本号,便于日后统一升级(配置属性)。

使用案例：

<?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>MavenDemo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--packaging标签定义成pom工程，
    pom工程是一个逻辑工程，没有任何的包的实际引入，只做包的版本声明-->
    <packaging>pom</packaging>

    <!--声明变量，一般用于版本号的声明-->
    <properties>
        <mybatis.version>3.5.6</mybatis.version>
    </properties>

    <!--依赖管理器：用于声明依赖的坐标gav，不实际引入jar-->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <!--依赖的坐标-->
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>${mybatis.version}</version>
                <!--依赖的范围：import只能用于dependencyManagement
                中的scope中，表明指定的pom必须导入我规定的版本号-->
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

</project>

总结：父工程本质是通过dependencyManagement和properties管理了一堆的版本号

Maven多模块管理的方式二：

案例演示：
（1）直接创建一个父工程：maven-parent（区别与方式一的空工程）

（2）创建子maven模块：maven-java-01

子模块maven-java-01的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指向父工程-->
    <parent>
        <artifactId>maven-parent</artifactId>
        <groupId>com.fan</groupId>
        <version>1.0-SNAPSHOT</version>
        <!--parent标签的这里没有relativePath,因为在同一级目录，能自动找到-->
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <!--子模块只有自己的artifactId，groupId和version默认使用父工程的，这里不需要写-->
    <artifactId>maven-java-01</artifactId>

</project>

父maven工程maven-parent的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>
    <!--父工程自己的gav-->
    <groupId>com.fan</groupId>
    <artifactId>maven-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--父工程打包为pom-->
    <packaging>pom</packaging>

    <!--父工程通过modules标签来聚合所有的子模块-->
    <modules>
        <!--module是子模块的模块名称-->
        <module>maven-java-01</module>
    </modules>

</project>

父工程的管理版本号的方式dependencyManagement和properties都一样的用法。

子工程继承父工程的编译插件：

查看项目的默认jdk编译版本：

在父工程设置jdk编译插件的版本：

<build>
        <plugins>
            <!--jdk编译插件-->
            <plugin>
                <!--jdk编译插件的坐标-->
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <!--源代码编译成class文件的版本-->
                    <target>1.8</target>
                    <!--源码使用的jdk版本-->
                    <source>1.8</source>
                    <!--项目构建使用的编码,避免中文乱码-->
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>

Maven多模块管理的方式三（混用方式一和方式二）：