Maven- 聚合与继承

最新推荐文章于 2024-10-06 20:16:20 发布
最新推荐文章于 2024-10-06 20:16:20 发布
阅读量183 收藏 1
点赞数
分类专栏： Maven 文章标签： java maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37890535/article/details/103566712
版权

  1. 聚合:
    实现一次构建多个项目, 而不是到两个模块的目录下分别执行 mvn 命令. 创建一个额外的模块, 然后通过该模块构件整个项目的所有模块.

    <?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>study.maven</groupId>
    <artifactId>maven-aggregator</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--这里和一般项目的不一样-->
    <packaging>pom</packaging>
    <name>Aggregator</name>
    <modules>
        <!--这里是需要一次构建的模块-->
        <module>study-email</module>
        <module>study-persist</module>
    </modules>
</project>

    通常将聚合模块放在项目目录的最顶层, 其它模块则作为聚合模块的子目录存在.

  2. 继承:
    父 pom 的 packaging 也为 pom. 父模块本身不包含除 pom 之外的项目文件, 也就不需要 src/main/java/

    <!--父 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>study.maven</groupId>
    <artifactId>maven-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--这里和一般项目的不一样-->
    <packaging>pom</packaging>
    <name>Parent</name>
</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>
    <!--这里引用 pom-->
    <parent>
        <groupId>study.maven</groupId>
        <artifactId>maven-parent</artifactId>
        <version>1.0-SNAPSHOT</version>
        <!--这个路径配置比较重要-->
        <relativePath>../maven-parent/pom.xml</relativePath>
    </parent>
    <!--这里不用为子 pom 声明 groupId 和 version, 它们从父 pom 中继承-->
    <artifactId>study-email</artifactId>
    <name>email</name>
