# Maven Parent- Child POMs



## PollerJava (24. Nov 2014)

Hallo,

ich hätte eine Frage zu einem Maven Reactor Projekt .
Ich hab eine parent- POM und Child- POMs.
In den Child- POMs hab ich natürlich die Referenz auf die Parent POM.
Wenn ich jetzt ein neues Release mache, hab ich bis jetzt in der Parent- POM eine neue Version eingetragen und in den child- POMs musste ich dann natürlich auch die Version der parent- POM nachziehen.
Meine Frage wäre jetzt, ob es da eine bessere Möglichkeit gibt, damit ich nicht immer die Child- Versionen ändern muss.

Vielen Dank!!


Parent- Eintrag in den Childs:

```
<parent>
		<groupId>groupId</groupId>
		<artifactId>artifactId</artifactId>
		<version>1.0.0</version>
		<relativePath>../a/b/c.pom</relativePath>
	</parent>
```


----------



## BuckRogers (24. Nov 2014)

```
<version>${project.parent.version}</version>
```


----------



## PollerJava (25. Nov 2014)

Leider bekomm ich folgende Fehlermeldung, ich hab schon gesucht danach, aber ich kanns ehrlich gesagt nicht lösen, ich habe in meiner parent- POM auch die Child- Module angegeben usw.
Vielleicht hat noch mal jemand eine Idee, was ich machen kann um das zu lösen.
Besten Dank,


