À quoi sert l'injection de dépendances dans les…

L'injection de dépendances (DI) est utilisée dans les applications Android pour décomposer le code, améliorer la testabilité et faciliter la refactorisation. Elle permet aux composants d'obtenir des dépendances à partir de sources externes plutôt que de les créer eux-mêmes.

Les principaux objectifs de l'utilisation de DI dans Android :

Découplage (Détachement des dépendances) : Les composants deviennent moins liés entre eux. Modifier une dépendance ne nécessite pas de changer le composant qui l'utilise.
Testabilité : Il est facile de substituer des implémentations de test (mocks, fakes) lors de l'écriture de tests unitaires.
Gestion du cycle de vie : Les frameworks DI peuvent gérer la création et la destruction des objets, assurant des cycles de vie appropriés pour les dépendances, ce qui est particulièrement pertinent dans Android avec ses cycles de vie spécifiques d'Activities, Fragments, etc.
Réutilisation : Les dépendances peuvent être facilement réutilisées par différents composants de l'application.
Simplification du code : Le code devient plus propre et plus compréhensible, car il n'est pas nécessaire de créer et de passer manuellement des dépendances via des constructeurs ou des setters.

Exemples de frameworks DI en Android : Hilt (recommandé par Google), Dagger, Koin.

Exemple (pseudocode sans DI) :

// Classe qui crée une dépendance en interne
class UserRepository {
    private val apiService = ApiService() // Création interne de dépendance

    fun getUser(id: Int): User {
        return apiService.fetchUser(id)
    }
}

class ApiService {
    fun fetchUser(id: Int): User {
        // Logique pour obtenir des données
        return User(id, "John Doe")
    }
}

data class User(val id: Int, val name: String)

Exemple (pseudocode avec DI) :

// Classe recevant la dépendance via le constructeur
class UserRepository(private val apiService: ApiService) {

    fun getUser(id: Int): User {
        return apiService.fetchUser(id)
    }
}

class ApiService {
    fun fetchUser(id: Int): User {
        // Logique pour obtenir des données
        return User(id, "Jane Doe")
    }
}

data class User(val id: Int, val name: String)

// Quelque part dans le code, où la configuration DI a lieu :
// val apiService = ApiService()
// val userRepository = UserRepository(apiService)

Dans le dernier exemple, UserRepository ne sait pas comment créer ApiService, il la reçoit simplement de l'extérieur. Cela facilite le remplacement de ApiService par une version de test lors des tests de UserRepository.

À quoi sert l'injection de dépendances dans les applications Android?