devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

maven---parent和dependencyManagement标签_dependencymanagement和parent

作者：你好赵伟 | 2024-05-30 02:20:56

赞

踩

dependencymanagement和parent

前沿

之前对maven的学习不系统，只是知道简单的使用方法，工作之后才对maven有了更深的学习。接下来小白会利用空闲时间，系统的学习一下maven，并且记录一下maven的学习心得，和大家分享一下。由于本人能力有限，写的博客难免会出现问题。希望大家也希望各位大佬指出问题，共同进步。

这里记录的maven使用时的parent和dependencyManagement标签的作用和dependencyManagement于dependency标签的区别。

这里通过两个场景进行说明：

场景一，有两个web项目W1、W2，一个java项目J1，依赖同一个jar包：domain.jar。如果分别在各自pom文件中引入domain.jar的依赖，那么当domain.jar的版本发生变化时，三个项目的pom文件都要改，项目中依赖越多修改越多。

此时就可以使用parent标签, 可以创建一个parent项目，打包类型为pom，parent项目中没有任何代码，只是管理多个项目之间公共的依赖。在parent项目的pom文件中定义对domain.jar的依赖，W1W2J1三个子项目中只需要定义<parent></parent>，parent标签中写上parent项目的pom坐标就可以引用到domain.jar了。

场景二，有一个springweb.jar，只有W1W2两个web项目需要，J1项目是java项目不需要，那么又要怎么去依赖？

可以在W1和W2中分别定义对springweb.jar的依赖，当springweb.jar版本变化时修改起来不方便。

解决办法是在parent项目的pom文件中使用<dependencyManagement>即公共的依赖写在parent的<dependency>中，不是全部需要的依赖写在dependencyManagement中，当版本修改之后只需要修改parent的dependencyManagement中的版本就可以了，子项目只需要引用就好了。（前提是子项目不写版本号，否则以子项目的版本为主）

1、parent标签

parent标签能够管理多个项目之间公共的依赖。通过字面意思我们很容易想到java中的继承，他和 java 中的继承相当，作用就是复用。例如场景一的例子。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  6.     <artifactId>xxxxxx</artifactId>
  7.     <packaging>pom</packaging>
  8.     <version>1.0.1-SNAPSHOT</version>
  9.     <description>xxxxxxx</description>
  10.  
  11.     <parent>
  12.         <groupId>xxxxxp</groupId>
  13.         <artifactId>ip-pomxxxx-parent</artifactId>
  14.         <version>2.0.6-RELEASE</version>
  15.     </parent>
  16.  
  17.     <name>y-core-parent</name>
  18.     <modules>
  19.         <module>e-contract-common</module>
  20.       
  21.     </modules>
  22.  
  23.     <properties>
  24.         <contract.pub.version>1.0.2-SNAPSHOT</contract.pub.version>
  25.     </properties>
  26. ......
  27.  
  28.     <dependencyManagement>
  29.         <dependencies>
  30.             <dependency>
  31.                 <groupId>com.x x x.iuap</groupId>
  32.                 <artifactId>x x x</artifactId>
  33.                 <version>${cont.pub.version}</version>
  34.             </dependency>
  35. <-- <properties>
  36.         <contract.pub.version>1.0.2-SNAPSHOT</contract.pub.version>
  37.     </properties>-->
  38.            
  39.     </dependencyManagement>
  40.  
  41.     <!--私服配置，用于发布-->
  42.     <distributionManagement>
  43.         <repository>
  44.             <id>ddds</id>
  45.             <name>Nexus Release Repository</name>
  46.             <url>http:maven仓库地址</url>
  47.         </repository>
  48.        
  49.     </distributionManagement>
  50.  
  51. </project>

这个是项目的配置文件

 <parent>
        <groupId>xxxxxp</groupId>
        <artifactId>iuap-pomxxxx-parent</artifactId>
        <version>2.0.6-RC1-RELEASE</version>
    </parent>