Project build error: Non-resolvable parent POM: Failure to transfer  from http://
 repo.maven.apache.org/maven2 was cached in the local repository, resolution will not be reattempted until the update interval of central has elapsed or updates are forced. Original error: 
 Could not transfer artifact ...om:${project.parent.version} from/to central (404 Not Found 
 Illegal character in path at index 99: ... and 'parent.relativePath' points at wrong local POM


----------



## BuckRogers (25. Nov 2014)

Poste doch mal bitte deine Projektstruktur und die Abhängigkeiten in den POM-files. Aber benutze bitte das Code Template.


----------



## PollerJava (25. Nov 2014)

main- Projekt (with maven dependencyManagement)

```
<modelVersion>4.0.0</modelVersion>
	<groupId>groupId</groupId>
	<artifactId>artifactId</artifactId>
	<packaging>pom</packaging>
	<name>name</name>

        <!-- erbt von parent master POM -->
	<parent>
		<groupId>parentMasterGroupId</groupId>
		<artifactId>parentMasterArtifactId</artifactId>
		<version>1.1.1</version>
		<relativePath>../parentmasterpath/pom.xml</relativePath>
	</parent>

<!-- here modules are defined -->
```

child- POM

```
<parent>
		<groupId>mainGroupId</groupId>
  		<artifactId>mainArtifactId</artifactId>
  		<version>1.1.1</version>
		<relativePath>../mainPOM/pom.xml</relativePath>
  </parent>
```

Ich hab also eine master- POM, eine main- POM leitet von der Master- POM ab (hier sind auch die Module definiert) und dann gibt es eben noch die child POMs.


----------



## BuckRogers (25. Nov 2014)

Wieso brauchst du Main und Master POM?
Eigentlich reicht eine Main-POM und die Child-POMs.

Ich denke mir jetzt mal das Master-POM die oberste ist, welche applikationsweit gilt. Dann sind die Main-POMs die der Module und die Child-POMs in den Modulen für jeweiliges Packaging, DependencyMgmt etc.

Master:

```
<groupId>masterName</groupId>
    <artifactId>masterName</artifactId>
    <version>1.0-SNAPSHOT</version>

<modules>
        <module>mainName1</module>
        <module>mainName2</module>
    </modules>
```
Main

```
<parent>
        <groupId>masterName</groupId>
        <artifactId>masterName</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>mainName</artifactId>
    <packaging>pom</packaging>

    <modules>
        <module>childName-war</module>
    </modules>
```
Child

```
<parent>
        <relativePath>../../mainName</relativePath>
        <groupId>masterName</groupId>
        <artifactId>childName</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <groupId>masterName</groupId>
    <artifactId>childName-war</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>
```

so sieht es bei mir aus und es funktioniert. Du solltest vielleicht in der Child-Pom groupId auf dein Master-POM verweisen?

Jedoch sagt deine Fehlermeldung aus, dass der relative Pfad nicht stimmt.


----------



## PollerJava (26. Nov 2014)

So wie du oben beschrieben hast, funktionierts bei mir auch (master ist die unternehmensweite POM, main ist die Projekt- POM). Bei mir funktioniert aber das nicht:
Child-POM:

```
<parent>
        <relativePath>../../mainName</relativePath>
        <groupId>masterName</groupId>
        <artifactId>childName</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <groupId>masterName</groupId>
    <artifactId>childName-war</artifactId>
    <version>${project.parent.version}</version>
    <packaging>war</packaging>
```


----------



## BuckRogers (26. Nov 2014)

Hast du die groupId des child-poms auf den masterNamen geändert? Hast du den relativen Pfad im child-pom geändert, bzw probiert ob ein Verweis zu einem höherenpom funktioniert?


----------



## BuckRogers (28. Nov 2014)

Da du dich mit Maven beschäftigst würde ich gern auf meine Problemstellung verweisen. Eventuell kannst du mir ja helfen?

http://www.java-forum.org/deployment/164123-alte-dependencies-deployt.html


----------



## kama (28. Nov 2014)

Die erste Frage ist, ob Du einen multi module Build hast? 

Nach Deiner Beschreibung hört sich das so an...

Also mal die Struktur wie es sein sollte: (das dann hier liegt wird dann in den trunk bei SVN oder in den master bei git eingecheckt):


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

Dabei sollten die Childs jeweils auf den Parent verweisen (aber OHNE relativePath)...relativePath etc. wie Du angedeutet hast macht keinen Sinn....


```
<groupId>com.group.x</groupId>
    <artifactId>project-parent</artifactId>
    <version>1.0-SNAPSHOT</version>

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

Dann das jeweilige Child:

```
<parent>
      <groupId>com.group.x</groupId>
      <artifactId>project-parent</artifactId>
      <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>childName-war</artifactId>
    <packaging>war</packaging>
```

In der Regel brauch man kein weitere Angabe für groupId da diese vom Parent übernommen wird. Das gilt auch für die Version. Die GroupId anpassen macht man nur bei großen Projekten....

Um nun die Version auf einen neue/andere Version zu setzen für eine Release kann man das in Unterschiedlichen Formen machen.

1. Manuelle Variante

Man nimmer das versions-maven-plugin wie folgt:

```
mvn versions:set -DnewVersion=NEUE_VERSION
```
Zum Beispiel:

```
mvn versions:set -DnewVersion=2.0.0
```
Dann werden alle Versionen in den Parents als auch bei Module Abhängigkeiten entsprechend angepasst. Dann einchecken. Dann einen Tag Setzen und 
	
	
	
	





```
mvn deploy
```

2. Automatische Variaten

Man nimmt das maven-release-plugin:


```
mvn release:prepare release:perform
```

Dazu ist aber notwendig, dass der SCM Eintrag in der Parent POM gepflegt ist...

MfG
Karl Heinz Marbaise


----------



## PollerJava (29. Nov 2014)

Hallo kama, 

vielen Dank für die ausführliche Antwort. Das heißt aber auch, dass ich auch in der child poms im parent tag einen versionseintrag habe und diese Versionen dann mittels.


```
mvn versions:set -DnewVersion=2.0.0
```

gesetzt werden. ${project.parent.version} kann ich da auf keinen Fall in den child- POMs verwenden. 
Kann man das so sagen?

Vielen Dank.
Poller


----------



## kama (29. Nov 2014)

Hi,

in den Child POM ist das nicht notwendig...und macht wenn man genau darüber nachdenkt auch keinen sinn...


```
<parent>
      <groupId>com.group.x</groupId>
      <artifactId>project-parent</artifactId>
      <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>childName-war</artifactId>
    <packaging>war</packaging>
    <description>...</description>
```

Wo soll ich bei obigem denn ${project.parent.version} nutzen ? Da die Version ja vererbt wird führt sich das sozusagen selbst ad absurdum...

Weiterhin wird die Nutzung von Platzhaltern im Version-Tag nicht unterstützt und führt auch zu einer entsprechenden Meldung (Abbruch).

Mit Maven 3.2.1 kannst Du mehrere Platzhalter verwenden und zwar überall anstatt z.B. 1.0-SNAPSHOT hart Kodiert...z.B so etwas wie 
	
	
	
	





```
1.0-${revision}
```
 anstelle von version:


```
<parent>
      <groupId>com.group.x</groupId>
      <artifactId>project-parent</artifactId>
      <version>1.0-${revision}</version>
    </parent>

    <artifactId>childName-war</artifactId>
    <packaging>war</packaging>
    <description>...</description>
```
verwendent und dann in der Kommandozeile muss aber folgendes:

```
mvn -Drevision=SNAPSHOT clean package
```
angeben werden.

Oder man kann dann die Information aus dem Versionskontrollsystem nehmen (Git SHA1 oder by SVN die Revision nummer).

Gruß
Karl Heinz Marbaise


----------



## PollerJava (30. Nov 2014)

>> Wo soll ich bei obigem denn ${project.parent.version} nutzen ? Da die Version ja vererbt wird führt sich das sozusagen selbst ad absurdum...

Dann würde es aber auf jeden Fall sinn machen, wenn eine POM von einer Parent- POM "ableitet", dass man den Versions Tag weglassen könnte - das geht aber leider nicht, würde aber aus meiner Sicht sinn machen.

lg


----------



## kama (30. Nov 2014)

Das Problem mit dem Weglassen der Version ist folgendes.

Wenn die Version da ist kann Maven feststellen, dass es aus dem aktuellen Reaktor stammte und nutzen...

Wenn ich jetzt die Version weglassen welche Version soll dann genommen werden? Ok. Man könnte annehmen, dass man einfach den Parent (sprich eine Verzeichnisebene höher) nimmt wenn einer da ist...

Da fällt man dann aber bei Aggregatoren auf die Nase...abgesehen davon gibt es durchaus fälle wo das dann eine andere Version sein muss...die dann aus dem Repository gezogen werden soll..bei Company POM's führt das dann wieder zu Problemen...

Die ideale Lösung ist das nicht...aber in Maven 4.X gibt es vielleicht eine bessere Lösung...

Gruß
Karl Heinz Marbaise


----------

