Maven 模块管理

最新推荐文章于 2024-10-02 09:04:28 发布

star walkin

最新推荐文章于 2024-10-02 09:04:28 发布

阅读量343

点赞数

分类专栏： Maven

原文链接：https://juejin.cn/post/6844903970024980488

版权

Maven 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

随着项目的不断发展，需求的不断细化与添加，代码越来越多，结构也越来越复杂，这时候就会遇到各种问题

不同方面的代码之间相互耦合，这时候一系统出现问题很难定位到问题的出现原因，即使定位到问题也很难修正问题，可能在修正问题的时候引入更多的问题。
多方面的代码集中在一个整体结构中，新入的开发者很难对整体项目有直观的感受，增加了新手介入开发的成本，需要有一个熟悉整个项目的开发者维护整个项目的结构（通常在项目较大且开发时间较长时这是很难做到的）。
开发者对自己或者他人负责的代码边界很模糊，这是复杂项目中最容易遇到的，导致的结果就是开发者很容易修改了他人负责的代码且代码负责人还不知道，责任追踪很麻烦。

将一个复杂项目拆分成多个模块是解决上述问题的一个重要方法。 拆分的好处

多模块的划分可以降低代码之间的耦合性（从类级别的耦合提升到jar包级别的耦合）
每个模块都可以是自解释的（通过模块名或者模块文档）
模块还规范了代码边界的划分，开发者很容易通过模块确定自己所负责的内容
…

自解释性就是要求程序代码、配置、脚本能够充分清晰的表明自己的业务意图、业务步骤、参数类型、参数值范围、约束、修改方法等信息。

对于程序代码，类和对象名字要反映出执行者（actor）在场景中角色，通常采用名词命名。方法名字要充分反映业务意图。通常可以采用动词或动词短语命名。如果参数过多，使用具有结构的对象封装参数，而不是将参数胡乱塞入Map<String,Object>传递。同时，方法要充分注释，写清楚参数和返回值的含义，可能抛出的异常和其他需要注意的地方。脚本也是一种程序源代码，因此可采用和程序代码同样的原则。

模块拆分策略

推荐按照功能拆分，后期方便转换成微服务架构

按职责划分

–module-test
- –module-test-service
- –module-test-po
- –module-test-controller
- –module-test-dao
- –module-test-common
- –module-test-util

按功能拆分

例如，在电商系统中如下module

–module-test
- –module-test-common公共部分
- –module-test-order订单
- –module-test-checkout购物车
- –module-test-pay支付
- –module-test-catory类目
- –module-test-product商品
- –module-test-price价格
- –module-test-account账号

搭建多模块项目

搭建多模块项目，需要使用 maven 的继承和聚合，其中聚合负责将多个模块集中在一起进行管理，继承则负责各子模块中的公共配置

创建项目

我使用的是idea

在这里插入图片描述

删掉src

pom文件内容

创建子模块

在项目下创建子模块
在这里插入图片描述
套路与创建普通项目一致

注意变化

module 的 pom 文件发生了变化

新增了两段配置

<packaging>pom</packaging>

<modules>
    <module>module-util</module>
</modules>

pom 是最简单的打包类型。不像jar和war，它生成的构件只有它本身。将 packaging 申明为 pom 则意味着没有代码需要测试或者编译，也没有资源需要处理。

由于我们使用了聚合，所以打包方式必须为pom，否则无法构建。

<modules>
    <module>module-util</module>
</modules>

module的值是子模块相对于当前 POM 的路径。

再看子模块中的 pom

在这里插入图片描述
也是分成两个部分

<parent>
    <groupId>com.wqlm</groupId>
    <artifactId>module</artifactId>
    <version>1.0-SNAPSHOT</version>
</parent>

<artifactId>module-util</artifactId>

<parent>
    <groupId>com.wqlm</groupId>
    <artifactId>module</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--<relativePath/>-->
</parent>

