maven dependencyManagement的作用

最新推荐文章于 2025-04-11 09:30:00 发布
最新推荐文章于 2025-04-11 09:30:00 发布
阅读量426 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Maven 文章标签： Maven dependencyManagement
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/abinge317/article/details/103062473

从Maven的继承开始说起：

假设有两个子模块sub-1和sub-2，其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>cn.codecrazy.demo</groupId>
  <artifactId>demo-sub1</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.3.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.3.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.2.31</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

<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>cn.codecrazy.demo</groupId>
  <artifactId>demo-sub2</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.3.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.3.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

可以看到sub1和sub2中都引入了junit、spring-context和spring-beans依赖。并且sub1中还另外引入了fastjson依赖。我们可以利用maven的继承机制，将这些依赖放到parent父模块中，并在子模块中引入节点。

在sub1和sub2的上层目录中新增一个parent模块，其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>cn.codecrazy.demo</groupId>
  <artifactId>demo-parent</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>pom</packaging>

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.3.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.3.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.2.31</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

注意节点为pom方式，之后的sub1和sub2的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>cn.codecrazy.demo</groupId>
    <artifactId>demo-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <relativePath>../pom.xml</relativePath>
  </parent>

  <artifactId>demo-sub1</artifactId>

</project>

 <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>cn.codecrazy.demo</groupId>
    <artifactId>demo-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <relativePath>../pom.xml</relativePath>
  </parent>

  <artifactId>demo-sub2</artifactId>

</project>

可以看到sub1和sub2模块的pom文件配置大大简化了，由于配置了parent节点，子模块的依赖从父模块得到了继承，即使在子模块中不配置节点，子模块也引入了它的依赖。

但是上述配置存在一个问题，sub2中并不需要fastjson依赖，但由于继承，也同样从父模块中继承了fastjson依赖。换句话说，以后继承自该parent模块的其他子模块也许并不需要parent模块中声明的所有依赖，但是就目前这种配置方式，父模块中的这些依赖都会被无条件的继承，这显然是不合理的，这就需要用到节点。

节点中配置的依赖并不会真正的引入依赖，但是该节点却能够被子模块继承，要在子模块中真正引入依赖，需要将依赖配置在节点下，而这种方式配置的依赖可以省略节点，使用的即是在节点中配置的相应。采用了节点的父模块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>cn.codecrazy.demo</groupId>
  <artifactId>demo-parent</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>pom</packaging>
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.3.4.RELEASE</version>
      </dependency>
      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>4.3.4.RELEASE</version>
      </dependency>
      <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.31</version>
      </dependency>
      <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>3.8.1</version>
        <scope>test</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
</project>

sub1和sub2模块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>cn.codecrazy.demo</groupId>
    <artifactId>demo-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <relativePath>../pom.xml</relativePath>
  </parent>

  <artifactId>demo-sub1</artifactId>

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
    </dependency>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

<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>cn.codecrazy.demo</groupId>
    <artifactId>demo-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <relativePath>../pom.xml</relativePath>
  </parent>

  <artifactId>demo-sub2</artifactId>

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

可以看到在sub2的pom文件中没有引入fastjson依赖，这样sub2就不会真正的引入fastjson依赖。

节点的另一个好处是，使得多个子模块中引入的相同依赖版本号能够保持一致。

如何引入另外的dependencyManagement？

假设在某个模块demo-other中也有节点管理着一批依赖，现在想在demo-parent模块中将那些依赖管理全部导入，把demo-other模块中的依赖全部复制到demo-parent模块的节点下是可行但是非常不优雅的做法。

比较优雅的做法是用到import依赖范围，即import。demo-parent的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>cn.codecrazy.demo</groupId>
  <artifactId>demo-parent</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>pom</packaging>
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>cn.codecrazy.demo</groupId>
        <artifactId>demo-other</artifactId>
        <version>1.0-SNAPSHOT</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.3.4.RELEASE</version>
      </dependency>
      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>4.3.4.RELEASE</version>
      </dependency>
      <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.31</version>
      </dependency>
      <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>3.8.1</version>
        <scope>test</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
</project>

注意多出来的部分：

<dependency>
    <groupId>cn.codecrazy.demo</groupId>
    <artifactId>demo-other</artifactId>
    <version>1.0-SNAPSHOT</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>
