Koin — какво е, принципи на Dependency Injection и как работи

Какво е Koin и с какво се различава

Koin — DI рамка за Kotlin, написана на чист език без използване на рефлексия, анотации или генериране на код. За разлика от Dagger Hilt, който изисква процесор за анотации и генериране на код по време на компилация, Koin работи изключително по време на изпълнение, използвайки лек DSL за описване на модули.

Основната идея на Koin е да предостави прост API за регистриране и разрешаване на зависимости без необходимост от изучаване на сложни концепции за графи на зависимости и дървета на компоненти. Разработчикът описва кои класове са достъпни за контейнера, а Koin ги инжектира автоматично чрез конструктора или мързеливи делегати by inject. Рамката е напълно съвместима с Kotlin Multiplatform, позволявайки единен DI подход на Android, iOS и сървърната страна.

Според проучване на Kotlin Developers Community (2025), Koin се използва в 31% от търговските Android проекти, като по популярност отстъпва само на Hilt (47%). Основната причина за избора е простотата на конфигурация и липсата на необходимост от генериране на код, което ускорява изграждането на проекта.

Изберете Koin за средни и големи проекти, където бързото стартиране на разработката е важно, или за Kotlin Multiplatform решения, където Hilt не е наличен по архитектурни причини.

Koin не използва рефлексия и генериране на код — всички регистрации се основават на inline функции с reified типове, които по време на компилация заместват конкретния тип в тялото на функцията. Това прави Koin една от най-леките DI рамки по отношение на размера на крайния APK: добавянето на Koin увеличава размера на приложението само със 100–150 KB, докато Dagger Hilt добавя около 500 KB поради генерирания код.

Как работят контейнерът и DSL на Koin

Контейнерът Koin се инициализира чрез функцията startKoin, която приема ламбда с конфигурация. Вътре в тази ламбда се описват модули с регистрации — основният градивен елемент на DI логиката.

startKoin и модули

Функцията startKoin създава глобален контейнер, достъпен от всяка точка на приложението чрез GlobalContext, но в мултимодулни проекти се препоръчва използването на KoinApplication за създаване на изолирани контейнери. В Android за инициализация се използва AndroidContext, който автоматично се свързва с жизнения цикъл на Application. Модулите се регистрират чрез параметъра modules, който приема списък от инстанции на Module.

val networkModule = module {
    single {
        OkHttpClient()
    }
    single {
        Retrofit.Builder()
            .baseUrl("https://api.example.com")
            .build()
    }
}

startKoin {
    modules(networkModule)
}

Всеки модул съдържа дефиниции чрез single (сингълтън) или factory (нов екземпляр). Дефинициите могат да се позовават на други регистрирани зависимости чрез get(), формирайки граф на инжектиране без изрично посочване на типове и без boilerplate код.

DSL и inline функции

Koin активно използва inline функции с reified параметри за извеждане на тип от контекста. Това позволява писане на регистрации без изрично посочване на клас: single { MyService() } автоматично определя типа въз основа на върнатата стойност на ламбдата.

За разлика от Dagger, Koin не проверява графа на зависимости по време на компилация — всички грешки се откриват по време на изпълнение при първия достъп до неразрешена зависимост. Това е компромис, който значително опростява кода и ускорява изграждането, но изисква тестово покритие на DI конфигурацията.

Във версия Koin 3.5 се появи експериментална проверка на графа по време на компилация чрез плъгина Koin Annotations. Основното предимство на Koin — липсата на генериране на код — обаче се губи в този режим, затова повечето екипи продължават да използват класическия DSL подход с проверки по време на изпълнение чрез тестове.

Начини за инжектиране на зависимости в Koin

Koin предоставя няколко начина за инжектиране на зависимости: by inject(), get() и директно предаване чрез конструктор. Изборът на начин зависи от контекста на използване.

by inject() — мързеливо инжектиране

Делегатът by inject — най-честият начин за инжектиране в ViewModel и Android фрагменти. Зависимостта се инициализира мързеливо — само при първия достъп до свойството.

class MainViewModel : ViewModel() {
    private val repository: UserRepository by inject()

    fun loadUsers() {
        repository.fetchAll()
    }
}

get() — изрично получаване

Функцията get връща екземпляра на зависимостта незабавно. За разлика от by inject(), get() не поддържа мързеливо зареждане и изисква контейнерът вече да е инициализиран към момента на извикването.

Модули и скоупове в Koin

Scope в Koin — механизъм за свързване на жизнения цикъл на зависимостите с конкретен компонент, като Activity, Fragment или потребителска сесия.

scope — свързване с компонент

Функцията scope вътре в модул създава скоуп, който живее докато живее свързаният компонент. Всички зависимости, регистрирани в скоупа, се унищожават при затварянето му, предотвратявайки изтичане на памет.

val userScope = module {
    scope<UserSession> {
        scoped {
            UserRepository(get())
        }
        scoped {
            SessionManager(get())
        }
    }
}

Функцията scoped регистрира зависимост, която ще съществува само вътре в скоупа.

single vs factory

single — регистрация на един екземпляр за цялото приложение с мързелива инициализация. factory — всяко извикване на get() създава нов екземпляр, използва се за ViewModel, хранилища и обекти със състояние.

Koin в Android проекти

Интеграцията на Koin в Android проект е минимална: просто добавете зависимостта в build.gradle и извикайте startKoin в Application.onCreate. Koin предоставя модули за интеграция с Jetpack Compose, Navigation и WorkManager.

Специалната библиотека koin-android-compose позволява директно инжектиране на зависимости в Composable функции чрез koinViewModel() и koinInject().

Според Google I/O 2024, Jetpack Compose се превърна в основната рамка за нови Android проекти. Koin предоставя естествена поддръжка на Compose без допълнителна конфигурация.

За тестване Koin предоставя функциите koinTest и koinTestRule, които създават изолиран тестов контейнер с тестови модули. Интеграцията с Jetpack Navigation се осъществява чрез модула koin-androidx-navigation.

За единично тестване на ViewModel с Koin се използва koinTestRule от библиотеката koin-test-junit5 или koin-test-junit4. Реалните зависимости се заменят с мокове чрез MockK.

Една от ключовите възможности на Koin 3.x е поддръжката на Ktor за създаване на сървърни приложения в Kotlin и Compose Multiplatform за десктоп приложения. Това прави Koin единствената DI рамка, покриваща и трите Kotlin платформи без промяна на парадигмата на инжектиране.

За мултимодулни проекти Koin поддържа мързеливо зареждане на модули чрез loadKoinModules, което позволява независимо свързване на DI конфигурацията на всеки feature модул.