实现对依赖的版本统一控制，点进去我们会进入到该pom中，我们会发现该pom根据ucf-parent管理

  1.      <parent>
  2.         <groupId>com.xx.iuap</groupId>
  3.         <artifactId>ucf-parent</artifactId>
  4.         <version>2.0.1-RELEASE</version>
  5.     </parent>

再点进去会发现

  1.     <parent>
  2.         <groupId>org.springframework.boot</groupId>
  3.         <artifactId>spring-boot-starter-parent</artifactId>
  4.         <version>2.2.11.RELEASE</version>
  5.     </parent>
  6.  
  7.     <groupId>com.xx.iuap</groupId>
  8.     <artifactId>uc-parent</artifactId>
  9.     <version>2.0.1-RELEASE</version>
  10.     <name>uc-parent</name>
  11.     <packaging>pom</packaging>

 即，会继承springboot的依赖包，整个依赖关系如下

- 注释： 目前 父->子的依赖关系为

org.springframework.boot: spring-boot-starter-parent

-> com.xx.iuap: iuap-3rd-party（公司外开源的）

-> com.xx.iuap: iuap-2nd-party（公司内部的依赖库）

-> com.yonyou.iuap: yonyou-mdd-starter-parent  一方包（工程中各个模块之间的依赖）

二方包的管理

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  6.  
  7.     <parent>
  8.         <groupId>com.xx.up</groupId>
  9.         <artifactId>uc-parent</artifactId>
  10.         <version>2.0.1-RELEASE</version>
  11.     </parent>
  12.  
  13.     <groupId>com.xx.iuap</groupId>
  14.     <artifactId>iuap-pom-with-ucf-parent</artifactId>
  15.     <version>2.0.6-RC1-RELEASE</version>
  16.  
  17.     <name>iuap-pom-with-ucf-parent</name>
  18.     <packaging>pom</packaging>
  19.  
  20.     <properties>
  21.         <!-- ucf组件 -->
  22.         <uc.version>2.0.0-RELEASE</ucf.version>
  23.         <uc.file.version>2.0.0-RELEASE</ucf.file.version>
  24.         <uc.log.version>1.0.9-RELEASE</ucf.log.version>
  25.         <uc.ds.version>2.0.0-RELEASE</ucf.ds.version>
  26.         <!--  iuap组件  -->
  27.         <ap.version>5.0.4-RELEASE</iuap.version>
  28.         <irs.version>5.2.8-RELEASE</iris.version>
  29.         <mwclient.version>5.2.8-RELEASE</mwclient.version>
  30.         <eos-spring-support.version>5.2.8-RELEASE</eos-spring-support.version>
  31.         <auth.sdk.version>6.0.2-RELEASE</auth.sdk.version>
  32.         <auth.sdk.core.version>3.5.2-RELEASE</auth.sdk.core.version>
  33.         <open.isv.version>1.0.0-RELEASE</open.isv.version>
  34.        
  35.     </properties>
  36.  
  37.     <dependencyManagement>
  38.         <dependencies>
  39.             <dependency>
  40.                 <groupId>com.xx.iuap</groupId>
  41.                 <artifactId>iuap-pom</artifactId>
  42.                 <version>2.0.6-RC1-RELEASE</version>
  43.                 <type>pom</type>
  44.                 <scope>import</scope>
  45.             </dependency>
  46.         </dependencies>
  47.     </dependencyManagement>
  48.  
  49.     <distributionManagement>
  50.         <repository>
  51.             <id>iUAP</id>
  52.             <name>iUAP</name>
  53.             <url>http://maven.yonyou.com/nexus/content/repositories/iUAP/</url>
  54.         </repository>
  55.     </distributionManagement>
  56. </project>

