La bonne façon d'utiliser les dépendances dynamiques de Gradle

Cet article a été mis à jour en avril 2025

Gradle est un système de construction puissant et flexible largement utilisé pour le développement d'Android et d'autres projets basés sur Java. Il offre une gestion des dépendances, ce qui vous permet de définir les bibliothèques externes et les frameworks sur lesquels votre application s'appuiera.

Définir les dépendances dans Gradle

Typiquement, vous définissez les dépendances dans Gradle comme ceci :

dependencies {

    implementation 'com.vonage.client:client-sdk:2.7.0'

}

Dans l'exemple ci-dessus, Gradle télécharge la version spécifique 2.7.0 du Vonage Client SDK. Cependant, lorsque vous souhaitez que Gradle gère les versions des bibliothèques de manière dynamique, vous pouvez utiliser une version dynamique au lieu de spécifier un numéro de version fixe.

Comprendre le versionnement sémantique

La plupart des bibliothèques suivent aujourd'hui versionnement sémantique (semver), qui utilise un format major.minor.patch (par exemple, 2.7.0). Les règles de versionnement sont les suivantes :

• Major: Incrémenté lorsqu'il y a des changements rétrocompatibles dans l'API (par exemple, des changements de signature de méthode).

• Mineur: Incrémenté lorsque de nouvelles fonctionnalités sont ajoutées de manière rétrocompatible (par exemple, ajout de nouvelles méthodes).

• Patch: Incrémenté pour les corrections de bogues rétrocompatibles (par exemple, correction de bogues sans introduction de nouvelles fonctionnalités).

Utilisation des dépendances dynamiques

Gradle vous permet d'utiliser la version dynamique, ce qui lui permet de récupérer automatiquement la dernière version compatible d'une dépendance. Voici comment définir une version dynamique :

dependencies {

    implementation 'com.vonage.client:client-sdk:2.7.+'

}

Dans l'exemple ci-dessus, Gradle va chercher la version la plus récente du patch de 2.7.x (par exemple, 2.7.1, 2.7.2). Vous pouvez utiliser d'autres formes de dépendances dynamiques, telles que :

• implementation 'com.vonage.client:client-sdk:2.+': Cette fonction permet d'obtenir la dernière version de la base de données 2.x (versions mineures et correctives).

• implementation 'com.vonage.client:client-sdk:+': Cette fonction permet de récupérer la dernière version disponible de la bibliothèque.

Si les dépendances dynamiques permettent de s'assurer que vous utilisez toujours les dernières corrections de bogues et améliorations, elles s'accompagnent de quelques inconvénients majeurs.

Pourquoi faut-il être prudent avec les dépendances dynamiques ?

Les dépendances dynamiques peuvent entraîner des comportements imprévisibles. Vous trouverez ci-dessous quelques problèmes potentiels et des scénarios dans lesquels les dépendances dynamiques posent des problèmes.

Scénario problématique 1 : constructions incohérentes

Imaginez que votre application fonctionnait bien il y a un mois, mais qu'après l'introduction d'un bogue, elle a cessé de fonctionner comme prévu. Vous consultez le dépôt de l'époque, reconstruisez l'application, mais le problème persiste. Que s'est-il passé ?

Le problème est que le mécanisme de dépendance dynamique de Gradle a récupéré la dernière version de la bibliothèque externe, qui contient maintenant le bogue. Même si votre code source date d'un mois, la version de la bibliothèque externe n'était pas verrouillée, et c'est donc la dernière version qui a été téléchargée, introduisant le problème.

Leçon 1: Reconstruire votre application avec des dépendances dynamiques peut être peu fiable car les dépendances sont mises à jour au fil du temps, ce qui rend difficile la reproduction de l'environnement exact sur lequel votre application a été construite.

Scénario problématique 2 : bogues imprévisibles pour les utilisateurs

Si vous êtes un créateur de bibliothèque et que vous recommandez aux utilisateurs d'utiliser une version dynamique de votre bibliothèque (par ex, com.vonage.client:client-sdk:2.7.+), il se peut qu'ils rencontrent, sans le savoir, des bogues introduits dans les nouvelles versions de la bibliothèque. Ils signaleront probablement des problèmes, mais sans en connaître la cause exacte - parce qu'ils utilisaient une version plus récente que prévu.

