So aktualisieren Sie die version der untergeordneten Modulen in Maven?

Frage 1)

Der beste Weg, um zu verwalten, application lifecycle und Veröffentlichungen ist die Verwendung des release-plugin.

Wie Sie vielleicht wissen, Maven-Philosophie ist die Konvention über die Konfiguration. Maven-Konvention ist die snapshot-Versionen (die mit der Endung-SNAPSHOT) während der Entwicklung und der Zuordnung einer nicht-snapshot-version nur für releases.

Sagen, Sie sind der Entwicklung von version 1.1.1. Während in der Entwicklung, die Sie gerade verwenden 1.1.1-SNAPSHOT. Maven wird sich darum kümmern-updates, die Momentaufnahme. Wenn ein Artefakt-repository, die Sie verwenden können, U um sicherzustellen, dass Sie immer die Letzte version des snapshots.

Wenn der release fertig ist, release-plugin generiert und setzt die version 1.1.1 und updates POM ist mit der neuen Entwickler-version, wie 1.1.2-SNAPSHOT.

Über multimodule Projekte, gibt es zwei Szenarien: die Module sind Verwandte, aber voneinander unabhängig (wie mehrere web-Anwendungen) oder Sie sind Module von einem einzigen großen Anwendung oder Bibliothek, und Sie teilen-Versionen. Sie scheinen daran interessiert, die letzteren.

Der beste Weg in diesem Fall ist nur die Erben die gleichen Eltern (vielleicht auch root) Modul, einschließlich der version. Sie verweisen übergeordnete Gruppe:Artefakt:version und Sie nicht angeben, eine version für die Kinder. Allgemein sind Sie auch Erben-Gruppe, so dass Ihr Kind pom Aussehen kann:

<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>

Nun müssen Sie nur, auf Kinder aufzupassen, verweist auf die richtige version des Elternteils, der mit Hilfe der release-plugin.

Ihm zu helfen, wissen über Kinder, sollten Sie Ihre parent-pom auch ein root-pom indem Sie den Abschnitt "Module", wie Sie später sehen werden.

Frage 2)
Ich in der Regel erklären Eigenschaften in der übergeordneten mit allen Versionen aller Artefakte, die referenziert werden können. Wenn mehrere Module teilen version, brauchen Sie nur eine Eigenschaft. Die Eltern können so Aussehen:

<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>

Kinder können Verweise auf andere Module mit

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

Es ist eine sehr schlechte Praxis zu erklären Abhängigkeiten mit NEUESTEN. Sagen Sie, dass Sie hierzu für die version 1.1.1. Jetzt arbeiten Sie mit version 1.1.2-SNAPSHOT und wahrscheinlich hast du auch Artefakte, die mit dieser version installiert in Ihrem lokalen repo.

Nun sagen, aus irgendeinem Grund müssen Sie neu erstellen version 1.1.1, zum Beispiel aufgrund eines Fehlers in der Produktion. Ihr build die neue version verwenden. Wenn Sie Glück haben, diese brechen das bauen. Wenn du Pech hast, kann es sogar unbemerkt in die Produktion.

Nicht zuletzt, wie einige Leute mithilfe von property-Werten zu erklären, die Kinder-Versionen. Dieser wird dringend abgeraten und wird berichtet, dass die Warnung von maven. Ich persönlich glaube nicht, jemals tun Sie es. Die Gründe sind auch in Bezug auf die Reproduzierbarkeit von builds und die Tatsache, dass maven geht davon aus, dass ein release-build wird sich nie ändern. Mit einer Modul-version extern tweakable ist nicht wirklich eine gute Idee.

EDIT:

Fall, wenn die Modul-Versionen sind nicht ausgerichtet.

Tatsächlich beide Szenarien gemischt werden kann.
Sie können, zum Beispiel:

Eltern

---Component1

---Component2

---Component3

------Comp3Module1

------Como3Module2

------Comp3Module3

Wo die Eltern und die drei-Komponenten-Versionen unterschiedlich sind und die drei Module des component3 teilen gleiche version wie vorher erklärt.

