【Maven】 的继承机制

最新推荐文章于 2024-08-19 05:30:00 发布
最新推荐文章于 2024-08-19 05:30:00 发布
阅读量589 收藏 8
点赞数 4
分类专栏： Maven 文章标签： maven java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013675821/article/details/140685880
版权

Maven是一个强大的项目管理工具，主要用于Java项目的构建和管理。它以其项目对象模型（POM）为基础，允许开发者定义项目的依赖、构建过程和插件。Maven的继承机制是其核心特性之一，它允许子项目继承和复用父项目的配置，从而提高了代码重用性和管理的简洁性。

在本篇文章中，我们将详细讲解Maven的继承机制，包括继承的基本概念、继承的实现方式以及一些常见的应用场景。

一、Maven继承的基本概念

1.1 POM文件

在Maven中，项目对象模型（POM，Project Object Model）是项目的核心配置文件，位于项目根目录的pom.xml文件中。POM文件定义了项目的基本信息、依赖、插件、构建配置等。

一个典型的POM文件结构如下：

<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>my-project</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>
        <!-- 依赖声明 -->
    </dependencies>

    <build>
        <plugins>
            <!-- 插件声明 -->
        </plugins>
    </build>

</project>

1.2 继承的作用

Maven继承机制允许子项目从父项目继承POM配置。这意味着子项目可以复用父项目的依赖、插件、构建配置等，避免了重复定义。

继承的主要作用有：

  • 配置复用：子项目可以继承父项目的依赖、插件、构建配置等，从而减少重复配置。
  • 集中管理：可以在父项目中集中管理公共依赖和配置，方便版本的统一升级和维护。
  • 模块化开发：支持多模块项目的管理，每个子项目可以有自己的特定配置。

1.3 Maven继承的局限性

  • 单一继承：Maven不支持多继承，每个子项目只能有一个直接的父项目。
  • 继承与聚合的混淆：有时候开发者会将继承与聚合混淆，需要明确它们的区别。

二、Maven继承的实现

Maven继承通过父子关系实现。子项目通过指定父项目的groupId、artifactId和version来建立继承关系。

2.1 创建父项目

首先，我们需要创建一个父项目，定义公共的POM配置。

