Maven: aggiunta di un riferimento a un progetto padre pom

Question

Non sono sicuro di capire come utilizzare correttamente un progetto padre pom. Ho il seguente pom genitore definito:

<modelVersion>4.0.0</modelVersion> 
<groupId>com.example</groupId> 
<artifactId>parent</artifactId> 
<version>0.0.1-SNAPSHOT</version> 
<packaging>pom</packaging> 

<modules> 
    <module>../child1</module> 
    <module>../child2</module> 
</modules> 

E poi i bambini pom riferimento al genitore (ogni bambino ha il proprio insieme di dipendenze che non sono mostrati):

<parent> 
    <groupId>com.example</groupId> 
    <artifactId>parent</artifactId> 
    <version>0.0.1-SNAPSHOT</version> 
    <relativePath>../Parent/pom.xml</relativePath> 
</parent> 

<modelVersion>4.0.0</modelVersion> 
<artifactId>child1</artifactId> 

Questa messa a punto funziona bene e si risolve correttamente in eclissi (m2eclipse). Posso schierare questi per il mio repository locale e finire con la seguente struttura, che dovrebbe essere corretto:

--com 
    --example 
     --parent 
     --0.0.1-SNAPSHOT 
      --parent-0.0.1-SNAPSHOT.pom 
     --child1 
     --0.0.1-SNAPSHOT 
      --child1-0.0.1-SNAPSHOT.jar 
      --child1-0.0.1-SNAPSHOT.pom 
     --child2 
     --0.0.1-SNAPSHOT 
      --child2-0.0.1-SNAPSHOT.jar 
      --child2-0.0.1-SNAPSHOT.pom 

Il mio problema è che io ora voglio fare riferimento al progetto genitore in un diverso progetto di (non genitore, figlio1 o figlio2) e quindi coinvolgere tutti i figli del genitore. Posso aggiungere un riferimento ad esso nel mio altro progetto:

<dependencies> 
    <dependency> 
     <groupId>com.example</groupId> 
     <artifactId>parent</artifactId> 
     <version>0.0.1-SNAPSHOT</version> 
     <type>pom</type> 
    </dependency> 
</dependencies> 

Nel fare questo il progetto non mostra errori in Eclipse, ma senza artefatti vengono aggiunti al mio percorso di classe: non child1, child2, o una qualsiasi delle loro dipendenze.

Continuo a pensare che ci deve essere un modo per avere un progetto pom "master" che non è un barattolo in sé ma ha solo riferimenti ad altri barattoli e quindi essere in grado di fare riferimento a quel "master" da qualche parte, ma non posso scoprire come questo è realizzato.

Answer 1

Prova a creare un super pom con lo stesso tipo di confezione e aggiungi il tuo genitore corrente come dipendenza.

Answer 2

La prima cosa che suggerirei di cambiare la struttura dei progetti.

--com 
    --example 
     --parent 
     --0.0.1-SNAPSHOT 
      --parent-0.0.1-SNAPSHOT.pom 
     --child1 
     --0.0.1-SNAPSHOT 
      --child1-0.0.1-SNAPSHOT.jar 
      --child1-0.0.1-SNAPSHOT.pom 
     --child2 
     --0.0.1-SNAPSHOT 
      --child2-0.0.1-SNAPSHOT.jar 
      --child2-0.0.1-SNAPSHOT.pom 

vorrei suggerire di andare seguente modo:

--parent (pom.xml) 
     +--child1 
     +--child2 

Il genitore può essere controllato in in un controllo di versione (Git, SVN) sia nel master o nel bagagliaio. A parte che tutti Childs devono fare riferimento al genitore come questo:

<modelVersion>4.0.0</modelVersion> 

<parent> 
    <groupId>com.example</groupId> 
    <artifactId>parent</artifactId> 
    <version>0.0.1-SNAPSHOT</version> 
</parent> 

<artifactId>child1</artifactId> 

e nel vostro genitore si può usare cose come questa:

<groupId>com.example</groupId> 
<artifactId>parent</artifactId> 
<version>0.0.1-SNAPSHOT</version> 
<packaging>pom</packaging> 

<modules> 
    <module>child1</module> 
    <module>child2</module> 
</modules> 

Inoltre è possibile utilizzare una pom società semplicemente con l'aggiunta di un genitore di riferimento al genitore del progetto:

<parent> 
    <groupId>com.example</groupId> 
    <artifactId>master-pom</artifactId> 
    <version>0.0.1</version> 
</parent> 

<groupId>com.example</groupId> 
<artifactId>parent</artifactId> 
<version>0.0.1-SNAPSHOT</version> 
<packaging>pom</packaging> 

<modules> 
    <module>child1</module> 
    <module>child2</module> 
</modules> 

In compagnia POM si può (e dovrebbe) versioni del plugin pin diverso e definire le impostazioni predefinite aziendali e suggerimenti per le dipendenze con le loro versioni appropriate.

Se ti piace avere un super-pom aziendale, puoi creare un progetto maven separato che contiene solo il file pom che contiene le tue configurazioni come plug-in, dipendenze, ecc. E, naturalmente, controllalo in un controllo di versione (Git, SVN ecc.). separatamente dall'altro progetto.

Se si desidera fare riferimento a un file jar che significa in altre parole un artefatto della build multi-modulo, è necessario utilizzare il groupId corretto, l'idtifact e la versione.Se si desidera utilizzare child1 in un altro progetto è necessario fornire le seguenti:

<dependencies> 
    <dependency> 
     <groupId>com.example</groupId> 
     <artifactId>child1</artifactId> 
     <version>0.0.1-SNAPSHOT</version> 
    </dependency> 
</dependencies> 

E 'importante capire che il genitore di una costruzione a più modulo non è un un artefatto che viene solitamente utilizzato, causa basa su il tipo di imballaggio pom non crea realmente un artefatto (file jar).

Aggiornamento: Si può fare in modo limitato solo per l'area dependencyManagement con l'scope import ma questo è destinato solo per l'uso in depdencyManagement e non per le dipendenze. Un'altra soluzione potrebbe essere quella di creare un progetto fittizio separato che abbia le dipendenze anche due childs come deps transitivi. Ma questa non è davvero bellezza.

Quindi la soluzione è semplicemente aggiungere direttamente due o più dipendenze che si stanno utilizzando nel progetto e il gioco è fatto.

Answer 3

Come sottolineato da @khmarbaise, il genitore di una build multi-modulo non viene solitamente utilizzato come dipendenza altrove.

Dovresti essere in grado di aggiungere ciascuno dei tuoi moduli figlio come dipendenze e ottenere ciò che volevi fare aggiungendo il pom principale.