Java 如何在Maven中更新子模块的版本？

如何更新子模块的版本？有很多这样的Stackoverflow问题，但我找不到一个适合这个场景的问题。。。如果这是复制品，我会很高兴的

考虑以下项目

parent
  --mod1
  --mod2

在开发版本发布周期的开始，我需要将父级和模块更新到相同的版本。如果父级和模块的版本在整个发布过程中保持不变，那么我将从模块中省略

标记，并执行

versions:set-DnewVersion=1.1.1

，以启动开发周期。但事实证明，这些模块并非都以相同的版本结束周期。随着bug和修复的具体化，只有那个些有bug的模块才会得到更新。例如，父级和mod2可能在版本1.1.1-RC1，但mod1可能在版本1.1.1-RC2

因此，我需要：
1） 在模块中包括一个

标记，以独立跟踪每个模块版本

2） 如果mod2需要mod1作为依赖项，我需要确保mod2引用了mod1的最新版本

这导致了以下两个问题

1） 在循环开始时，如何在一个maven命令中将父模块和模块设置为相同的版本？我尝试了

version:set-DnewVersion=1.1.1

，但这只会更新所有POM中的父版本，而不会更新模块的版本。我还尝试了

-N版本：更新子模块

，但我认为我用错了，因为它不起任何作用，只显示所有模块的跳过

2） 这有点难，与上面的第2项相匹配。如何一步更新mod1的版本和mod2对mod1版本的引用？我知道如何分两步完成：

父pom：

<properties>
    <!-- update this manually if mod1's version no longer matches parent -->
    <mod1.version>${project.version}</mod1.version>
</properties>

${project.version}

mod2 pom：

    <dependency>
        <groupId>com.xxx</groupId>
        <artifactId>mod1</artifactId>
        <version>${mod1.version}</version>
    </dependency>

com.xxx
mod1
${mod1.version}

当mod1达到1.1.1-RC2时，我更新父POM和mod1 POM以反映这一点。这是两个步骤。无论如何，要把它变成一个步骤

我的例子很小，但在现实生活中，有许多模块可以使这个重要的时间节省，而且我很好奇。

1）我也尝试过这个版本：在过去设置，但从来没有让它正常工作。它应该执行与发布相同的过程：准备，但实际上没有。因此，您可以尝试的是

mvn发行版：prepare-DautoVersionSubmodules-DdryRun

。这应该是使所有的更新，而不检查任何东西到回购协议，也不做任何标记

2） 我相信ClearTK项目曾经遵循与您类似的策略：他们维护了一个多模块项目，每个模块都有自己的发布周期。为了控制这种情况，他们实现了一个定制的maven插件来警告他们依赖版本的不一致性

---

虽然这样的插件不会进行您请求的更新，但它至少应该在需要更新时通知您。要真正解决你的问题，你可能会考虑遵循与CuttKk一样的路线并实现你自己的Maven插件（或者你做了ClearTK最终做的事情：切换到同步释放周期）；

< P> OK，这就是我提出的。这是基于本文的

父POM：

<properties>
    <!-- versions of modules -->
    <main.version>1.0</main.version>
    <revision>SNAPSHOT</revision> <!-- default revision -->
    <Module1.revision>${revision}</Module1.revision>
    <Module2.revision>${revision}</Module2.revision>
    <Module3.revision>${revision}</Module3.revision>
    <Module4.revision>${revision}</Module4.revision>
    <Module5.revision>${revision}</Module5.revision>
    <Module1.version>${main.version}-${Module1.revision}</Module1.version>
    <Module2.version>${main.version}-${Module2.revision}</Module2.version>
    <Module3.version>${main.version}-${Module3.revision}</Module3.version>
    <Module4.version>${main.version}-${Module4.revision}</Module4.version>
    <Module5.version>${main.version}-${Module5.revision}</Module5.version>
</properties>

1
快照
${revision}
${revision}
${revision}
${revision}
${revision}
${main.version}-${Module1.revision}
${main.version}-${Module2.revision}
${main.version}-${Module3.revision}
${main.version}-${Module4.revision}
${main.version}-${Module5.revision}

具有项目间依赖关系的子POM示例：

    <groupId>com.xyz</groupId>
    <artifactId>Module4</artifactId>
    <packaging>jar</packaging>
    <version>${Module4.version}</version>

    <parent>
        <groupId>com.xyz</groupId>
        <artifactId>ParentProject</artifactId>
        <version>1.0</version>
    </parent>   

    <dependencies>
        <dependency>
            <groupId>com.xyz</groupId>
            <artifactId>Module1</artifactId>
            <version>${Module1.version}</version>
        </dependency>
        <dependency>
            <groupId>com.xyz</groupId>
            <artifactId>Module2</artifactId>
            <version>${Module2.version}</version>
        </dependency>
        <dependency>
            <groupId>com.xyz</groupId>
            <artifactId>Module3</artifactId>
            <version>${Module3.version}</version>
            <type>jar</type>
        </dependency>
    <dependencies>

