Koin — Conteneur d'injection de dépendances pour Kotlin

Koin — Conteneur d'injection de dépendances pour Kotlin

Dans le développement Kotlin moderne, la gestion des dépendances est une tâche importante. Koin est un conteneur léger d'injection de dépendances (DI) écrit en Kotlin, qui ne nécessite ni génération de code, ni réflexion, ni configuration complexe. Contrairement à Dagger ou Spring, Koin utilise un DSL simple et s'intègre parfaitement avec les coroutines et Flow. Sur cette page, nous verrons comment installer Koin, déclarer des modules, injecter des dépendances et l'utiliser dans des projets éducatifs.

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

L'injection de dépendances (DI) est un modèle dans lequel un objet reçoit ses dépendances de l'extérieur, plutôt que de les créer lui-même. Cela simplifie les tests, rend le code plus flexible et réduit le couplage. Koin implémente la DI via un conteneur qui gère la création et le cycle de vie des objets.

Installation de Koin

Ajoutez la dépendance suivante dans le fichier build.gradle.kts :

// build.gradle.ktsdependencies {    implementation("io.insert-koin:koin-core:3.5.3")    // Pour Android    implementation("io.insert-koin:koin-android:3.5.3")}

Concepts clés de Koin

• Module (module) — bloc dans lequel les dépendances sont déclarées.
• Définition (definition) — manière de créer un objet (single, factory, scoped).
• Conteneur (KoinApplication) — démarre et gère les modules.
• Injection (inject) — obtention d'une dépendance via des délégations ou des fonctions.

Création de modules et déclaration de dépendances

Koin utilise un DSL pour décrire les modules. Prenons un exemple avec un repository et un service :

// Définition de l'interface et de l'implémentationinterface UserRepository {    fun getUser(id: Int): String}

class UserRepositoryImpl : UserRepository {    override fun getUser(id: Int) = "User #$id"}

class UserService(private val repository: UserRepository) {    fun printUser(id: Int) {        println(repository.getUser(id))    }}

// Module Koinval appModule = module {    // single — crée une seule instance (singleton)    single<UserRepository> { UserRepositoryImpl() }    // factory — crée une nouvelle instance à chaque demande    factory { UserService(get()) }}

Démarrage du conteneur

Avant d'utiliser les dépendances, il faut démarrer Koin :

import org.koin.core.context.startKoin

fun main() {    startKoin {        modules(appModule)    }    // On peut maintenant obtenir les dépendances    val service: UserService by inject()    service.printUser(42)}

Méthodes d'injection de dépendances

• by inject() — obtention paresseuse (recommandée).
• get() — obtention immédiate.
• Constructeur — Koin transmet automatiquement les dépendances au constructeur.

Exemple avec by inject() :

class MyActivity : AppCompatActivity() {    // Injection paresseuse    private val repository: UserRepository by inject()        override fun onCreate(savedInstanceState: Bundle?) {        super.onCreate(savedInstanceState)        // Utilisation du repository    }}

Dépendances scopées

Il est parfois nécessaire de créer une dépendance qui vit dans un contexte spécifique (par exemple, une session utilisateur). Pour cela, on utilise scope :

val sessionModule = module {    scope<UserSession> {        scoped { UserSessionManager(get()) }    }}

Utilisation avec les coroutines

Koin prend en charge les coroutines via le module koin-core-coroutines. Exemple d'obtention asynchrone :

import org.koin.core.component.KoinComponentimport org.koin.core.component.inject