0Pricing
Android Academy · Leçon

Pourquoi l'injection de dépendances ?

Rendez votre code testable et modulaire.

Pourquoi l'injection de dépendances ? est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Android Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Android Academy comprend 4 leçons au total.

Qu’est-ce que l’injection de dépendances ?

L’injection de dépendances (DI) consiste à fournir à un objet ce dont il a besoin depuis l’extérieur, plutôt que de le laisser créer lui-même ces éléments.

Le problème : des dépendances rigides

Lorsqu’une classe construit elle-même ses dépendances, elle devient fortement couplée et difficile à modifier ou à tester.

class UserViewModel {
    private val repo = UserRepository(
        ApiClient(), AppDatabase.get()
    ) // tightly coupled
}

La solution : injecter les dépendances

Transmettez les dépendances par le constructeur. La classe n’a plus besoin de savoir comment elles sont créées.

class UserViewModel(
    private val repo: UserRepository
) {
    // repo supplied from outside
}

Avantage 1 : facilité des tests

Dans les tests, vous pouvez transmettre un dépôt simulé ou factice, afin de tester le ViewModel sans véritable réseau ni base de données.

val vm = UserViewModel(FakeUserRepository())

Avantage 2 : modularité

Comme les classes dépendent d’abstractions, vous pouvez remplacer les implémentations — par exemple une API réelle par une version hors ligne factice — sans modifier le code qui les utilise.

Dépendre d’interfaces

Faites dépendre les classes d’une interface, et non d’un type concret. C’est la clé pour remplacer facilement une implémentation.

interface UserRepository {
    suspend fun getUsers(): List<User>
}

class NetworkUserRepository(
    private val api: ApiService
) : UserRepository { /* ... */ }

Avantage 3&nbsp;: responsabilité unique

Les classes se concentrent sur leur rôle, et non sur la construction de leurs collaborateurs. La création des objets est déplacée dans un emplacement dédié.

L’injection manuelle devient pénible

Vous pouvez effectuer la DI manuellement, mais à mesure que le graphe grandit, vous devez relier de nombreux objets les uns aux autres et les faire transiter manuellement par les constructeurs. C’est fastidieux et source d’erreurs.

val db = AppDatabase.get(context)
val api = ApiService.create()
val repo = NetworkUserRepository(api)
val vm = UserViewModel(repo)
// ...repeated everywhere

Adopter un framework de DI

Un framework automatise cette configuration. Vous déclarez une seule fois comment construire chaque dépendance, puis il construit tout le graphe pour vous.

Pourquoi Hilt

Hilt est le framework de DI recommandé pour Android. Basé sur Dagger, il fournit des composants standard associés aux classes Android (Application, Activity, ViewModel), avec beaucoup moins de code répétitif.

Ce que Hilt vous apporte

  • La génération automatique du graphe de dépendances.
  • Des portées adaptées au cycle de vie.
  • Une injection facile dans les Activities, les Fragments et les ViewModels.

Les prochaines leçons vont vous guider dans sa configuration.

Vérification rapide

Vérifiez votre compréhension de l’injection de dépendances.

Récapitulatif

Vous avez appris que :

  • La DI fournit les dépendances depuis l’extérieur au lieu de les créer en interne.
  • Elle améliore la facilité des tests, la modularité et la séparation des responsabilités.
  • Il faut dépendre d’interfaces.
  • La DI manuelle s’adapte mal aux projets grandissants ; Hilt l’automatise.

Questions Fréquemment Posées

La leçon « Pourquoi l'injection de dépendances ? » est-elle gratuite ?

Oui — le texte complet de « Pourquoi l'injection de dépendances ? » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Android Academy, passe à CoddyKit PRO. Le cours Android Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Pourquoi l'injection de dépendances ? » ?

Rendez votre code testable et modulaire. Tu pratiques Android Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Android Academy ?

Aucune expérience préalable n'est requise. Android Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Pourquoi l'injection de dépendances ? » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Android Academy ?

Oui. Chaque leçon Android Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Pourquoi l'injection de dépendances ?
  2. Configurer Hilt
  3. Modules et fournisseurs
  4. Injecter dans les ViewModels
← Retour à Android Academy