Maven ne reconnaît pas les modules frères lors de l'exécution de la dépendance mvn: tree

Question

Je vais essayer de mettre en place un multi-module Maven du projet, et les inter-dépendances des modules sont apparemment pas mis en place correctement.

J'ai:

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

dans le POM parent (qui a un emballage de type pom) et puis les sous-répertoires communes/ et/ stockage qui définissent POT de chrysanthèmes avec le même nom.

De stockage dépend des Communes.

Dans la principale (master) répertoire, j'ai exécuter mvn dependency:tree et voir:

[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

Pourquoi la dépendance sur "commons" l'échec, même si le réacteur a évidemment vu parce qu'il parvient à traiter sa dépendance de l'arbre? Il ne doit certainement pas être aller le net pour le trouver car il est là...

Le pom pour le stockage:

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

Merci pour toutes les suggestions!

(Edit)

Pour préciser, ce que je cherche ici, c'est ceci: je ne veux pas à avoir à installer de module X pour générer un module Y qui dépend de X, étant donné que les deux sont des modules référencés dans le même parent POM. Cela fait sens intuitif pour moi que si j'ai deux choses à la source même de l'arbre, je ne devrais pas avoir à installer des produits intermédiaires pour continuer la construction. Espérons que ma pensée a un sens ici...

Answer 1

Comme discuté dans ce fil de discussion de liste de diffusion maven , l'objectif dépendances: arborescence à lui seul recherchera les choses dans le référentiel plutôt que dans le réacteur. Vous pouvez contourner ce problème en installant mvn, comme suggéré précédemment, ou en faisant quelque chose de moins onéreux qui appelle le réacteur, tel que

dépendance de compilation mvn: tree

Travaille pour moi.

Answer 2

Je pense que le problème est que lorsque vous spécifiez une dépendance, Maven s'attend à l'avoir sous forme de fichier jar (ou autre) emballé et disponible à partir d'au moins un référentiel local. Je suis sûr que si vous lancez mvn install sur votre projet commun tout d’abord, tout fonctionnera.

Answer 3

En réalisant que c'est un vieux thread mais il semble que ce soit l'outil évolué ou c'était peut-être manqué la première fois autour.

Il est possible d'effectuer une génération qui fait dépendances résolues sans l'installer en faisant un réacteur de construire.

Si vous commencez votre construction dans le parent qui décrit la structure du module de votre projet, vos dépendances entre modules sera résolu lors de la construire lui-même par l'intérieur Maven réacteur.

Bien sûr, ce n'est pas la solution parfaite, car elle ne résout pas la construction d'un seul module individuel au sein de la structure. Dans ce cas, Maven va pas avoir les dépendances dans son réacteur et de l'abeille à la recherche à résoudre dans le référentiel. Donc, pour l'individu construit vous avez toujours installer les dépendances de la première.

Voici certains de référence décrivant cette situation.

Answer 4

pour moi, ce qui m'a amené à ce fil était un problème similaire et la solution consistait à s'assurer que tous les pom de dépendance de module avaient

  <packaging>pom</packaging>
 

le parent avait

pom

mon modèle dep avait pom - donc il n'y avait pas de pot à trouver.

Answer 5

Ajoutez un plugin maven-compiler au POM parent. Ça devrait ressembler à ça:

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

<properties>
    <maven.compiler.plugin.version>2.3.2</maven.compiler.plugin.version>
    <jre.source.version>1.7</jre.source.version>
    <jre.target.version>1.7</jre.target.version>
</properties>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>${maven.compiler.plugin.version}</version>
            <configuration>
                <source>${jre.source.version}</source>
                <target>${jre.target.version}</target>
            </configuration>
        </plugin>
    </plugins>
</build>