web-dev-qa-db-fra.com

Maven: ajout d'une référence à un projet pom parent

Je ne suis pas sûr de comprendre comment utiliser correctement un projet pom parent. J'ai le pom parent suivant défini:

<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>parent</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>pom</packaging>

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

Et puis les enfants pom référencent le parent (chaque enfant a son propre ensemble de dépendances non affichées):

<parent>
    <groupId>com.example</groupId>
    <artifactId>parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <relativePath>../Parent/pom.xml</relativePath>
</parent>

<modelVersion>4.0.0</modelVersion>
<artifactId>child1</artifactId>

Cette configuration fonctionne correctement et se résout correctement dans Eclipse (m2Eclipse). Je peux les déployer dans mon référentiel local et obtenir la structure suivante, qui devrait être correcte:

--com
   --example
      --parent
        --0.0.1-SNAPSHOT
          --parent-0.0.1-SNAPSHOT.pom
      --child1
        --0.0.1-SNAPSHOT
          --child1-0.0.1-SNAPSHOT.jar
          --child1-0.0.1-SNAPSHOT.pom
      --child2
        --0.0.1-SNAPSHOT
          --child2-0.0.1-SNAPSHOT.jar
          --child2-0.0.1-SNAPSHOT.pom

Mon problème est que je veux maintenant faire référence au projet parent dans un projet different (pas à parent, child1 ou child2) et ainsi intégrer tous les enfants du parent. Je peux y ajouter une référence dans mon autre projet:

<dependencies>
    <dependency>
        <groupId>com.example</groupId>
        <artifactId>parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <type>pom</type>
    </dependency>
</dependencies>

En faisant cela, le projet ne montre aucune erreur dans Eclipse, mais aucun artefact n'est ajouté à mon chemin de classe: pas child1, child2 ou aucune de leurs dépendances.

Je n'arrête pas de penser qu'il doit y avoir un moyen d'avoir un projet de pom "maître" qui ne soit pas un pot en lui-même mais qui ne contienne que des références à d'autres bocaux et puisse ensuite référencer ce "maître" quelque part, mais je ne peux pas savoir comment cela se fait. est accompli.

javaeclipsemavenm2eclipse
12
trebor

La première chose que je suggérerais de changer votre structure des projets.

--com
   --example
      --parent
        --0.0.1-SNAPSHOT
          --parent-0.0.1-SNAPSHOT.pom
      --child1
        --0.0.1-SNAPSHOT
          --child1-0.0.1-SNAPSHOT.jar
          --child1-0.0.1-SNAPSHOT.pom
      --child2
        --0.0.1-SNAPSHOT
          --child2-0.0.1-SNAPSHOT.jar
          --child2-0.0.1-SNAPSHOT.pom

Je suggérerais de suivre le chemin suivant:

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

Le parent peut être archivé dans un contrôle de version (Git, SVN) dans le maître ou dans le coffre. En dehors de cela, tous les enfants doivent référencer le parent comme ceci:

<modelVersion>4.0.0</modelVersion>

<parent>
    <groupId>com.example</groupId>
    <artifactId>parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</parent>

<artifactId>child1</artifactId>

et dans votre parent, vous pouvez utiliser des choses comme ceci:

<groupId>com.example</groupId>
<artifactId>parent</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>pom</packaging>

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

De plus, vous pouvez utiliser un nom de société en ajoutant simplement une référence parent à votre projet parent:

<parent>
    <groupId>com.example</groupId>
    <artifactId>master-pom</artifactId>
    <version>0.0.1</version>
</parent>

<groupId>com.example</groupId>
<artifactId>parent</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>pom</packaging>

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

Dans la société pom, vous pouvez (et devez) épingler différentes versions de plug-in et définir les valeurs par défaut de la société ainsi que des suggestions de dépendances avec leurs versions appropriées.

Si vous aimez avoir une entreprise super-pom, vous créez simplement un projet maven distinct qui ne contient que le fichier pom qui contient vos configurations, telles que les plugins, les dépendances, etc. séparément de l'autre projet.

Si vous souhaitez référencer un fichier jar, ce qui signifie en d'autres termes un artefact de votre construction multi-module, vous devez utiliser les identifiants groupId, artifactId et version corrects. Si vous aimez utiliser child1 dans un autre projet, vous devez indiquer les éléments suivants:

<dependencies>
    <dependency>
        <groupId>com.example</groupId>
        <artifactId>child1</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </dependency>
</dependencies>

Il est important de comprendre que le parent d'une construction à plusieurs modules n'est pas un artefact généralement utilisé. En raison du type d'emballage utilisé, pom, il ne crée pas vraiment d'artefact (fichier jar).

Update: Vous pouvez le faire de manière limitée uniquement pour le domaine dependencyManagement avec le scope import mais ceci est uniquement destiné à être utilisé dans le depdencyManagement et non pour les dépendances . Un autre La solution pourrait consister à créer un projet fictif séparé comportant les dépendances et deux enfants en tant que dépôts transitifs. Mais ce n'est pas vraiment la beauté.

La solution consiste donc simplement à ajouter directement deux ou plusieurs dépendances que vous utilisez dans votre projet et c'est tout.

13
khmarbaise

Essayez de créer un super pom avec le même type d’emballage et ajoutez votre parent actuel en tant que dépendance.

0
MikeW

Comme @khmarbaise l'a souligné, le parent d'une construction multi-module n'est généralement pas utilisé comme dépendance ailleurs. 

Vous devriez pouvoir ajouter chacun de vos modules enfants en tant que dépendances et réaliser ce que vous voulez faire en ajoutant le pom parent. 

0
Raghuram