com.xyz
模块4
罐子
${Module4.version}
com.xyz
父项目
1
com.xyz
模块1
${Module1.version}
com.xyz
模块2
${Module2.version}
com.xyz
模块3
${Module3.version}
罐子

1） 在循环开始时，如何在一个maven命令中将父模块和模块设置为相同的版本

你再也不需要了。父POM可以保持在同一版本，只有在父POM更改时才会更改。在这种情况下，您可以使用

mvn版本：set-DnewVersion=1.1.1

。但是你不必为这种方法而担心

相反，您可以使用属性

main.version

动态设置版本。例如，

mvn clean deploy-Dmain.version=1.1.1

此外，要强制动态传递版本号，您可以省略我在上面的父POM中包含的默认

main.version

属性

2） 如何一步更新mod1的版本和mod2对mod1版本的引用

这基本上归结为如何管理修订。如果我没有在mvn命令中设置

revision

属性，那么所有模块都将使用

SNAPSHOT

作为修订。如果我将

revision

属性设置为

RC1

，则所有模块都将获得该版本。此外，如果我将

revision

设置为

RC1

，但将

Module4.revision

设置为

RC2

，则Module4获得RC2，所有其他模块获得RC1。这满足了客户对每个模块进行动态修订的要求

以下是一些例子：

• mvn clean deploy-Dmain.version=1.1.1

  将所有模块设置为version

  1.1.1-SNAPSHOT

• mvn clean deploy-Dmain.version=1.1.1-Drevision=RC1

  将所有模块设置为version

  1.1.1-RC1

• mvn clean deploy-Dmain.version=1.1.1-Drevision=RC1-DModule4.revision=RC2

  将所有模块设置为版本

  1.1.1-RC1

  ，模块4设置为版本

  1.1.1-RC2

  $ mvn release:prepare -DautoVersionSubmodules=true
  $ mvn release:perform
  

  <dependency>
      <groupId>com.xxx</groupId>
      <artifactId>mod1</artifactId>
      <version>LATEST</version>
  </dependency>
  

  <parent>
     <groupId>com.mycompany.myproject</groupId>
     <artifactId>myproject-parent</artifactId>
     <version>1.1.1-SNAPSHOT</version>
     <relativePath>../myproject-parent</relativePath>
  </parent>
  <artifactId>myproject-module1</artifactId>
  

  <groupId>com.mycompany.myproject</groupId>
  <artifactId>myproject-parent</artifactId>
  <version>1.1.1-SNAPSHOT</version>
  <packaging>pom</packaging>
  <properties>
     <myproject.version>1.1.1-SNAPSHOT</myproject.version>
  </properties>
  
  .......
  
  <modules>
     <module>../myproject-module1</module>
     ...
  </modules>
  

  <version>${myproject.version}</version>
  

  <properties>
     <myproject.group>com.mycompany.myproject</myproject.group>
     <component1.version>1.1.1-RC1</component1.version>
     <component2.version>1.1.1-RC2</component2.version>
     <component3.version>2.0.0</component3.version>
  <properties>
  

  <dependencyManagement>
     <dependencies>
        <dependency>
           <groupId>${myproject.group}</groupId>
           <artifactId>component1</artifactId>
           <version>${component1.version}</version>
        </dependency>
        <dependency>
          <groupId>${myproject.group}</groupId>
           <artifactId>component2</artifactId>
           <version>${component2.version}</version>
           <type>war</type>
        </dependency>
        <dependency>
           <groupId>${myproject.group}</groupId>
           <artifactId>comp3module1</artifactId>
           <version>${component3.version}</version>
          <type>ejb</type>
        </dependency>
        <dependency>
           <groupId>${myproject.group}</groupId>
           <artifactId>comp3module1</artifactId>
           <version>${component3.version}</version>
          <type>ejb-client</type>
        </dependency>
        <dependency>
           <groupId>${myproject.group}</groupId>
           <artifactId>comp3module2</artifactId>
           <version>${component3.version}</version>
          <type>war</version>
        </dependency>
     </dependencies>
  </dependencyManagement>
  

  <dependency>
     <groupId>${myproject.group}</groupId>
     <artifactId>component1</artifactId>
  </dependency>
  <dependency>
     <groupId>${myproject.group}</groupId>
     <artifactId>comp3module1</artifactId>
     <type>ejb-client</type>
  </dependency>