Maven erkennt Geschwistermodule nicht, wenn mvn dependency: tree ausgeführt wird

Ich versuche, ein Maven-Projekt mit mehreren Modulen einzurichten, und die Abhängigkeiten zwischen den Modulen werden anscheinend nicht richtig eingerichtet.

Ich habe:

<modules>
  <module>commons</module>
  <module>storage</module>
</modules>

in der übergeordneten POM (die eine Verpackung vom Typ POM hat) , und dann Unterverzeichnisse commons/und storage/welche definieren JAR poms mit dem gleichen Namen.

Die Speicherung hängt von Commons ab.

Im Hauptverzeichnis (Master) starte ich mvn dependency:treeund sehe:

[INFO] Building system
[INFO]    task-segment: [dependency:tree]
[INFO] ------------------------------------------------------------------------
[INFO] [dependency:tree {execution: default-cli}]
[INFO] domain:system:pom:1.0-SNAPSHOT
[INFO] \- junit:junit:jar:3.8.1:test
[INFO] ------------------------------------------------------------------------
[INFO] Building commons
[INFO]    task-segment: [dependency:tree]
[INFO] ------------------------------------------------------------------------
[INFO] [dependency:tree {execution: default-cli}]
...correct tree...
[INFO] ------------------------------------------------------------------------
[INFO] Building storage
[INFO]    task-segment: [dependency:tree]
[INFO] ------------------------------------------------------------------------
Downloading: http://my.repo/artifactory/repo/domain/commons/1.0-SNAPSHOT/commons-1.0-SNAPSHOT.jar
[INFO] Unable to find resource 'domain:commons:jar:1.0-SNAPSHOT' in repository my.repo (http://my.repo/artifactory/repo)
[INFO] ------------------------------------------------------------------------
[ERROR] BUILD ERROR
[INFO] ------------------------------------------------------------------------
[INFO] Failed to resolve artifact.

Missing:
----------
1) domain:commons:jar:1.0-SNAPSHOT

Warum schlägt die Abhängigkeit von "Commons" fehl, obwohl der Reaktor sie offensichtlich gesehen hat, weil er seinen Abhängigkeitsbaum erfolgreich verarbeitet? Es sollte definitiv nicht ins Netz gehen, um es zu finden, da es genau dort ist ...

Der Pom zur Aufbewahrung:

<?xml version="1.0" encoding="UTF-8"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>
  <packaging>jar</packaging>
  <parent>
    <artifactId>system</artifactId>
    <groupId>domain</groupId>
    <version>1.0-SNAPSHOT</version>
  </parent>
  <groupId>domain</groupId>
  <artifactId>storage</artifactId>
  <name>storage</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <!-- module dependencies -->
    <dependency>
      <groupId>domain</groupId>
      <artifactId>commons</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>

    <!-- other dependencies -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

Vielen Dank für alle Vorschläge!

(Bearbeiten)

Zur Verdeutlichung suche ich hier Folgendes: Ich möchte nicht Modul X installieren müssen, um Modul Y zu erstellen, das von X abhängt, da beide Module vom selben übergeordneten POM referenziert werden. Dies macht für mich intuitiv Sinn, dass ich keine Zwischenprodukte installieren muss, wenn ich zwei Dinge im selben Quellbaum habe, um den Build fortzusetzen. Hoffentlich macht mein Denken hier Sinn ...

Ich denke, das Problem ist, dass wenn Sie eine Abhängigkeit angeben, Maven erwartet, dass sie als JAR (oder was auch immer) verpackt und von mindestens einem lokalen Repo verfügbar ist. Ich bin sicher, dass mvn installalles funktionieren wird , wenn Sie zuerst Ihr Commons-Projekt ausführen .

Wie in diesem Maven-Mailinglisten-Thread erläutert , wird das Abhängigkeits-Baum-Ziel selbst eher im Repository als im Reaktor nachschlagen. Sie können dies umgehen, indem Sie wie zuvor vorgeschlagen mvn installieren oder etwas weniger belastendes tun, das den Reaktor aufruft, z

mvn compile dependency:tree

Funktioniert bei mir.

Die Erkenntnis, dass dies ein älterer Thread ist, aber es scheint, dass entweder das Tool weiterentwickelt wurde oder dass dies beim ersten Mal übersehen wurde.

Es ist möglich, einen Build durchzuführen, bei dem Abhängigkeiten ohne Installation aufgelöst werden, indem ein Reaktor-Build durchgeführt wird.

Wenn Sie Ihren Build im übergeordneten Element starten, das die Modulstruktur Ihres Projekts beschreibt, werden Ihre Abhängigkeiten zwischen Ihren Modulen während des Builds selbst über den internen Maven-Reaktor aufgelöst.

Dies ist natürlich nicht die perfekte Lösung, da dadurch nicht der Aufbau eines einzelnen Moduls innerhalb der Struktur gelöst wird. In diesem Fall hat Maven die Abhängigkeiten nicht in seinem Reaktor und wird versuchen, sie im Repository aufzulösen. Für einzelne Builds müssen Sie also zuerst die Abhängigkeiten installieren.

Hier ist eine Referenz , die diese Situation beschreibt.

Für mich war das, was mich zu diesem Thread führte, ein ähnliches Problem und die Lösung bestand darin, sicherzustellen, dass alle Modulabhängigkeiten poms hatten

 <packaging>pom</packaging>

der Elternteil hatte

pom

Mein Model Dep hatte Pom - also war kein Glas zu finden.

Das einzige, was für mich funktioniert hat: Wechsel zu Gradle :(

ich habe

Parent
  +---dep1
  +---war1 (using dep1)

und ich kann einfach in war1 cd und mvn tomcat7: run-war verwenden. Ich muss immer das gesamte Projekt installieren, obwohl war1 auf sein übergeordnetes Element verweist und das übergeordnete auf war1 und dep1 (als Module) verweist, sodass alle Abhängigkeiten bekannt sein sollten.

Ich verstehe nicht, wo das Problem liegt.

In einer Maven-Modulstruktur wie dieser:

- parent
  - child1
  - child2

Sie werden in parent pomdiesem haben:

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

Wenn Sie jetzt auf child1In angewiesen sind child2, geben Sie Folgendes in Ihr <dependencies>In ein child2:

<dependency>
  <groupId>example</groupId>
  <artifactId>child1</artifactId>
</dependency>

Sie erhalten eine Fehlermeldung, für die die JAR child1nicht gefunden werden kann. Dies kann durch die Deklaration einer gelöst werden <dependencyManagement>Block, der child1in dem pomfür parent:

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>example</groupId>
      <artifactId>child1</artifactId>
      <version>${project.version}</version>
    </dependency>
  </dependencies>
</dependencyManagement>

child1wird jetzt erstellt, wenn Sie ein compileoder packageusw. Ziel ausführen parent, und child2findet die child1kompilierten Dateien.

Bonus auf die Antwort von Don Willis :

Wenn Ihr Build Testgläser erstellt, um Testcode für Ihre Reaktorsubmodule freizugeben, sollten Sie Folgendes verwenden:

mvn test-compile dependency:tree

dependency:treeDies ermöglicht in diesem Fall die vollständige Ausführung.

Stellen Sie sicher, dass das fehlerhafte Modul im POM aufgelöst wird und auf das rechte übergeordnete Element zeigt, indem Sie die Konfigurationen in die POM-Datei des Moduls aufnehmen.