I progetti di maven possono avere più genitori?

Question

Abbiamo progetti java e flex al lavoro. Al momento abbiamo 1 pom base che contiene le configurazioni che vogliamo utilizzare per entrambi i progetti. Il problema è che i progetti flex ereditano la configurazione per javadoc e pmd, ad esempio, che non vogliono.

Voglio farlo un po 'più pulito e avere un vero base-pom e poi un pom-java-base e un flex-base-pom. Ma come funziona in un multimodulo che ha sia una parte flex che una parte java?

Abbiamo plugin per la nostra applicazione in cui si usa la seguente struttura:

• mio-plugin
  • mio-plugin-client (flex)
  • mio-plugin-server (java)

Il mio-plugin solo contiene una pom.xml con la sezione. Vorrei usare il mio plugin pom.xml come genitore per entrambi, ma poi non posso nemmeno usare java base-pom o flex base-pom anche come genitore. Quale sarebbe il miglior approccio per questo?

Answer 1

Un progetto può avere un solo genitore (a differenza di ereditarietà multipla in C++), ma questo genitore può essere parte di una gerarchia padre più grande. Come sottolineato da altri, si potrebbe quindi avere qualcosa di simile:

 
base-pom/ 
|-- flex-base-pom 
| |-- my-plugin-client 
| | `-- pom.xml 
| `-- pom.xml 
|-- java-base-pom 
| |-- my-plugin-server 
| | `-- pom.xml 
| `-- pom.xml 
`-- pom.xml 

Detto questo, ho notato che hai scritto che il vero problema è che:

progetti Flex ereditano configurazione per javadoc e PMD per esempio, che non vogliono.

Si dovrebbe usare l'elemento pluginManagement per evitare questa situazione:

pluginManagement è un elemento che si vede lungo plugin laterali. La gestione dei plug-in contiene elementi di plug-in allo stesso modo, ad eccezione del fatto che piuttosto che configurare le informazioni sui plugin per questa particolare build di progetto, è inteso a configurare le build di progetto che ereditano da questa. Tuttavia, questo configura solo i plugin che sono effettivamente referenziati all'interno dell'elemento plugins nei bambini. I bambini hanno tutto il diritto di ignorare le definizioni di pluginManagement.

Così, nel pom genitore, configurare i plug-in pluginManagement (javadoc e PMD, per esempio), e fare riferimento all'interno dell'elemento plugins nei figli desiderati (solo nel mio-plugin-server di qui). Questo risolverebbe il tuo problema attuale.

Answer 2

Solo immagini che pom.xml sono in realtà classi Java: è possibile avere un solo genitore (o estendere una classe), ma questo genitore può anche avere un altro genitore, e così via.

Come ho spiegato here, è necessario distinguere i principi padre e di aggregazione in Maven, il che significa che il mio plug-in sarebbe considerato come un progetto di aggregazione, non necessariamente un progetto padre per sia my-plugin-client che my-plugin -genitore.

Quindi, per riassumere:

my-plugin definirà il pom di base per tutti i progetti. Quindi, si creano due nuovi progetti pom: java-base-pom e flex-base-pom. Hanno entrambi my-plugin come genitore. Ora, my-plugin-client avrà come java-base-pom come genitore, mentre il mio-plugin-server utilizzerà flex-base-pom per il suo genitore.

In questo modo, my-plugin-client erediterà tutte le proprietà definite nello my-plugin pom.xml e anche dal progetto java-base-pom.

Answer 3

L'unico modo è quello di avere base-pom come genitore di java-base-pom e flex-base-pom.

devo struttura simile per i miei progetti di primavera:

base-pom (basic configuration - eclipse, reports, repositories, etc) 
| 
+ spring-base-pom (spring definitions) 
    | 
    + spring-jar-base-pom (jar specific definitions) 
    | 
    + spring-war-base-pom (spring web and servlet dependencies) 
    | 
    + spring-webapp-base_pom (spring web mvc dependencies) 

Answer 4

ho attraversare questo proble esatto anche, e la soluzione migliore che ho trovato è stato quello di utilizzare l'ereditarietà e aggregazione, come suggeriscono in questa domanda: does maven support multiple parents (multiple inheritance) ?

Si può avere un pom aggregatore che non è il genitore di i progetti è aggregati.

e spiegare nel Maven Documentation

Ereditarietà e l'aggregazione di creare una bella dinamica per il controllo costruisce attraverso un unico, POM di alto livello (...) Al contrario, un progetto POM può aggregare i progetti che fanno non ereditare da esso.

Da questo ho avuto il mio POMs eredità (pom-master contiene configurazioni Comuni, e ogni bambino le specifiche quelle):

 
pom-master 
    |-- pom-java 
    |-- pom-flex 

e così il mio progetto può ottenere le specifiche per ogni configurazioni moduli a piacere :

 
project (aggregate project-flex & project-java) 
    |-- project-java 
    |  `-- pom.xml => parent = pom-java 
    |-- project-flex 
    |  `-- pom.xml ==> parent = pom-flex 
    `-- pom.xml => parent = pom-master 

auguro che possa aiutare gli altri così :)

Answer 5

è possibile ottenere più inhe ritance con profili:

I profili (multipli) creati nel root pom e l'attivazione automatica di qualsiasi variazione di questi profili consente di ottenere l'ereditarietà multipla della configurazione di Maven.

Answer 6

Anche se i progetti Maven hanno solo genitore, possono importare qualsiasi numero di altri pom di simile a questo:

<dependencyManagement> 
    <dependency> 
     <groupId>org.example</groupId> 
     <artifactId>my-shared-dependencies</artifactId> 
     <version>0.0.1-SNAPSHOT</version> 
     <type>pom</type> 
     <scope>import</scope> 
    </dependency> 
<dependencyManagement> 

Questo ha due importanti differenze rispetto a un genitore:

1. Plugin definiti nel pom importato non verrà importato
2. Le dipendenze definite nel pom importato non verranno aggiunte al pom attuale, verranno importate solo le dipendenze nella sezione di gestione delle dipendenze

Tuttavia, se il vostro pom genitore ha un < dipendenze> sezione e si desidera includere quelle nelle vostre dipendenze, allora è possibile aggiungere il genitore alla sezione dipendenze proprio come una dipendenza regolare:

<dependency> 
    <groupId>org.example</groupId> 
    <artifactId>my-shared-dependencies</artifactId> 
    <version>0.0.1-SNAPSHOT</version> 
</dependency> 

Anche se la stessa dipendenza è già stata importata, il tag della versione deve essere nuovamente specificato. Per ridurre la duplicazione, può essere memorizzato in una proprietà