Gestion de projet multi-module Maven

Un projet multi-module Maven désigne une structure de projet dans laquelle un projet parent contient plusieurs sous-modules. Cette structure nous permet de diviser un grand projet en plusieurs modules logiquement indépendants mais interdépendants, chacun pouvant être construit séparément ou ensemble dans son intégralité.

Avantages des projets multi-modules

  1. Réutilisation du code: Le code commun peut être extrait dans un module séparé pour être utilisé par d'autres modules
  2. Séparation des préoccupations: Différentes équipes peuvent se concentrer sur le développement de différents modules
  3. Efficacité de compilation: Seuls les modules modifiés sont compilés, ce qui réduit le temps de compilation
  4. Gestion des dépendances: Gérer de manière centralisée les relations de dépendance de tous les modules
  5. Gestion des versions: Tous les modules utilisent un numéro de version unifié pour faciliter la gestion

Scénarios applicables

  • Découpage en couches de grands projets (par ex.,web、service、dao)

  • Architecture de microservices (un module par service)

  • Partage de code commun (par ex.,commonModule)

Structure de répertoires standard

parent-project/          # 父项目根目录
├── pom.xml             # 父POM(packaging=pom)
├── module-a/           # 子模块A
│   ├── src/
│   └── pom.xml         # 子模块A的POM
├── module-b/           # 子模块B
│   ├── src/
│   └── pom.xml         # 子模块B的POM
└── module-web/         # Web模块
    ├── src/
    └── pom.xml

Fonctionnalités clés :

  1. POM parent:

    • Doit être défini<packaging>pom</packaging>

    • via<modules>Gérer les sous-modules

  2. Sous-modules:

    • via<parent>héritent du POM parent

    • peuvent avoir leurs propres dépendances et configurations de build


Création d'un projet Maven multi-module

1. Créer le projet parent

Le projet parent lui-même ne contient généralement aucun code ; il sert principalement à gérer les sous-modules et la configuration commune.

Pour créer le fichier pom.xml du projet parent, vous devez définir packaging sur pom :

<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>parent-project</artifactId>
    <version>1.0.0</version>
    <packaging>pom</packaging>
   
    <modules>
        <module>module1</module>
        <module>module2</module>
    </modules>
</project>

2. Créer des sous-modules

Les sous-modules sont de véritables modules de code, qui peuvent être des projets Java ordinaires, des applications web, etc. Chaque sous-module possède son propre fichier pom.xml, mais il doit déclarer le projet parent :

<project>
    <parent>
        <groupId>com.example</groupId>
        <artifactId>parent-project</artifactId>
        <version>1.0.0</version>
    </parent>
   
    <modelVersion>4.0.0</modelVersion>
    <artifactId>module1</artifactId>
</project>

Gestion des dépendances dans les projets multi-modules

Dans un projet multi-module, les modules peuvent dépendre les uns des autres. Par exemple, module2 dépend de module1 :

<project>
    <!-- pom.xml de module2 -->
    <dependencies>
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>module1</artifactId>
            <version>${project.version}</version>
        </dependency>
    </dependencies>
</project>

Héritage des dépendances

Le projet parent peut définir des dépendances communes, et les sous-modules hériteront automatiquement de ces dépendances :

<project>
    <!-- pom.xml du projet parent -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

Le sous-module doit uniquement déclarer le groupId et l'artifactId de la dépendance, sans préciser la version :

<project>
    <!-- pom.xml du sous-module -->
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
    </dependencies>
</project>

Construction de projets multi-modules

1. Compiler l'ensemble du projet

Exécutez ce qui suit dans le répertoire du projet parent :

mvn clean install

Cela compilera tous les sous-modules dans l'ordre des dépendances.

2. Compiler un seul module

Entrez dans le répertoire du module spécifique et exécutez :

cd module1
mvn clean install

Ou spécifiez le module depuis le répertoire du projet parent :

mvn -pl module1 clean install

3. Compiler un module et ses dépendances

mvn -pl module1 -am clean install

Bonnes pratiques pour les projets multi-modules

1. Découpage raisonnable des modules

  • Diviser les modules par fonction
  • Diviser les modules par couche (par ex., dao, service, web)
  • Extraire les utilitaires communs dans un module séparé

2. Gestion des versions

  • Utiliser le projet parent pour gérer centralement les numéros de version
  • Envisager d'utiliser le plugin versions de Maven pour gérer les mises à niveau de version

3. Optimisation du build

  • Configurer un ordre de build approprié
  • Utiliser des profils pour gérer les builds pour différents environnements
  • Envisager des builds en parallèle pour améliorer l'efficacité

4. Gestion des dépendances

  • Gérer centralement les dépendances communes dans le projet parent
  • Utiliser dependencyManagement pour unifier les versions
  • Éviter les dépendances circulaires

Problèmes courants et solutions

1. Problèmes de dépendances circulaires

Problème: Le module A dépend du module B, et le module B dépend du module A.
Solution:

  • Repenser la structure des modules et extraire le code commun vers un troisième module
  • Utiliser des interfaces pour découpler

2. Problèmes d’ordre de construction

Problème: Maven ne peut pas identifier correctement l’ordre des dépendances entre les modules.
Solution:

  • Déclarer explicitement les dépendances entre modules
  • Utiliser le plugin reactor pour analyser l’ordre de construction

3. Problèmes d’incohérence de versions

Problème: Différents modules utilisent différentes versions de dépendances.
Solution:

  • Gérer de manière centralisée les versions des dépendances dans le projet parent
  • Utiliser dependencyManagement

En utilisant judicieusement la gestion de projets multi-modules Maven, vous pouvez améliorer considérablement la maintenabilité et l'efficacité de build des grands projets. Maîtriser ces techniques vous aidera à mieux organiser et gérer des projets Java complexes.

Autres extensions