Frage 1)
In diesem Fall wird jedes Modul hat seine version infependently angegeben.
Wie gesagt, es ist eine schlechte prsctise zu verwenden, eine Eigenschaft, um anzugeben, Modul-version, der Grund, warum ich nur empfehlen kann buchstäblich angeben-Versionen.
Wie schon gesagt, zu verwalten, Versionierung, der beste Weg ist, um release-plugin, sowie die Integration mit dem Versionskontrollsystem wie SVN.
Andere Antworten geben, details, wie es zu benutzen, damit ich nicht aufwändig es weiter, es sei denn, angefordert.

Frage 2)
Die empfohlene Vorgehensweise ist die gleiche, erklärte der für den Fall der Freigabe die gleiche version, nur, dass Sie mehrere Eigenschaften.
Die Eltern können so Aussehen:

<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>

Dann können Sie mit dependency management zu zentralisieren version management in der Muttergesellschaft.

Beispielsweise in parent-pom,

<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>

Nun, verweisen Sie jedes Modul von jedem anderen Modul, und es ist so einfach:

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

Versionen werden automatisch geleitet von der Muttergesellschaft. Sie nicht brauchen, um Sie zu pflegen, in Kinder, die Abhängigkeiten, die sich auch weniger ausführlich.

Ok das ist, was ich kam mit. Diese basiert auf dieser continuous-Freigabe-von-maven-Artefakte Artikel.

Parent-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>

Beispiel Kind POM mit inter-Projekt-Abhängigkeit:

    <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>

1) Am Anfang des Zyklus wie kann ich die Eltern und die Module auf die gleiche version in einem maven-Befehl?

Müssen Sie sich nicht mehr. Das parent-POM bleibt die gleiche version, nur ändern, wenn die parent-POM verpasst. In diesem Fall können Sie mvn version:set -DnewVersion=1.1.1. Aber Sie brauchen nicht, um für diesen Ansatz.

Stattdessen kann man dynamisch festlegen, die version mit der Eigenschaft main.version. E. g. mvn clean deploy -Dmain.version=1.1.1 Auch, um zu erzwingen, dynamische übergabe der Versionsnummer, können Sie die Standard - main.version Eigenschaft, die ich in meiner parent-POM oben.

2) Wie aktualisiere ich die beiden mod1 version und mod2 Verweis auf mod1 version in einem Schritt?

Diese im Grunde läuft darauf hinaus, wie die Verwaltung Revisionen. Wenn ich nicht die revision Eigenschaft in der mvn-Kommando, dann werden alle Module verwenden SNAPSHOT als die revision. Wenn ich die revision Eigenschaft RC1 dann alle Module erhalten, die revision. Außerdem, wenn ich revision zu RC1 aber Module4.revision zu RC2 dann Module4 bekommt RC2 und alle anderen Module bekommen RC1. Dies erfüllt die Anforderung des Kunden ist, dynamische änderungen auf einer pro Modul basis.

Hier sind einige Beispiele:

• mvn clean deploy -Dmain.version=1.1.1 Setzt alle Module auf version 1.1.1-SNAPSHOT.
• mvn clean deploy -Dmain.version=1.1.1 -Drevision=RC1 Setzt alle Module auf version 1.1.1-RC1.
• mvn clean deploy -Dmain.version=1.1.1 -Drevision=RC1 -DModule4.revision=RC2 Setzt alle Module auf version 1.1.1-RC1 außer für Module4 die version 1.1.1-RC2.

Gibt es eine Einschränkung, die erwähnt werden muss. Wenn Sie erhöhen Sie die version einer abhängigen Modul, z.B. Modul1, zu RC2, dann müssen Sie auch erhöhen Sie die version aller Module, die es verwenden, zum Beispiel Module4 muss nicht erhöht werden, RC2 (oder die nächste version) auch. Dies ist etwas, das der client wurde bewusst gemacht, und es ist auch der Grund, warum ich lieber alle Module haben die gleiche version. Aber ich finde, wie dynamisch es raus kam. Im wesentlichen die version ist nun über die Kommandozeile mit keine updates zu POM-Dateien erforderlich.