父项目POM (parent-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>

    <properties>
        <!-- 公共属性 -->
        <java.version>17</java.version>
        <spring.version>5.3.12</spring.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!-- 公共依赖 -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <!-- 公共插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.11.0</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

2.2 创建子项目

接下来，我们创建一个子项目，并让其继承父项目的POM配置。

子项目POM (child-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>child-project</artifactId>

    <dependencies>
        <!-- 子项目特有的依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
    </dependencies>

</project>

2.3 执行Maven命令

在根目录下执行mvn clean install，Maven会自动处理父子关系，并构建整个项目。

2.4 查看继承效果

当子项目继承父项目后，子项目的构建将使用父项目中定义的依赖和插件配置：

  • 子项目会自动使用父项目中的spring-context依赖。
  • 子项目会自动使用父项目中的maven-compiler-plugin插件，Java版本为17。

子项目的有效POM

我们可以通过Maven命令查看子项目的有效POM（Effective POM），它展示了继承后的最终配置。

执行以下命令：

mvn help:effective-pom

在终端输出中，可以看到子项目的完整POM配置，包括从父项目继承的部分。

三、Maven继承中的常用元素

3.1 dependencyManagement

  • 作用：用于在父项目中定义依赖的版本管理。
  • 特点：子项目继承时，不会自动引入依赖，而是只继承版本信息。

示例：

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
    </dependencies>
</dependencyManagement>

子项目使用时只需引用依赖，而不需要显式指定版本：

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <!-- 版本号已由父项目管理 -->
    </dependency>
</dependencies>

3.2 pluginManagement

  • 作用：用于在父项目中定义插件的版本管理。
  • 特点：子项目继承时，不会自动引入插件，而是只继承版本信息。

示例：

<build>
    <pluginManagement>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.11.0</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>
        </plugins>
    </pluginManagement>
</build>

子项目需要手动引入插件：

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
        </plugin>
    </plugins>
</build>

3.3 properties

  • 作用：用于在父项目中定义全局属性，子项目可以继承并使用这些属性。
  • 示例：
<properties>
    <java.version>17</java.version>
    <spring.version>5.3.12</spring.version>
</properties>

子项目使用属性：

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.11.0</version>
            <configuration>
                <source>${java.version}</source>
                <target>${java.version}</target>


            </configuration>
        </plugin>
    </plugins>
</build>

3.4 build与profiles

  • 作用：定义构建过程中的配置和多环境配置。
  • 示例：
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>3.0.0-M5</version>
        </plugin>
    </plugins>
</build>

<profiles>
    <profile>
        <id>development</id>
        <properties>
            <env>dev</env>
        </properties>
    </profile>
    <profile>
        <id>production</id>
        <properties>
            <env>prod</env>
        </properties>
    </profile>
</profiles>

子项目可以通过命令行参数激活特定配置：

mvn clean install -Pdevelopment

四、Maven继承与聚合的区别

Maven中的继承与聚合是两个不同的概念，容易混淆。

4.1 继承（Inheritance）

  • 特点：
    • 父子项目有继承关系。
    • 子项目继承父项目的POM配置。
  • 用途：
    • 适用于需要共享公共配置的项目。

4.2 聚合（Aggregation）

  • 特点：
    • 父项目是一个容器项目，没有实际业务逻辑。
    • 父项目通过modules元素管理多个子模块。
  • 用途：
    • 适用于多模块项目的管理。

4.3 继承与聚合同时使用

在实际项目中，继承和聚合可以同时使用，以实现更高效的项目管理。

示例：

<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>multi-module-project</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <modules>
        <module>module-a</module>
        <module>module-b</module>
    </modules>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.3.12</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

</project>

模块A的POM：

<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>multi-module-project</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>module-a</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
    </dependencies>

</project>

模块B的POM：

<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>multi-module-project</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>module-b</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
    </dependencies>

</project>

五、Maven继承的高级应用

5.1 多层继承

Maven支持多层继承，即子项目可以继续充当父项目，提供更深层次的继承结构。

parent-pom
  ├── intermediate-pom
  │     ├── child-a
  │     └── child-b
  └── child-c

中间层POM：

<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>intermediate-project</artifactId>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
                <version>3.12.0</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

</project>

子项目A的POM：

<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>intermediate-project</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>child-a</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
    </dependencies>

</project>

5.2 使用自定义的父POM

在某些情况下，我们可能需要自定义一个父POM，用于管理公司的多个项目。

  • 创建一个company-parent-pom，其中包含公司标准的依赖、插件和构建配置。
  • 每个项目都可以继承这个company-parent-pom，实现标准化的项目管理。

公司父POM：

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

    <properties>
        <java.version>17</java.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-core</artifactId>
                <version>2.17.1</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.11.0</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

项目POM：

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

    <artifactId>my-company-project</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
        </dependency>
    </dependencies>

</project>

5.3 使用parent.relativePath实现跨项目继承

在多模块项目中，子项目默认会在相对路径上寻找父项目。但在某些情况下，我们希望子项目引用远程仓库中的父POM，而不是本地的父POM。这时可以使用parent.relativePath属性。

<parent>
    <groupId>com.company</groupId>
    <artifactId>company-parent-pom</artifactId>
    <version>1.0</version>
    <relativePath/> <!-- 设置为空，强制从远程仓库获取 -->
</parent>

六、常见问题与解决方案

6.1 子项目不继承父项目的依赖版本

问题：子项目引用父项目的依赖时，需要手动指定版本号。

解决方案：确保依赖被定义在dependencyManagement中，而不是dependencies中。

6.2 多模块项目构建失败

问题：在多模块项目中，某个子模块构建失败导致整个项目构建失败。

解决方案：可以使用-pl参数单独构建某个模块：

mvn clean install -pl module-a

6.3 父子项目之间版本不兼容

问题：子项目与父项目使用的依赖版本不一致，导致冲突。

解决方案：可以在子项目中覆盖父项目的依赖版本：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.15</version> <!-- 覆盖版本 -->
</dependency>

七、总结

Maven的继承机制是项目管理中的一个重要特性，它通过父子关系实现配置复用、集中管理和模块化开发。在实际应用中，我们可以结合继承和聚合机制，实现更高效的项目管理。

关键点回顾

  • Maven的POM文件是项目配置的核心。
  • 子项目通过parent元素继承父项目的配置。
  • dependencyManagement和pluginManagement用于管理依赖和插件的版本。
  • 继承与聚合是Maven中两个不同的概念，但可以结合使用。
  • 通过多层继承和自定义父POM实现更复杂的项目管理。
Maven继承
weixin_50074193的博客
04-28 2274
Maven继承 一.继承的意义 在构建多个模块的项目时候，往往会多有模块有相同的groupId、version，或者有相同的依赖，为了减 少pom文件的配置、统一相同依赖的版本。可以将一个大型项目分为父工程和子工程,其中父工程的唯一 作用就是定义所有子模块工程的资源版本（父工程不编写代码，只编辑pom.xml文件） 二．继承的实现 创建父工程： 保证父工程的pom.xml文件中定义的打包packaging标签的类型是pom。 创建子工程 在子工程中使用 parent 标签,定义groupId artifa
maven继承与聚合代码
01-27
Maven的继承机制允许我们在多个项目之间共享公共的配置信息。这主要通过父POM（Parent POM）实现。当一个项目的POM声明了一个父POM时，它会继承父POM中的所有属性，如依赖、插件、构建配置等。这样，我们可以在父POM...
Maven
qq_51076441的博客
04-06 362
学了后面忘前面，刚好复习的时候就简单的记录一下吧。这一章节是Maven，我就挑了些我觉得要常用的，肯定还有很多不足之处，慢慢补充！简单的记录一下复习的过程来源：尚硅谷。
Maven继承：构建高效、可维护的Java项目
最新发布
xycxycooo的博客
08-19 1016
Maven继承是指在一个父项目（Parent Project）中定义公共的配置（如依赖、插件等），然后让子项目（Submodules）继承这些配置。通过继承，子项目可以复用父项目的配置，从而减少重复配置，提高项目的可维护性。Maven的继承功能极大地简化了多模块项目的管理和构建过程，使开发者能够更专注于业务逻辑的实现，而不必手动处理复杂的构建配置。通过合理利用继承功能，你可以构建出结构清晰、易于维护的项目。掌握Maven继承的原理和使用方法，将使你在面对复杂项目时更加从容不迫。
maven 继承
Mr_Wanter
02-02 1101
系统整理一下用到的maven继承关系。 dependencyManagement、pluginManagement dependencies、scope ……
Maven之继承
qq_45839663的博客
08-21 928
Maven之继承
maven依赖+继承+聚合
09-27
Maven的继承机制允许我们创建一个父`pom.xml`（称为超级POM），在其中定义共用的部分。子模块只需要继承这个父POM，就可以直接使用父POM的配置。例如： ```xml <groupId>com.example</groupId> <artifactId>...
maven 继承.docx
06-19
本文将深入探讨 Maven 项目的继承机制及其应用场景。 首先，Maven 项目继承的概念是：一个 Maven 项目（子项目）可以从另一个 Maven 项目（父项目）中继承属性和依赖。这种继承关系有助于减少重复配置，尤其是当多...
Maven聚合与继承实例详解.docx
06-19
Maven的继承机制则使得多个项目可以共享相同的配置，特别是共有的依赖和构建设置。当一个项目定义为父项目（Parent POM），其他项目声明为该父项目的子项目（Child POM），它们就能继承父项目中的配置。父POM通常...
maven(十)-继承
weixin_30731305的博客
02-25 110
 继承 如果项目划分了多个模块，都需要依赖相似的jar包，只需要创建一个父模块，在它的pom.xml文件中配置依赖jar包。功能模块只需要继承父模块，就可以自动得到其依赖jar包，而不需要在每个模块中都重复配置。 创建父模块 在eclipse中创建项目-maven project，这里勾选 create a simple.... 下一步 输入gro...
Maven聚合与继承的实例讲解（一）
dlhkuem0453的博客
08-15 172
概述 在javaweb高速发展的今天，我们软件设计人员往往会用很多种方式对软件划分模块，目的就是为了能有清晰的设计和低耦合性的，高重用性的软件。Maven有很好的依赖管理系统（Dependency Management System）和项目生命周期的管理（Project Leftcycle）,而其中的依赖管理是本文阐述和做出实例的重点。 实例背景 利用一个教程的...
Maven POM元素继承
weixin_30515513的博客
10-24 141
为了减少重复代码的编写，我们需要创建POM的父子结构，然后在POM中申明一些配置供子POM继承，以实现“一处申明，多处使用的”目的。以之前的模块中的结构为基础，在account-aggregator下创建一个account-parent的子目录，然后在该子目录下创建除account-aggregator模块之外的模块的父模块。为此在该子目录下创建一个pom.xml文件如下： ...
maven--继承
weixin_44239550的博客
01-07 366
其实这里就两块内容，一个是大家都可以用的坐标，一个是有些用不着的坐标。如果需要使用父的坐标，那子类得描述清楚父模块的位置，如果是定义可选择的坐标，那父模块必须的加一个标签。
Maven的继承
liaowenxiong的博客
01-19 260
文章目录什么是继承？如何实现继承？ 什么是继承？ 在聚合多个项目时，如果这些被聚合的项目中需要引入相同的Jar，那么可以将这些Jar写入父pom中，各个子项目继承该pom即可。 如何实现继承？ 父pom配置：将需要继承的Jar包的坐标放入标签即可。 <dependencyManagement> <dependencies> <dependency> <groupId>org.apache.shiro</groupI
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值