Maven no reconoce los módulos hermanos al ejecutar la dependencia de mvn: árbol

Estoy tratando de configurar un proyecto Maven de varios módulos, y las dependencias entre módulos aparentemente no se están configurando correctamente.

Yo tengo:

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

en el POM padre (que tiene un pom de tipo empaquetado) y luego en los subdirectorios commons/y storage/que definen los poms JAR con el mismo nombre.

El almacenamiento depende de Commons.

En el directorio principal (maestro), ejecuto mvn dependency:treey veo:

[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

¿Por qué falla la dependencia de los "comunes", a pesar de que el reactor obviamente lo ha visto porque procesa con éxito su árbol de dependencia? Definitivamente no debería ir a la red para encontrarlo, ya que está allí ...

El pom para almacenamiento:

<?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>

¡Gracias por cualquier sugerencia!

(Editar)

Para aclarar, lo que estoy buscando aquí es esto: no quiero tener que instalar el módulo X para construir el módulo Y que depende de X, dado que ambos son módulos referenciados desde el mismo POM principal. Esto tiene sentido intuitivo para mí que si tengo dos cosas en el mismo árbol de fuentes, no debería tener que instalar productos intermedios para continuar con la compilación. Ojalá mi pensamiento tenga algún sentido aquí ...

Creo que el problema es que cuando especificas una dependencia, Maven espera tenerla empaquetada como jar (o lo que sea) y disponible en al menos un repositorio local. Estoy seguro de que si ejecuta mvn installprimero su proyecto de bienes comunes, todo funcionará.

Como se discutió en este hilo de la lista de correo de Maven , el objetivo de dependencia: árbol por sí solo buscará cosas en el repositorio en lugar de en el reactor. Puede solucionar esto instalando mvn, como se sugirió anteriormente, o haciendo algo menos oneroso que invoca el reactor, como

mvn compile dependency:tree

Funciona para mi.

Darse cuenta de que este es un hilo más antiguo, pero parece que la herramienta evolucionó o esto podría haberse perdido la primera vez.

Es posible realizar una compilación que resuelva las dependencias sin instalar mediante una compilación de reactor.

Si comienza su compilación en el padre que describe la estructura del módulo de su proyecto, sus dependencias entre sus módulos se resolverán durante la compilación a través del reactor interno de Maven.

Por supuesto, esta no es la solución perfecta, ya que no resuelve la construcción de un solo módulo individual dentro de la estructura. En este caso, Maven no tendrá las dependencias en su reactor y buscará resolverlo en el repositorio. Entonces, para compilaciones individuales, aún debe instalar las dependencias primero.

Aquí hay alguna referencia que describe esta situación.

para mí, lo que me llevó a este hilo fue un problema similar y la solución fue asegurar que todos los pom de dependencia del módulo tuvieran

 <packaging>pom</packaging>

el padre tenía

pom

mi modelo de depósito tenía pom, por lo que no se encontró ningún frasco.

Lo único que funcionó para mí: cambiar a gradle :(

yo tengo

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

y puedo simplemente cd en war1 y usar mvn tomcat7: run-war. Siempre tengo que instalar todo el proyecto antes, a pesar de que war1 hace referencia a su padre y el padre hace referencia a war1 y dep1 (como módulos), por lo que se deben conocer todas las dependencias.

No entiendo cuál es el problema.

En una estructura de módulo de Maven como esta:

- parent
  - child1
  - child2

Tendrás en el parent pomesto:

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

Si ahora depende de child1adentro child2poniendo lo siguiente en su <dependencies>adentro child2:

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

Recibirá un error que indica que child1no se puede encontrar el JAR . Esto se puede resolver declarando un <dependencyManagement>bloque que incluya child1en el pomfor parent:

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

child1ahora se compilará cuando ejecute un objetivo compileo packageetc. en parent, y child2encontrará child1los archivos compilados de.

Bonificación de la respuesta de Don Willis :

Si su compilación crea jarras de prueba para compartir código de prueba entre sus submódulos de reactor, debe usar:

mvn test-compile dependency:tree

lo que permitirá dependency:treeque se ejecute hasta su finalización en este caso.

Asegúrese de que el módulo que está fallando se resuelva en el pom, esté apuntando al padre correcto al incluir las configuraciones en el archivo pom del módulo.