Maven não reconhece módulos irmãos ao executar mvn dependency: tree

Estou tentando configurar um projeto Maven com vários módulos e as dependências entre os módulos aparentemente não estão sendo configuradas corretamente.

Eu tenho:

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

no POM pai (que tem um pom do tipo de embalagem) e, em seguida, nos subdiretórios commons/e storage/que definem os poms JAR com o mesmo nome.

O armazenamento depende do Commons.

No diretório principal (mestre), executo mvn dependency:treee vejo:

[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 que a dependência de "bens comuns" falha, embora o reator obviamente a tenha visto porque processa com sucesso sua árvore de dependência? Definitivamente, não deveria ir para a rede para encontrá-lo, pois está bem ali ...

O pom para armazenamento:

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

Obrigado por qualquer sugestão!

(Editar)

Para esclarecer, o que estou procurando aqui é o seguinte: Não quero ter que instalar o módulo X para construir o módulo Y que depende de X, visto que ambos são módulos referenciados no mesmo POM pai. Isso faz sentido intuitivo para mim que, se eu tiver duas coisas na mesma árvore de origem, não devo ter que instalar produtos intermediários para continuar a compilação. Espero que meu pensamento faça algum sentido aqui ...

Acho que o problema é que, quando você especifica uma dependência, o Maven espera tê-la como jar (ou qualquer outro) empacotado e disponível em pelo menos um repositório local. Tenho certeza de que se você executar primeiro mvn installem seu projeto comum, tudo funcionará.

Conforme discutido neste tópico da lista de discussão maven , o objetivo da dependência: árvore por si só procurará as coisas no repositório ao invés do reator. Você pode contornar isso instalando mvn, conforme sugerido anteriormente, ou fazendo algo menos oneroso que invoque o reator, como

mvn compile dependency:tree

Funciona para mim.

Perceber isso é um tópico mais antigo, mas parece que a ferramenta evoluiu ou isso pode ter sido esquecido da primeira vez.

É possível realizar uma construção que faça dependências resolvidas sem instalar, fazendo uma construção de reator.

Se você iniciar sua construção no pai que descreve a estrutura do módulo do seu projeto, suas dependências entre os módulos serão resolvidas durante a própria construção por meio do reator interno Maven.

Claro que esta não é a solução perfeita, pois não resolve a construção de um único módulo individual dentro da estrutura. Neste caso o Maven não terá as dependências em seu reator e buscará resolvê-lo no repositório. Portanto, para compilações individuais, você ainda precisa instalar as dependências primeiro.

Aqui estão algumas referências que descrevem esta situação.

para mim, o que me levou a este tópico foi um problema semelhante e a solução foi garantir que todas as dependências do módulo tivessem

 <packaging>pom</packaging>

o pai tinha

pom

meu modelo dep tinha pom - então não havia jarra a ser encontrada.

A única coisa que funcionou para mim: mudar para o gradle :(

eu tenho

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

e posso apenas fazer cd em war1 e usar mvn tomcat7: run-war. Sempre tenho que instalar o projeto inteiro antes, apesar das referências de war1, seu pai e as referências do pai war1 e dep1 (como módulos), então todas as dependências devem ser conhecidas.

Não entendo qual é o problema.

Em uma estrutura de módulo Maven como esta:

- parent
  - child1
  - child2

Você terá parent pomneste:

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

Se você agora dependem child1em child2, colocando o seguinte no seu <dependencies>em child2:

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

Você receberá um erro no qual o JAR child1não pode ser encontrado. Isso pode ser resolvido declarando um <dependencyManagement>bloco incluindo child1no pomfor parent:

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

child1agora será compilado quando você executar um objetivo compileou packageetc. no parent, e child2encontrará child1os arquivos compilados de.

Bonificando a resposta de Don Willis :

Se sua compilação cria jars de teste para compartilhar o código de teste entre os submódulos do reator, você deve usar:

mvn test-compile dependency:tree

que permitirá dependency:treea execução até a conclusão neste caso.

Certifique-se de que o módulo que está falhando seja resolvido no pom, esteja apontando para o pai correto, incluindo as configurações no arquivo pom do módulo.