Gestion des dépendances avec Maven

L'une des fonctionnalités principales de Maven est la gestion des dépendances. Lorsque nous traitons des projets multi-modules (contenant des centaines ou des milliers de modules ou sous-projets), les relations de dépendance entre les modules deviennent très complexes, et la gestion devient très difficile. Dans cette situation, Maven fournit une approche hautement contrôlée.


Découverte des dépendances transitives

Une situation assez courante, par exemple, A dépend d'une autre bibliothèque B. Si un autre projet C veut utiliser A, alors le projet C doit aussi utiliser la bibliothèque B.

Maven peut éviter d'avoir à rechercher toutes les bibliothèques requises. Maven lit les fichiers de projet (pom.xml) pour trouver les relations de dépendance entre les projets.

Tout ce que nous avons à faire est de définir les dépendances directes dans le pom de chaque projet. Maven s'occupera de tout le reste pour nous.

Avec les dépendances transitives, le graphe de toutes les bibliothèques incluses peut croître rapidement. Lorsqu'il y a des bibliothèques en double, les situations possibles continueront d'augmenter. Maven fournit certaines fonctionnalités pour contrôler le degré des dépendances transitives.

Fonctionnalité Description de la fonctionnalité
Médiation des dépendances Détermine quelle version de dépendance sera utilisée lorsque plusieurs versions créées manuellement apparaissent en même temps. Si deux versions de dépendance se trouvent à la même profondeur dans l'arborescence des dépendances, la première dépendance déclarée sera utilisée.
Gestion des dépendances Vous pouvez spécifier directement une version créée manuellement à utiliser. Par exemple, supposons que le projet C inclut le projet B comme dépendance, et que le projet B dépende du projet A. Dans ce cas, vous pouvez spécifier explicitement la version du projet A à utiliser lorsque le projet B est référencé. Cela signifie que vous pouvez contrôler quelle version spécifique du projet A sera utilisée par le projet B.
Portée des dépendances Dépendances incluses dans chaque phase du processus de build.
Exclusion de dépendances Toute dépendance transitive peut être exclue via l'élément "exclusion". Par exemple, A dépend de B, B dépend de C, donc A peut marquer C comme "exclue".
Dépendance facultative Toute dépendance transitive peut être marquée comme facultative en utilisant l'élément "optional". Par exemple : A dépend de B, et B dépend de C. Par conséquent, B peut marquer C comme facultative, de sorte que A n'utilise plus C.

Portée des dépendances

La découverte des dépendances transitives peut être limitée en utilisant les portées de dépendance suivantes :

Portée Description
Compile Cette portée indique que la dépendance associée est uniquement valide sur le classpath du projet. Valeur par défaut.
Provided Cette portée indique que la dépendance concernée est fournie par le JDK d'exécution ou un serveur web.
Exécution Cette portée indique que la dépendance concernée n'est pas requise pendant la phase de compilation, mais qu'elle est requise pendant la phase d'exécution.
Test Cette portée indique que la dépendance concernée est uniquement destinée aux phases de compilation et d'exécution des tests.
Système Cette portée indique que vous devez fournir un chemin système.
Importer Cette portée n'est utilisée que lorsque la dépendance est définie dans un pom. En même temps, le fichier POM du projet actuelles dépendances définies dans la section <dependencyManagement> peuvent remplacer un POM spécifique.

Gestion des dépendances

Habituellement, dans un projet commun, il existe une série de projets. Dans ce cas, nous pouvons créer un fichier pom de dépendances communes contenant toutes les dépendances communes, que nous appelons le pom parent des autres poms de sous-projets. L'exemple suivant peut vous aider à mieux comprendre ce concept.

Voici une explication détaillée du graphe de dépendances ci-dessus :

  • App-UI-WAR dépend de App-Core-lib et App-Data-lib.

  • Root est le projet parent de App-Core-lib et App-Data-lib.

  • Root définit Lib1, lib2 et Lib3 comme dépendances dans sa section des dépendances.

Le code du fichier pom.xml d'App-UI-WAR est le suivant :

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.companyname.groupname</groupId> <artifactId>App-UI-WAR</artifactId> <version>1.0</version> <packaging>war</packaging> <dependencies> <dependency> <groupId>com.companyname.groupname</groupId> <artifactId>App-Core-lib</artifactId> <version>1.0</version> </dependency> </dependencies> <dependencies> <dependency> <groupId>com.companyname.groupname</groupId> <artifactId>App-Data-lib</artifactId> <version>1.0</version> </dépendance> </dépendances> </projet>

Le code du fichier pom.xml d'App-Core-lib est le suivant :

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <parent> <artifactId>Root</artifactId> <groupId>com.companyname.groupname</groupId> <version>1.0</version> </parent> <modelVersion>4.0.0</modelVersion> <groupId>com.companyname.groupname</groupId> <artifactId>App-Core-lib</artifactId> <version>1.0</version> <packaging>jar</packaging> </project>

Le code du fichier pom.xml de App-Data-lib est le suivant :

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <parent> <artifactId>Root</artifactId> <groupId>com.companyname.groupname</groupId> <version>1.0</version> </parent> <modelVersion>4.0.0</modelVersion> <groupId>com.companyname.groupname</groupId> <artifactId>App-Data-lib</artifactId> <version>1.0</version> <packaging>jar</packaging> </project>

Le code du fichier pom.xml de Root est le suivant :

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.companyname.groupname</groupId> <artifactId>Root</artifactId> <version>1.0</version> <packaging>pom</packaging> <dependencies> <dependency> <groupId>com.companyname.groupname1</groupId> <artifactId>Lib1</artifactId> <version>1.0</version> </dependency> </dependencies> <dependencies> <dependency> <groupId>com.companyname.groupname2</groupId> <artifactId>Lib2</artifactId> <version>2.1</version> </dependency> </dependencies> <dependencies> <dependency> <groupId>com.companyname.groupname3</groupId> <artifactId>Lib3</artifactId> <version>1.1</version> </dependency> </dependencies> </project>

Maintenant, lorsque nous construisons le projet App-UI-WAR, Maven trouvera toutes les dépendances en parcourant le graphe de dépendances et construira l'application.

À travers l'exemple ci-dessus, nous pouvons apprendre les concepts clés suivants :

  • Les dépendances communes peuvent être unifiées ensemble à l'aide du concept de pom parent. Les dépendances des projets App-Data-lib et App-Core-lib sont listées dans le projet Root (reportez-vous au type de packaging de Root, il s'agit d'un POM).
  • Il n'est pas nécessaire de déclarer Lib1, lib2, Lib3 comme dépendances dans App-UI-W. Maven implémente ce détail grâce au mécanisme de dépendances transitives.
Autres extensions