PricingLoginStart free
Kotlin Academy · leksjon

Dependency Injection i KMP med Koin

Koble sammen delte moduler med Koin i et multiplattformoppsett.

Leksjon 4 av 414 trinn

Dependency Injection i KMP med Koin er en gratis leksjon i Kotlin Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Kotlin Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Kotlin Academy inneholder totalt 4 leksjoner.

Hvorfor DI i KMP?

Dependency Injection kobler opprettelsen av komponenter fra bruken av dem. I KMP er Koin det foretrukne DI-rammeverket fordi det er ren Kotlin og fungerer i commonMain uten annotasjonsprosessorer.

// No annotation processing needed — Koin uses lambda DSL
// Add to build.gradle.kts:
// implementation("io.insert-koin:koin-core:3.5.0")
// androidMain: koin-android
// iosMain: no extra dep
fun main() { println("Koin works on all KMP targets") }

Koin-modulens DSL

Definer bindinger i en module { }-blokk ved hjelp av single, factory eller scoped.

import org.koin.core.module.dsl.*
import org.koin.dsl.*
val appModule = module {
    single { HttpClient() }               // one instance
    single<UserRepository> { RemoteUserRepository(get()) }
    factory { GetUserUseCase(get()) }      // new instance each time
}

Delt modul i commonMain

Definer en delt Koin-modul i commonMain. Plattformmoduler utvider den med plattformspesifikke bindinger.

// commonMain/di/SharedModule.kt
import org.koin.dsl.module
fun sharedModule() = module {
    single<UserRepository> { RemoteUserRepository(get()) }
    single { GetUserUseCase(get()) }
    single { UserViewModel(get()) }
}

Plattformmodul i androidMain

Plattformmoduler leverer den faktiske HTTP-motoren, database-driveren og Android-spesifikke singletoner.

// androidMain/di/AndroidModule.kt
import io.ktor.client.engine.okhttp.*
import org.koin.dsl.module
fun androidModule() = module {
    single { OkHttp.create() }    // Ktor engine
    single { createHttpClient(get()) }
    includes(sharedModule())
}

startKoin i Android-applikasjonen

Kall startKoin { } i Android-Application.onCreate. Bruk androidContext(this) for å gjøre konteksten tilgjengelig.

// androidMain:
import org.koin.android.ext.koin.androidContext
import org.koin.core.context.startKoin
// In Application.onCreate():
startKoin {
    androidContext(this@MyApp)
    modules(androidModule())
}

Starte Koin på iOS

På iOS kaller du KoinApplication.start() fra Swift-AppDelegate eller App-strukturen, og sender med de delte Koin-modulene.

// iosMain/KoinInit.kt:
import org.koin.core.context.startKoin
fun initKoin() {
    startKoin {
        modules(iosModule())
    }
}
// Swift: KoinInitKt.doInitKoin() in AppDelegate

Løse avhengigheter

I ViewModels eller use cases i commonMain bruker du get() i en modul eller inject() / getKoin().get() på kallsteder.

import org.koin.core.component.KoinComponent
import org.koin.core.component.inject
class UserViewModel : KoinComponent {
    private val getUser: GetUserUseCase by inject()
    fun load(id: String) = runBlocking { getUser(id) }
}

Koin-scope for ViewModels

Bruk viewModel { } i Android-modulen for Android-ViewModels, eller den plattformuavhengige factory { } for delte ViewModels.

// androidMain (with koin-android):
import org.koin.androidx.viewmodel.dsl.viewModel
val androidVmModule = module {
    viewModel { UserViewModel(get()) }
}
// In Compose:
// val vm: UserViewModel = koinViewModel()

Testing med Koin

Bruk startKoin i testoppsettet med en testmodul som erstatter ekte avhengigheter med falske implementasjoner.

import org.koin.core.context.startKoin
import org.koin.core.context.stopKoin
import org.koin.dsl.module
class UserViewModelTest {
    @BeforeTest fun setup() {
        startKoin { modules(module {
            single<UserRepository> { FakeUserRepository() }
            single { GetUserUseCase(get()) }
        })}
    }
    @AfterTest fun teardown() = stopKoin()
}

Single kontra Factory kontra Scoped

single: én instans så lenge appen lever. factory: en ny instans for hver get(). scoped: én instans per Koin-scope (for eksempel et skjermscope).

import org.koin.dsl.module
val lifetimeModule = module {
    single { Database() }           // shared, one instance
    factory { Analytics() }         // new on each get()
    scope<ScreenScope> {
        scoped { ScreenViewModel() } // one per screen lifecycle
    }
}

Koin kontra manuell DI kontra Hilt

Koin: multiplattform, ingen KSP/KAPT, DI ved kjøring. Hilt: bare for Android, ved kompilering, annotasjonsdrevet. Manuell DI: maksimal kontroll uten kostnadene ved et rammeverk. KMP-prosjekter bruker Koin for å dele kode.

fun main() {
    // Koin  : commonMain, runtime, lambda DSL
    // Hilt  : androidMain only, compile-time
    // Manual: no framework, explicit wiring in factory/module files
    println("Choose Koin for KMP; Hilt for Android-only projects")
}

Lat injeksjon med by inject()

by inject() løser en avhengighet først ved første tilgang – nyttig i klasser som implementerer KoinComponent.

import org.koin.core.component.KoinComponent
import org.koin.core.component.inject
class AppService : KoinComponent {
    private val repo: UserRepository by inject()  // resolved on first use
    fun doWork() = println(repo.javaClass.simpleName)
}

Rask kontroll

Hvilket Koin-scope oppretter en ny instans hver gang get() kalles?

Besvar den i den interaktive leksjonen

Oppsummering

Koin bruker en lambda-DSL uten annotasjonsbehandling – ideelt for KMP. Definer delte moduler i commonMain og plattformmoduler i plattformenes kildesett. Bruk single for singletoner, factory for nye instanser og by inject() for lat oppløsning.

Gratis å komme i gang

Lær deg Kotlin med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
51
Leksjoner
203
Start læringen gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «Dependency Injection i KMP med Koin» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Kotlin Academy, inkludert «Dependency Injection i KMP med Koin», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Kotlin Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Dependency Injection i KMP med Koin»?

Koble sammen delte moduler med Koin i et multiplattformoppsett. Du øver på Kotlin Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Kotlin Academy?

Ingen tidligere erfaring er nødvendig. Kotlin Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Dependency Injection i KMP med Koin»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Kotlin Academy-leksjonen?

Ja. Alle Kotlin Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. KMP-prosjektstruktur: commonMain, androidMain, iosMain
  2. expect/actual-mekanismen for plattform-API-er
  3. Dele repository- og use case-lag
  4. Dependency Injection i KMP med Koin
← Tilbake til Kotlin Academy