</project>

    正确设置 relativePath 非常重要. 对于一个包含父子模块关系的 Maven 项目, 由于只想构建单独的一个模块. 如果此时父模块没有被安装到本地仓库, 并且子模块的 relativePath 没有被正确设置. 此时 Maven 将无法找到父 pom 导致构建失败. 如果 Maven 能够根据 relativePath 找到父 pom, 它就不要再去检查本地仓库.

     可以继承的 pom 元素:
     * groupId: 项目组 ID
     * version: 项目版本
     * description: 项目的描述信息
     * organization: 项目的组织信息
     * inceptionYear: 项目的创始年份
     * url: 项目的 URL 地址
     * developers: 项目的开发者信息
     * contributors: 项目的贡献者信息
     * distributionManagement: 项目的不熟配置
     * issueManagement: 项目的缺项跟踪系统信息
     * ciManagement: 项目的持续继承系统信息
     * scm: 项目的版本控制系统信息
     * mailingLists: 项目的邮件列表信息
     * properties: 自定义的 Maven 信息
     * dependencies: 项目的依赖配置
     * dependencyManagement: 项目的依赖管理配置
     * repositories: 项目的仓库配置
     * build: 项目的源码目录配置, 输出目录配置, 插件配置, 插件管理配置
     * reporting: 项目的报告输出目录配置, 报告插件配置

  3. 依赖管理:
    Maven 提供的 dependencyManagement 元素既能让子模块继承到父模块的依赖配置, 又能保证子模块依赖使用的灵活性. 在 dependencyManagement 元素下的依赖声明不回引入实际的依赖, 不过它能够约束 dependencies 下的依赖使用.

    <!--父 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>study.maven</groupId>
    <artifactId>maven-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--这里和一般项目的不一样-->
    <packaging>pom</packaging>
    <name>Parent</name>
    <properties>
        <springframework.version>2.5.6</springframework.version>
        <junit.version>4.7</junit.version>
    </properties>
    <!--这里使用 dependencyManagement 声明的依赖既不会给 maven-parent 引入依赖, 也不会给它的子模块引入依赖, 不过这段配置是会被继承的-->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>${springframework.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
                <version>${springframework.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${springframework.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
                <version>${springframework.version}</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</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>
    <!--这里引用 pom-->
    <parent>
        <groupId>study.maven</groupId>
        <artifactId>maven-parent</artifactId>
        <version>1.0-SNAPSHOT</version>
        <!--这个路径配置比较重要-->
        <relativePath>../maven-parent/pom.xml</relativePath>
    </parent>
    <!--这里不用为子 pom 声明 groupId 和 version, 它们从父 pom 中继承-->
    <artifactId>study-email</artifactId>
    <name>email</name>
    <properties>
        <javax.mail.version>1.4.1</javax.mail.version>
        <greenmail.version>1.3.1.b</greenmail.version>
    </properties>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <dependency>
            <groupId>javax.mail</groupId>
            <artifactId>mail</artifactId>
            <version>${javax.mail.version}</version>
        </dependency>
        <dependency>
            <groupId>com.icegreen</groupId>
            <atifactId>greenmail</artifactId>
            <version>${greenmail.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project> 

<!--若某个模块需要使用和另一个模块完全一样的 dependencyManagement 配置-->
<dependencyManagement>
    <dependencies>
        <groupId>study.maven</groupId>
        <artifactId>maven-parent</artifactId>
        <version>1/0-SNAPSHOT</version>
        <type>pom</type>
        <!--注意这里-->
        <scope>import</scope>
    </dependencies>
</dependencyManagement>

  4. 插件管理:

        <!--父 pom-->
    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-source-plugin</artifactId>
                    <version>2.1.1</version>
                    <executions>
                        <execution>
                            <id>attach-source</id>
                            <phase>verify</phase>
                            <goals>
                                <goal>jar-no-fork</goal>
                            </goals>
                        <execution>
                    </executions>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
    
    <!--子 pom-->
    <build>
        <plugins>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-source-plugin</artifactId>
        </plugins>
    </build>

  5. 聚合与继承的关系:
    对于聚合模块来说, 它知道哪些被聚合的模块, 但哪些被聚合的模块不知道这个聚合模块的存在; 对于继承关系的父 pom 来说, 它不知道有哪些子模块继承于它, 但那些子模块都必须知道自己的父 pom 是什么.

  6. 反应堆:

    • 构建顺序: Maven 按序读取 pom, 如果该 pom 没有依赖模块, 那么就构建该模块, 否则就先构建其依赖模块. 如果该依赖还依赖于其它模块, 则进一步先构建依赖的依赖.
    • 裁剪:
      • -am: 同时构建所列模块的依赖模块. 例如: mvn clean install -pl study-mail -am. 由于study-mail 依赖于 maven-parent, 所以 maven-parent 也会被构建.
      • -amd: 同时构建依赖于所列模块的模块. 例如: mvn clean install -pl maven-parent -amd. 由于 study-mail 和 study-persisit 都依赖于 maven-parent, 所以这两个模块都会被构建.
      • pl: 构建制定的模块, 模块剑用逗号分隔开. 例如: mvn clean install -pl study-mail,study-persist
      • -rf: 从完整的构建顺序中, 指定从哪个模块开始构建, 该模块及其以后的模块都会按照顺序被构建. 例如: mvn clean install -rf study-email, 则 study-email, study-persist 模块都会被构建.

  7. 参考:
    [1] : Maven 实战

javadaysdaysup
关注
专栏目录
Maven---继承与聚合
PeterLee3333的博客
06-02 168
继承与聚合 （4）注意 1、每个maven工程都有对应的打包方式，默认为jar,web工程打包方式为war 2、聚合工程中所包含的模块在进行构建时会根据模块间的依赖关系设置构建顺序，与聚合工程中模块的配置书写位置无关参与聚合的工程无法向上感知是否参与聚合，只能向下配置哪些模块参与本工程的聚合 二、继承 （1）概念︰继承描述的是两个工程间的关系，与java中的继承相似，子工程可以继承父工程中的配置信息，常见于依赖关系的继承 （2）作用 简化配置
apache-maven-3.9.2.zip配置好的阿里云仓库文件
05-26
10. Maven聚合与继承：Maven支持项目间的聚合和继承，聚合允许将多个项目组合在一起作为一个整体进行构建，而继承则允许共享部分POM配置，减少重复代码。 总的来说，这个预配置好的“apache-maven-3.9.2.zip”文件...
maven-聚合与继承
weixin_30715523的博客
08-26 76
1、聚合-方便快速构建项目 　　多个maven模块要构建需要分别执行一次maven构建命令，怎样只执行一次构建命令就构建多个maven模块呢？maven提供了聚合模块可以满足一次运行，构建多模块的要求 2、继承-消除重复配置，统一管理 　　多个maven模块中的pxm.xml有很多相同的配置，如果简化配置？maven提供了继承机制，抽出重复的配置，统一依赖管理和插件管理 maven工程隐...
Maven（3）--聚合与继承
demon7552003的小本本
07-06 323
目录 聚合 重点： 继承 注意： 聚合与继承的关系区别 ： 共同点 ： Maven可继承的POM 元素 依赖管理 import依赖范围 插件管理 约定由于配置 反应堆 反应堆的构建顺序 裁剪反应堆 聚合 假设项目【用户注册服务】包含模块：account-email和 account-persist。我们需要进行全部构建，而不是在每个模块目录下都执行mvn命令进...
Maven高级-----继承与聚合
m0_59281987的博客
04-28 921
在maven中，可以在父工程的pom文件中通过来统一管理依赖版本。父工程：--统一管理依赖版本-->--JWT令牌-->子工程：--JWT令牌-->注意：在父工程中所配置的只能统一管理依赖版本，并不会将这个依赖直接引入进来。这点和是不同的。子工程要使用这个依赖，还是需要引入的，只是此时就无需指定版本号了，父工程统一管理。变更依赖版本，只需在父工程中统一变更。将多个模块组织成一个整体，同时进行项目的构建。
Maven高级-聚合-继承
qq_40432598的博客
01-06 523
Maven高级-聚合-继承
Maven之聚合与继承
weixin_35794878的博客
01-24 8702
关于maven的聚合、依赖相关内容的讲解
Maven聚合与继承
Mr_Susy的博客
09-02 1254
当我们一次想要构建多个项目时应该怎么做？当我们多个模块下存在很多相同的配置时如何进行版本控制？
Maven进阶-继承与聚合
Cey_Tao的博客
08-28 835
这时要说一说继承时说到的 relativePath 属性，前面说 relativePath 属性可以省略，前提是父模块已经构建并 install 至仓库，否则子模块无法构建，但此时父模块同时也聚合了子模块，要构建父模块就又要一起构建子模块，但构建子模块又需要父模块 install 至仓库……父模块的打包方式必须设置为 pom（默认打包方式是 jar）继承关系中，分为父模块与子模块，父模块也被称为 parent 模块，子模块会继承父模块的依赖，父模块中也可以设置依赖管理器，供子模块选择是否需要某些依赖。...
Maven高级-聚合和继承
Eumenides_Suki的博客
04-06 1437
两种之间的作用: * 聚合用于快速构建项目，对项目进行管理 * 继承用于快速配置和管理子项目中所使用jar包的版本 聚合和继承的相同点: * 聚合与继承的pom.xml文件打包方式均为pom，可以将两种关系制作到同一个pom文件中 * 聚合与继承均属于设计型模块，并无实际的模块内容 聚合和继承的不同点: * 聚合是在当前模块中配置关系，聚合可以感知到参与聚合的模块有哪些 * 继承是在子模块中配置关系，父模块无法感知哪些子模块继承了自己
apache-maven-3.6.1-bin
07-20
8. **聚合（Aggregation）与继承（Inheritance）**：通过聚合，一个项目可以包含多个子项目，而继承则允许子项目共享父项目中的配置，如依赖。 9. ** profiles**：Maven的profile功能允许根据不同的环境或条件选择...
version-maven-plugin：简单易用的maven继承聚合项目的版本号变更插件
02-04
用于对Maven聚合继承项目的版本号进行便捷变更的工具 在使用RPC框架的微服务架构中，为了让服务消费者实现像调用本地方法一样的透明的通过网络进行RPC，服务提供者一般会提供立面jar用于服务消费者集成并通过动态...
apache-maven-3.5.0
11-06
5. **聚合与继承**：聚合允许将多个项目组合成一个父项目，方便统一管理。继承则允许子项目共享父项目的配置，减少重复代码。 6. **POM的继承与覆盖**：子POM可以继承父POM的配置，并根据需要覆盖部分属性或添加...
apache-maven-3.6.1 安装包
02-11
9. **聚合与继承**：Maven的聚合（aggregation）功能允许将多个项目聚合为一个超级项目，而继承（inheritance）则让子项目共享父项目的部分配置，提高了代码的可复用性和一致性。 10. **版本管理**：Maven的版本...
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 879
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 283
JDK1.0主要特性。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 625
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
Spring依赖注入和注解驱动详解和案例示范
J老熊
10-01 1000
在 Spring 框架中，依赖注入（Dependency Injection, DI）和注解驱动（Annotation-Driven）是其核心机制，它们为 Spring 应用提供了灵活性和可扩展性。依赖注入简化了对象间的依赖管理，而注解驱动则通过简洁的注解配置取代了繁琐的 XML 配置。本文将详细分析这两个机制，并通过示例加深理解。
Maven聚合与继承：多模块项目管理
“Maven聚合和继承.pdf”是一个技术文档，主要讲解了如何使用Maven的聚合和继承特性来管理多模块开发项目。文档通过一个具体的案例——用户注册功能的`account-persist`模块来阐述这些概念。 在进行多模块开发时，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值