Maven中pom.xml dependencyManagement作用
06-16 417
dependencyManagement 最大的好处就是极大的统一了项目的各个依赖的版本，如果没有 dependencyManagement ，以后版本升级，我们就需要到各个子模块中挨个做修改，但现在我们只需要修改最顶层项目 pom.xml 文件中的 dependencyManagement 中的版本即可，就可以通过 Maven 以来的传递性作用到整个项目中，方便了项目依赖的管理。通常会在各个子项目的 pom.xml 文件中都会用到，是 dependency 标签的上一级；
【maven】maven dependencyManagement 锁定Jar包版本
九师兄
12-19 478
1.概述 视频地址：maven dependencyManagement 锁定Jar包版本
Apache Maven Dependency Management
03-17
Book Description Manage your Java and JEE project dependencies with ease with this hands-on guide to Maven Overview Improve your productivity by efficiently managing dependencies. Learn how to detect and fix dependency conflicts Learn how to share transitive relations and to visualize your dependencies In Detail Managing dependencies in a multi-module project is difficult. In a multi-module project, libraries need to share transitive relations with each other. Maven eliminates this need by reading the project files of dependencies to figure out their inter-relations and other related information. Gaining an understanding of project dependencies will allow you to fully utilize Maven and use it to your advantage. Aiming to give you a clear understanding of Maven’s functionality, this book focuses on specific case studies that shed light on highly useful Maven features which are often disregarded. The content of this book will help you to replace homebrew processes with more automated solutions. This practical guide focuses on the variety of problems and issues which occur during the conception and development phase, with the aim of making dependency management as effortless and painless as possible. Throughout the course of this book, you will learn how to migrate from non-Maven projects to Maven, learn Maven best practices, and how to simplify the management of multiple projects. The book emphasizes the importance of projects as well as identifying and fixing potential conflicts before they become issues. The later sections of the book introduce you to the methods that you can use to increase your team’s productivity. This book is the perfect guide to help make you into a proud software craftsman. What you will learn from this book Learn how to use profiles, POM, parent POM, and modules Increase build-speed and decrease archive size Set, rationalize, and exclude transitive dependencies Optimize your POM and its dependencies Migrate projects to Maven including projects with exotic dependencies Approach An easy-to-follow, tutorial-based guide with chapters progressing from basic to advanced dependency management. Who this book is written for If you are working with Java or Java EE projects and you want to take advantage of Maven dependency management, then this book is ideal for you. This book is also particularly useful if you are a developer or an architect. You should be well versed with Maven and its basic functionalities if you wish to get the most out of this book. Table of Contents Chapter 1: Basic Dependency Management Chapter 2: Dependency Mechanism and Scopes Chapter 3: Dependency Designation (advanced) Chapter 4: Migration of Dependencies to Apache Maven Chapter 5: Tools within Your IDE Chapter 6: Release and Distribute Appendix: Useful Public Repositories Book Details Title: Apache Maven Dependency Management Author: Jonathan Lalou Length: 158 pages Edition: 1 Language: English Publisher: Packt Publishing Publication Date: 2013-10-25 ISBN-10: 1783283017 ISBN-13: 9781783283019
maven dependencyManagement作用
xhangs的博客
06-20 816
在中可以定义依赖的范围，例如：
Maven 依赖管理 dependencyManagement
最新发布
小李同学的博客
04-11 1668
值作用适用场景compile默认作用域，依赖在编译、测试、运行时都可用。业务核心依赖（如provided由运行环境提供（如 JDK API），编译时需要但运行时不需要。Servlet API、JDBC 驱动。runtime运行时依赖（如数据库驱动），编译时不需，但运行时需要。。test仅用于测试代码，编译主代码时不可见。system需要手动指定路径的依赖（需配合本地特殊依赖（如未发布到仓库的 JAR）。
Maven中的dependencyManagement 作用
qq_41394352的博客
07-16 285
当在idea项目中模块很多时。为了项目的正确运行，必须让所有的子项目使用依赖项的统一版本，必须确保应用的各个项目的依赖项和版本一致，才能保证测试的和发布的是相同的结果。 在我们项目顶层的POM文件中，我们会看到dependencyManagement元素。通过它元素来管理jar包的版本，让子项目中引用一个依赖而不用显示的列出版本号。Maven会沿着父子层次向上走，直到找到一个拥有dependencyManagement元素的项目，然后它就会使用在这个dependencyManagement元素中指定的版本号
Maven 中 Maven-dependencyManagement作用
一个还在上学的程序缘
11-18 154
这篇讲的很nice ：传送门 其实就是版本控制，父类声明版本（但不会引用），子类直接引用，而且子类可以声明自己的版本。
Maven中dependencyManagement作用
抽象的螺旋
06-30 316
Maven中dependencyManagement作用
Maven DependencyManagement：掌控依赖的终极利器
xycxycooo的博客
08-16 1911
Maven的是一种机制，允许你在父POM（Project Object Model）中定义依赖的版本和配置，而不实际引入这些依赖。子项目可以选择性地继承这些依赖，并使用父POM中定义的版本和配置。通过这种方式，你可以统一管理项目中所有模块的依赖版本，避免版本冲突和不一致。Maven的功能极大地简化了多模块项目的依赖管理，使开发者能够更专注于业务逻辑的实现，而不必手动处理复杂的依赖配置。通过合理利用，你可以构建出结构清晰、易于维护的项目。掌握Maven的原理和使用方法，将使你在面对复杂项目时更加从容不迫。
Maven的dependencyManagement与dependencies区别
Apollo
04-18 594
先说结论：Maven 使用dependencyManagement 元素来提供了一种管理依赖版本号的方式。
【Maven】dependencyManagement和dependencies
HR的博客
08-06 2115
代码】【Maven】dependencyManagement和dependencies。
maven中 depedencyManagement的作用
健康平安的活着的专栏
11-12 1364
在maven的聚合工程中，父模块的pom文件中，使用dependencymanagement来管理依赖版本号。目的是让所。，确保应用的各个项目的依赖和版本一致，不用每个模块项目都弄一个版本号，不利于管理。
Maven| Maven中dependencyManagement作用说明
YvesHe的专栏
08-21 359
在Maven多模块的时候，管理依赖关系是非常重要的，各种依赖包冲突，查询问题起来非常复杂，于是就用到了， 示例说明， 在父模块中： mysql mysql-connector-java 5.1.44 </depende...
Maven中dependencyManagement标签作用
个人学习博客，不足之处，还望不吝赐教！
10-28 454
使用 dependencyManagement 可以统一声明依赖版本，进行集中管理，避免依赖冲突。
Maven中的DependencyManagement和Dependencies
程序媛的一生
05-06 657
这里介绍一个在父项目中的根结点中声明dependencyManagement和dependencies的区别 dependencyManagement Maven 使用dependencyManagement 元素来提供了一种管理依赖版本号的方式。通常会在一个组织或者项目的最顶层的父POM 中看到dependencyManagement 元素。使用pom.xml 中的depende
Maven中dependencyManagement标签的作用
sinat_34241861的博客
08-03 5701
一、作用 使用dependencyManagement可以统一管理项目中依赖包的版本号，当需要变更版本号时只需在父pom中修改即可；如果某个子项目需要指定一个特殊的版本号时，只需要在自己项目的pom.xml中显示声明一个版本号即可，此时子项目会使用自己声明的版本号，而不继承父项目的版本号 二、dependencyManagement与dependencies的区别 dependencies相对于dependencyManagement，所有声明在dependencies里的依赖都会自动引入，并默认被所有的
＜dependencyManagement＞的作用
m0_63040701的博客
10-09 5064
dependencyManagement是一个 Maven 项目中的元素，它的作用是集中管理项目的依赖版本。
Maven：＜dependencyManagement＞：依赖集中管理
宋冠巡的博客
04-16 5065
在Apache Maven构建工具中，`` 是一个非常重要的元素，用于在一个项目或一组项目的顶级POM（Project Object Model，即项目对象模型）中集中管理和控制所有子模块或子项目所使用的依赖项（dependencies）的版本和其他元数据。其核心作用在于实现依赖版本的一致性和简化依赖管理。
思-关于maven的dependencyManagement
心中有湖
04-10 278
layout title slug date status author categories tags post 思-关于maven的dependencyManagement dependencyManagement-maven 2020-03-06 12:10 publish 乐心湖 ...
maven dependencyManagement
12-30
### Maven 中 dependencyManagement 的用法和配置 #### 使用场景 当项目模块众多时，使用 Maven 管理项目变得尤为便捷。这不仅有助于管理构建、文档、报告、依赖关系等方面的工作，还能确保所有子项目使用的依赖项及其版本保持一致，从而保障测试环境与生产环境中的一致性[^1]。 #### 配置方式 在顶层 POM 文件中定义 `dependencyManagement` 元素用于集中管理和声明依赖的版本号。这种方式允许开发者在一个地方设定好所需 jar 包的具体版本信息，使得各子项目只需简单引用这些依赖而不必重复指定其版本号。具体来说： - **父级 POM**: 定义全局性的依赖管理规则。 ```xml <project> ... <dependencyManagement> <dependencies> <!-- 示例：Junit --> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</scope> </dependency> <!-- 更多依赖... --> </dependencies> </dependencyManagement> ... </project> ``` - **子级 POMs**: 继承自父级并利用已定义好的依赖设置 子项目的 pom.xml 可以像下面这样简洁地引入所需的依赖，无需再次指明版本号： ```xml <project> ... <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <!-- 版本由父POM中的dependencyManagement控制 --> </dependency> <!-- 添加其他本地特有的依赖 --> </dependencies> ... </project> ``` 这种机制有效减少了跨多个子模块间可能出现的版本不匹配问题，并简化了整个项目的维护工作量[^3]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值