声明了该模块继承自 com.wqlm:module:1.0-SNAPSHOT，其实这里面还省略了
<relativePath></relativePath> 由于 relativePath 默认是 ../pom.xml 而我们的子项目确实在父项目的下一级目录中，所以是可以不用填写的

Maven首先在当前构建项目的环境中查找父pom，然后项目所在的文件系统查找，然后是本地存储库，最后是远程repo。

artifactId 是子模块的组件id，由于继承了父pom，所以groupId、version 也可以不写，不写的话就默认继承自父pom

使用多模块

如上所示，在创建多个模块之后，可以在父pom中添加公共配置，然后所有的子模块都会继承这些配置。除此之外，还可以统一对子模块进行编译、打包、安装… 操作

子模块间的依赖

如果子模块间相互依赖,需要在 dependency 中引入要依赖的子模块，如图
在这里插入图片描述
上图中子模块 module-common:1.0-SNAPSHOT 依赖了 module-util:1.0-SNAPSHOT。

子模块间的相互依赖，需要管理好依赖项的版本号，否则容易依赖版本冲突。

简单来说就是把公共依赖及版本号在父 pom 中申明，子项目引入依赖时只需要指定 groupId、artifactId 不需要指定版本号

如下，先在父 pom 中申明依赖及版本号
在这里插入图片描述
再在子项目中引入依赖项，注意，不需要指定版本号，默认查找父pom中定义的版本号

在这里插入图片描述

在软件开发中，把一个大项目分拆为多个模块是降低软件复杂度的有效方法：

在这里插入图片描述
对于Maven工程来说，原来是一个大项目：

在这里插入图片描述
现在可以分拆成3个模块：

在这里插入图片描述
Maven可以有效地管理多个模块，我们只需要把每个模块当作一个独立的Maven项目，它们有各自独立的pom.xml。例如，模块A的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.itranswarp.learnjava</groupId>
    <artifactId>module-a</artifactId>
    <version>1.0</version>
    <packaging>jar</packaging>

    <name>module-a</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
        <java.version>11</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.28</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>5.5.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

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

    <groupId>com.itranswarp.learnjava</groupId>
    <artifactId>module-b</artifactId>
    <version>1.0</version>
    <packaging>jar</packaging>

    <name>module-b</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
        <java.version>11</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.28</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>5.5.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

可以看出来，模块A和模块B的pom.xml高度相似，因此，我们可以提取出共同部分作为parent：

<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.itranswarp.learnjava</groupId>
    <artifactId>parent</artifactId>
    <version>1.0</version>
    <packaging>pom</packaging>

    <name>parent</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
        <java.version>11</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.28</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>5.5.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

注意到parent的<packaging>是pom而不是jar，因为parent本身不含任何Java代码。编写parent的pom.xml只是为了在各个模块中减少重复的配置。现在我们的整个工程结构如下：
在这里插入图片描述
这样模块A就可以简化为：

<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.itranswarp.learnjava</groupId>
        <artifactId>parent</artifactId>
        <version>1.0</version>
        <relativePath>../parent/pom.xml</relativePath>
    </parent>

    <artifactId>module-a</artifactId>
    <packaging>jar</packaging>
    <name>module-a</name>
</project>

模块B、模块C都可以直接从parent继承，大幅简化了pom.xml的编写。

如果模块A依赖模块B，则模块A需要模块B的jar包才能正常编译，我们需要在模块A中引入模块B：

    ...
    <dependencies>
        <dependency>
            <groupId>com.itranswarp.learnjava</groupId>
            <artifactId>module-b</artifactId>
            <version>1.0</version>
        </dependency>
    </dependencies>

最后，在编译的时候，需要在根目录创建一个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/maven-v4_0_0.xsd">

    <modelVersion>4.0.0</modelVersion>
    <groupId>com.itranswarp.learnjava</groupId>
    <artifactId>build</artifactId>
    <version>1.0</version>
    <packaging>pom</packaging>
    <name>build</name>

    <modules>
        <module>parent</module>
        <module>module-a</module>
        <module>module-b</module>
        <module>module-c</module>
    </modules>
</project>