IDEA中如何使用Maven构建多模块项目？模块间如何相互调用？

一、前言

在 IntelliJ IDEA 中使用 Maven 构建多模块项目（Multi-Module Project）是一个常见的开发场景，尤其适用于大型项目或需要将代码拆分为多个独立模块的项目。通过合理组织模块结构，可以提高项目的可维护性和扩展性。下文将详细说明如何IDEA 中使用 Maven 构建多模块项目以及模块间是如何相互调用的。

二、构建多模块项目

1. 创建多模块项目的目录结构

首先，我们需要设计一个多模块项目的目录结构。假设你有一个项目 parent_project，它包含若干模块例如 module_common，module-a 和 module-b，那么该项目的目录结构可以是如下形式：

parent_project
│
├── module_common
│   ├── src
│   └── pom.xml
│
├── module_a
│   ├── src
│   └── pom.xml
│
├── module_b
│   ├── src
│   └── pom.xml
│
└── pom.xml (父项目的pom文件)

2. 创建父项目的 pom.xml

父项目的 pom.xml 文件用于定义整个项目的配置和模块列表**。它不会编译任何代码，只是一个聚合点。

<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.example</groupId>
    <artifactId>parent_project</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging> <!-- 项目的打包类型必须是pom -->

    <!-- 定义子模块 -->
    <modules>
    	<module>module_common</module>
        <module>module_a</module>
        <module>module_b</module>
    </modules>

    <!-- 统一管理依赖版本 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>com.example</groupId>
                <artifactId>module_a</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>com.example</groupId>
                <artifactId>module_b</artifactId>
                <version>${project.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!-- 其他配置，如插件、属性等 -->
</project>

3. 创建子模块的 pom.xml

（1）module_common 的 pom.xml

module_common 是一个独立的模块，一般情况下会包含一些基础功能或工具类。它的 pom.xml 配置如下：

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

    <!-- 继承项目的配置 -->
    <parent>
        <groupId>com.example</groupId>
        <artifactId>parent_project</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>module_common</artifactId>

    <!-- 模块module_common的依赖 -->
    <dependencies>
        <!-- 例如，添加一些第三方库 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

（2）module_a 的 pom.xml

module_b 的 pom.xml 文件同理：

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

    <!-- 继承项目的配置 -->
    <parent>
        <groupId>com.example</groupId>
        <artifactId>parent_project</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>module_a</artifactId>
    
    <dependencies>
		<!-- 例如，添加一些第三方库 -->
	</dependencies>
</project>

三、构建模块间的调用

1. 在调用模块的pom.xml文件中声明被调用模块

实际开发中，module_a 一般会用到 module_common 中的工具类等，那么我们需要在 module_a 的 pom.xml 中声明对 module_common 的依赖。
在 module_a 的pom.xml文件的<dependencies> </dependencies>部分添加下列依赖：

<!-- 声明对 module_common 的依赖 -->
<dependencies>
    <dependency>
        <groupId>com.example</groupId>
        <artifactId>module_common</artifactId>
        <version>${project.version}</version>
    </dependency>
</dependencies>

2. 在 module_a 中调用 module_common 的代码

由于 module-b 已经声明了对 module-a 的依赖，因此你可以在 module-b 中直接使用 module-a 中的类和方法。假设 module-a 中有一个类 com.example.modulea.ServiceA，你可以在 module-b 中这样调用：

package com.example.modulea;

import com.example.modulea.ServiceA;

public class ServiceB {
    public void doSomething() {
        ServiceA serviceA = new ServiceA();
        serviceA.performAction();
    }
}

四、其他注意事项

（1）统一管理依赖版本

为了简化依赖管理，建议在父项目的 pom.xml 中使用 <dependencyManagement> 来统一管理所有模块的依赖版本。这样，子模块只需要声明依赖的 groupId 和 artifactId，而不需要重复指定版本号。

（2）使用 mvn install 或 mvn package

mvn install：不仅会编译和打包项目，还会将生成的 JAR 文件安装到本地 Maven 仓库中。这对于多模块项目非常重要，因为其他模块可能会依赖这些 JAR 文件。
mvn package：只编译和打包项目，但不会将生成的 JAR 文件安装到本地仓库中。如果你只想构建项目而不安装 JAR 文件，可以使用这个命令。

（3）模块之间的循环依赖

尽量避免模块之间的循环依赖（即 module-a 依赖 module-b，同时 module-b 依赖 module-a）。循环依赖会导致构建失败或难以维护的项目结构。如果确实存在循环依赖，考虑重构代码或将共享的功能提取到一个新的模块中。

五、总结

通过以上步骤，你可以在 IntelliJ IDEA 中使用 Maven 构建一个多模块项目，并确保模块之间能够正确地相互调用。关键点包括：

• 项目的 pom.xml：定义项目的整体结构和模块列表。
• 子模块的 pom.xml：继承父项目的配置，并声明模块间的依赖关系。
• 模块间的依赖：通过 dependency 标签声明模块之间的依赖关系，确保构建顺序正确。
• IDEA 的支持：IDEA 会自动解析 Maven 项目的模块结构，并提供良好的开发体验。
  通过合理的模块化设计，你可以提高项目的可维护性和扩展性，同时利用 Maven 的强大构建工具来管理复杂的依赖关系。