三方包的管理

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  6.     <parent>
  7.         <groupId>org.springframework.boot</groupId>
  8.         <artifactId>spring-boot-starter-parent</artifactId>
  9.         <version>2.2.11.RELEASE</version>
  10.     </parent>
  11.     <groupId>com.yonyou.iuap</groupId>
  12.     <artifactId>ucf-parent</artifactId>
  13.     <version>2.0.1-RELEASE</version>
  14.     <name>ucf-parent</name>
  15.     <packaging>pom</packaging>
  16.  
  17.     <properties>
  18.         <HikariCP.version>3.3.1</HikariCP.version>
  19.         <activation.version>1.1.1</activation.version>
  20.         <activiti.version>5.22.0</activiti.version>
  21.         <activemq-spring.version>5.16.0</activemq-spring.version>
  22.         <alipay-sdk.version>4.10.70.ALL</alipay-sdk.version>
  23.         <amqp-client.version>5.4.3</amqp-client.version>
  24.         <antisamy.version>1.5.7</antisamy.version>
  25.         <apache-lucene.version>3.0.1</apache-lucene.version>
  26.         <junit-repeat-rule.version>3.0.1</junit-repeat-rule.version>
  27.      
  28.        ......
  29.     </properties>
  30.  
  31.     <dependencyManagement>
  32.         <dependencies>
  33.             <dependency>
  34.                 <groupId>cglib</groupId>
  35.                 <artifactId>cglib</artifactId>
  36.                 <version>${cglib.version}</version>
  37.             </dependency>
  38.             <dependency>
  39.                 <groupId>ch.qos.logback</groupId>
  40.                 <artifactId>logback-access</artifactId>
  41.                 <version>${logback.version}</version>
  42.             </dependency>
  43.            
  44.             <dependency>
  45.                 <groupId>com.github.cbismuth</groupId>
  46.                 <artifactId>junit-repeat-rule</artifactId>
  47.                 <version>${junit-repeat-rule.version}</version>
  48.             </dependency>
  49.             
  50.            
  51.             <dependency>
  52.                 <groupId>org.apache.lucene</groupId>
  53.                 <artifactId>lucene-analyzers-common</artifactId>
  54.                 <version>${apache-lucene.version}</version>
  55.             </dependency>
  56.             
  57.            ......
  58.  
  59.         </dependencies>
  60.     </dependencyManagement>
  61.  
  62.     <!-- 插件管理配置 -->
  63.     <build>
  64.         <plugins>
  65.             <!-- 定义JDK版本 -->
  66.             <plugin>
  67.                 <groupId>org.apache.maven.plugins</groupId>
  68.                 <artifactId>maven-compiler-plugin</artifactId>
  69.                 <configuration>
  70.                     <source>${java.version}</source>
  71.                     <target>${java.version}</target>
  72.                     <encoding>${project.build.sourceEncoding}</encoding>
  73.                     <showWarnings>true</showWarnings>
  74.                 </configuration>
  75.             </plugin>
  76.         </plugins>
  77.     </build>
  78.  
  79.     <distributionManagement>
  80.         <repository>
  81.             <id>iUAP</id>
  82.             <name>iUAP</name>
  83.             <url>http://maven.xxx.com/nexus/content/repositories/iUAP/</url>
  84.         </repository>
  85.     </distributionManagement>
  86. </project>

2、dependencyManagement

使用dependencyManagement可以统一管理项目的版本号，确保应用的各个项目的依赖和版本一致，不用每个模块项目都弄一个版本号，不利于管理，当需要变更版本号的时候只需要在父类容器里更新，不需要任何一个子项目的修改；

如果某个子项目需要另外一个特殊的版本号时，只需要在自己的模块dependencies中声明一个版本号即可。子类就会使用子类声明的版本号，不继承于父类版本号。如果不声明版本号的话，会使用父类的版本号。

3、dependencyManagement与dependencies区别：

（1)Dependencies相对于dependencyManagement，所有生命在dependencies里的依赖都会自动引入，并默认被所有的子项目继承。
（2)dependencyManagement里只是声明依赖，并不自动实现引入，因此子项目需要显示的声明需要用的依赖。

        1）如果不在子项目中声明依赖，是不会从父项目中继承下来的；

        2）只有在子项目中写了该依赖项，并且没有指定具体版本，才会从父项目中继承该项，并。                且version和scope都读取自父pom;

        3）另外如果子项目中指定了版本号，那么会使用子项目中指定的jar版本。

具体的使用区别可以查看之前的场景2

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/644895
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号