Domanda 1)
Il modo migliore per gestire il ciclo di vita delle applicazioni e uscite è quello di utilizzare il plugin di rilascio.
Come forse saprai, la filosofia di Maven è convenzione sulla configurazione. La convenzione di Maven consiste nell'usare le versioni di istantanee (quelle che terminano con -SNAPSHOT) durante lo sviluppo e l'assegnazione di una versione non istantanea solo per le versioni.
Supponiamo che stiate sviluppando la versione 1.1.1. Durante lo sviluppo, basta usare 1.1.1-SNAPSHOT. Maven si prenderà cura degli aggiornamenti dell'istantanea. Se si utilizza un repository di risorse, è possibile utilizzare -U per assicurarsi di avere sempre l'ultima versione delle istantanee.
Quando la versione è pronta, il plugin di rilascio genera e distribuisce la versione 1.1.1 e aggiorna POM con la nuova versione di sviluppo, ad esempio 1.1.2-SNAPSHOT.
I progetti multimodule presentano due scenari: i moduli sono correlati ma indipendenti (come diverse applicazioni Web) oppure sono moduli di un'unica grande applicazione o libreria e condividono le versioni. Sembri interessato a quest'ultimo.
Il modo migliore in questo caso è di ereditare lo stesso modulo genitore (forse anche root), inclusa la sua versione. Si fa riferimento al gruppo genitore: artefatto: versione e non si specifica una versione per i bambini. In genere si eredita anche il gruppo, così il vostro pom bambino può guardare come:
<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>
Ora è solo bisogno di prendersi cura dei bambini che punta alla versione corretta del genitore, con l'aiuto del plugin rilascio.
Per aiutarlo a conoscere i bambini, è consigliabile creare un pom per le radici includendo la sezione dei moduli come mostrato di seguito.
Domanda 2) In genere dichiaro le proprietà nel genitore con tutte le versioni di tutti gli artefatti a cui è possibile fare riferimento. Se diversi moduli condividono la versione, hai solo bisogno di una proprietà. Il genitore può apparire come:
<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>
I bambini possono fare riferimento ad altri moduli usando
<version>${myproject.version}</version>
Si tratta di una cattiva pratica di dichiarare le dipendenze che utilizza l'ultimo. Diciamo di farlo per la versione 1.1.1. Ora stai lavorando con la versione 1.1.2-SNAPSHOT e probabilmente hai artefatti con questa versione installata nel repository locale.
Ora diciamo per qualche motivo che è necessario ricostruire la versione 1.1.1, ad esempio a causa di un bug nella produzione. La tua build utilizzerà la nuova versione. Se sei fortunato, questo romperà la build. Se sei sfortunato, potrebbe anche passare inosservato alla produzione.
Ultimo ma non meno importante, ad alcune persone piace usare i valori delle proprietà per dichiarare le versioni dei bambini. Questo è fortemente scoraggiato e verrà segnalato come un avvertimento da parte di Maven. Io personalmente non lo faccio mai. Le ragioni sono anche legate alla riproducibilità delle build e al fatto che Maven suppone che una build di rilascio non cambierà mai. Avere una versione del modulo esternamente modificabile non è davvero una buona idea.
EDIT:
caso in cui le versioni del modulo non sono allineati.
In realtà entrambi gli scenari possono essere combinati. Si possono avere, per esempio:
Parent
--- Component1
--- Component2
--- Componente3
------ Comp3Module1
------ Como3Module2
------ Comp3Module3
Dove le versioni padre e le tre componenti sono diverse ei tre moduli di component3 condividono la stessa versione di prima spiegata.
Domanda 1) In questo caso ogni modulo ha la sua versione specificata in modo indipendente. Come detto prima, è un cattivo consiglio usare una proprietà per specificare la versione del modulo, motivo per cui posso solo raccomandare di specificare letteralmente le versioni. Come già detto, per gestire il controllo delle versioni, il modo migliore è utilizzare il plugin di rilascio e integrarlo con il sistema di controllo della versione, come SVN. Altre risposte forniscono dettagli su come usarlo, quindi non lo elaborerò ulteriormente, se non richiesto.
Domanda 2) L'approccio consigliato è lo stesso spiegato per il caso di condivisione della stessa versione, solo che sono necessarie diverse proprietà. Il genitore può apparire come:
<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>
quindi è possibile utilizzare la gestione delle dipendenze per centralizzare la gestione delle versioni nel genitore.
Per esempio, nel pom genitore,
<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>
Ora, fare riferimento a qualsiasi modulo da qualsiasi altro modulo, è facile come:
<dependency>
<groupId>${myproject.group}</groupId>
<artifactId>component1</artifactId>
</dependency>
<dependency>
<groupId>${myproject.group}</groupId>
<artifactId>comp3module1</artifactId>
<type>ejb-client</type>
</dependency>
versioni sono gestite automaticamente dal genitore. Non è necessario mantenerli nelle dipendenze dei bambini, che diventano anche meno prolissi.
Suggerirei di cambiare la procedura e di eseguire nuovi RC di tutti i moduli anche se solo alcuni di essi cambiano. Sincronizza il ciclo di rilascio e lascia che "release: prepare" gestisca l'aggiornamento della versione per te. – rec
@rec Grazie per il consiglio. Questo era già sul tavolo come opzione. Qualche idea su come realizzare ciò che viene richiesto? –
Ho visto un '$ {mod1.versione} 'variabile impostata nel padre pom, poi chiamata nel poms figlio' $ {mod1.version} 'e per le dipendenze, sebbene dagli avvertimenti di Maven 3, sono sicuro che ci sono molte buone ragioni per non farlo. –
Rossiar