Leçon: Évitez de conseiller aux utilisateurs d'utiliser des dépendances dynamiques pour les applications de production. Il peut être difficile de déterminer la cause d'un bogue, et les utilisateurs peuvent ne pas être en mesure de revenir facilement à une version fonctionnelle.

Des solutions modernes pour gérer les dépendances

Pour atténuer les problèmes causés par les dépendances dynamiques, des outils et des stratégies modernes sont disponibles :

1. Utiliser les fonctions de verrouillage de Gradle

Le verrouillage des dépendances intégré à Gradle vous permet de contrôler les versions des dépendances même lorsque vous utilisez le versionnement dynamique. Cela garantit que, bien que le spécificateur de version dans le fichier build.gradle peut être dynamique, la version réelle utilisée pendant la construction est verrouillée.

Pour activer verrouillage des dépendancesvous pouvez ajouter ce qui suit à votre fichier build.gradle fichier :

dependencyLocking {
    lockAllConfigurations()
}

Ensuite, pour générer un fichier de verrouillage, exécutez :

Le fichier généré dependencies.lock permet de s'assurer que tous les membres de l'équipe utilisent les mêmes versions des dépendances, ce qui rend les constructions déterministes et réduit la probabilité d'apparition de bogues.

2. Utilisation du plugin Gradle Dependency Lock

Pour les équipes qui ont besoin de fonctionnalités plus avancées, le plugin gradle-versions-plugin peut aider à suivre les dépendances obsolètes. Exécutez la commande suivante pour vérifier les mises à jour :

Ensuite, pour générer un fichier de verrouillage, exécutez :

Cette commande génère un rapport listant toutes les dépendances obsolètes de votre projet. Pour les grands projets, cela permet de s'assurer que les dépendances restent à jour sans avoir à vérifier manuellement chacune d'entre elles.

3. Verrouillage de versions spécifiques avecstrictly

Si vous avez besoin d'un contrôle fin sur les versions d'une dépendance qui sont utilisées (même avec le versionnage dynamique), vous pouvez utiliser la fonctionnalité strictly de Gradle :

dependencies {
    implementation('com.vonage.client:client-sdk:2.7.+') {
        strictly '2.7.1'
    }
}

Cela permet un versionnage dynamique, mais verrouille la version à 2.7.1ce qui empêche l'utilisation inopinée de versions plus récentes.

4. Avertissements de l'IDE

Les IDE modernes comme IntelliJ IDEA ou Android Studio vous avertissent lorsque vous utilisez des dépendances dynamiques, ce qui permet de détecter plus facilement les problèmes potentiels avant qu'ils ne surviennent. Ils proposent également souvent des actions faciles pour mettre à jour ou verrouiller les versions des dépendances.

Bonnes pratiques pour la gestion des dépendances

1. Définir explicitement les versions dans les environnements de production: Spécifiez toujours la version exacte dans le code de production afin d'éviter les problèmes inattendus liés aux nouvelles versions de la bibliothèque.

2. Utiliser le verrouillage des dépendances: Verrouillez les dépendances à des versions spécifiques pour vous assurer que vos constructions sont reproductibles dans tous les environnements.

3. Automatiser les mises à jour avec des outils: Envisagez d'utiliser des outils tels que Dependabot pour la gestion automatisée des dépendances dans votre référentiel. Cela vous aide à suivre les mises à jour sans avoir à vérifier manuellement chaque dépendance.

4. Consulter les changelogs: Avant de mettre à jour des dépendances, consultez leur journal des modifications pour vous assurer que vous êtes au courant des changements ou des nouvelles fonctionnalités.

5. Test en profondeur: Lorsque vous utilisez des dépendances dynamiques, veillez à mettre en place une bonne couverture de test afin de détecter les problèmes susceptibles de survenir à la suite de modifications de vos dépendances.

Conclusion

Les dépendances dynamiques dans Gradle sont pratiques mais peuvent présenter des risques, tels que des constructions incohérentes et des bogues imprévisibles. Il est préférable de verrouiller les dépendances en utilisant les fonctionnalités de verrouillage intégrées à Gradle ou des plugins tels que le module gradle-versions-plugin. Pour les applications de production, il est recommandé de spécifier les versions exactes afin d'éviter les problèmes inattendus et d'assurer la reproductibilité. En adoptant les bonnes stratégies et les bons outils, vous pouvez gérer vos dépendances en toute confiance et garder vos builds stables.