Injection de dépendances (Dependency Injection) en Kotlin : Guide complet

Introduction à Dependency Injection en Kotlin

Dans le développement moderne en Kotlin, en particulier lors de la création d'applications Android, le principe Dependency Injection (DI) est devenu non seulement une bonne pratique, mais une nécessité. L'injection de dépendances permet d'écrire un code propre, testable et évolutif, en réduisant le couplage entre les composants du système.

Dans cet article, nous allons voir ce qu'est Dependency Injection, quels problèmes il résout, et comment implémenter DI en Kotlin — de l'approche manuelle à l'utilisation de frameworks populaires comme Hilt et Koin.

Qu'est-ce que Dependency Injection (Injection de dépendances) ?

Dependency Injection est un pattern de conception dans lequel un objet reçoit ses dépendances de l'extérieur, plutôt que de les créer lui-même. Au lieu d'écrire val engine = Engine() à l'intérieur d'une classe, nous "injectons" une instance prête via le constructeur, une méthode ou un champ.

Considérons un exemple simple sans DI :

class Car {    private val engine = Engine() // Couplage fort

    fun start() {        engine.start()    }}

Problème : la classe Car est fortement liée à une implémentation spécifique de Engine. Il est difficile de la tester et de l'étendre.

Maintenant, un exemple avec DI via le constructeur :

class Car(private val engine: Engine) { // La dépendance est passée de l'extérieur

    fun start() {        engine.start()    }}

// Utilisationval engine = Engine()val car = Car(engine)car.start()

Maintenant, Car ne sait pas comment Engine est créé. Nous pouvons facilement le remplacer par un MockEngine pour les tests ou par une autre implémentation.

Pourquoi DI est-il important en Kotlin ?

Kotlin, en tant que langage moderne, offre d'excellentes possibilités pour DI :

• Null Safety — Kotlin aide à éviter les NullPointerException lors du travail avec les dépendances.
• Syntaxe concise — les constructeurs avec paramètres rendent DI naturel.
• Compatibilité avec Java — tous les frameworks DI populaires (Dagger, Hilt) supportent Kotlin.
• Style fonctionnel — Kotlin permet d'utiliser des lambdas et des délégations pour implémenter DI.

Façons d'implémenter DI en Kotlin

1. Injection manuelle (Manual DI)

La façon la plus simple est de passer les dépendances via le constructeur. Pour les petits projets, cela suffit souvent.

class Database(private val connection: Connection)

class UserRepository(private val database: Database)

class UserViewModel(private val userRepository: UserRepository)

// Assemblage manuel des dépendancesfun main() {    val connection = Connection("postgres://localhost:5432")    val database = Database(connection)    val repository = UserRepository(database)    val viewModel = UserViewModel(repository)}

Inconvénient : lorsque le projet grandit, la gestion manuelle devient lourde.

2. Service Locator (Anti-pattern ou solution temporaire)

On utilise parfois Service Locator — un objet central qui stocke toutes les dépendances. Cependant, cela est considéré comme un anti-pattern car il cache les dépendances réelles de la classe.

object ServiceLocator {    private val database = Database()    private val repository = UserRepository(database)        fun provideViewModel() = UserViewModel(repository)}

// Utilisationval viewModel = ServiceLocator.provideViewModel()

3. Frameworks DI : Hilt et Koin

Pour les projets sérieux, il est préférable d'utiliser des solutions prêtes à l'emploi. Examinons les deux plus populaires pour Kotlin/Android.

Hilt (basé sur Dagger)

Hilt est la bibliothèque DI officielle de Google pour Android. Elle est basée sur Dagger, mais avec une API simplifiée.

// 1. Annotation @HiltAndroidApp dans Application@HiltAndroidAppclass MyApplication : Application(