Dependency Injection в Kotlin: простое руководство для новичков

Онлайн-тренажер Python для начинающих

Изучайте Python легко и без перегрузки теорией. Решайте практические задачи с автоматической проверкой, получайте подсказки на русском языке и пишите код прямо в браузере — без необходимости что-либо устанавливать.

Начать курс

Введение: что такое Dependency Injection и зачем он нужен?

Представьте, что вы строите дом. Вам нужны кирпичи, цемент и инструменты. Вместо того чтобы каждый раз бежать на склад за ними, вы просто заказываете доставку всех материалов на стройплощадку. Dependency Injection (DI) или внедрение зависимостей — это тот же принцип, но для вашего кода.

Dependency Injection — это паттерн проектирования, при котором объект получает свои зависимости извне, а не создает их сам. Это делает код более гибким, тестируемым и легким для поддержки. В этой статье мы разберем DI на примере Kotlin — современного языка программирования, который отлично подходит для освоения этого паттерна.

Проблема: почему без DI код становится хрупким?

Рассмотрим типичный пример. Допустим, у нас есть класс UserService, который отправляет email-уведомления. Без DI он выглядит так:

class EmailService {
    fun sendEmail(to: String, message: String) {
        println("Отправка email на $to: $message")
    }
}

class UserService {
    private val emailService = EmailService() // Жесткая связь!

    fun notifyUser(email: String) {
        emailService.sendEmail(email, "Привет, пользователь!")
    }
}

В чем проблема? UserService жестко привязан к конкретной реализации EmailService. Если вы захотите:

Заменить EmailService на SmsService;
Добавить логирование;
Написать юнит-тесты с мок-объектом,

— вам придется менять код UserService. Это нарушает принцип Open/Closed (открытости/закрытости) и усложняет тестирование.

Решение: ручное внедрение зависимостей в Kotlin

Самый простой способ реализовать DI — передать зависимость через конструктор. В Kotlin это делается очень лаконично:

// 1. Создаем интерфейс (абстракцию)
interface NotificationService {
    fun send(to: String, message: String)
}

// 2. Реализуем конкретные сервисы
class EmailService : NotificationService {
    override fun send(to: String, message: String) {
        println("Email на $to: $message")
    }
}

class SmsService : NotificationService {
    override fun send(to: String, message: String) {
        println("SMS на $to: $message")
    }
}

// 3. Внедряем зависимость через конструктор
class UserService(private val notificationService: NotificationService) {
    fun notifyUser(email: String) {
        notificationService.send(email, "Привет!")
    }
}

// 4. Использование
fun main() {
    val emailService = EmailService()
    val userService = UserService(emailService) // Внедрение!
    userService.notifyUser("user@example.com")
}

Преимущества такого подхода:

Гибкость: можно легко подменить EmailService на SmsService;
Тестируемость: в тестах вы можете передать мок-объект:

class MockNotificationService : NotificationService {
    var lastMessage: String? = null
    override fun send(to: String, message: String) {
        lastMessage = message
    }
}

fun test() {
    val mock = MockNotificationService()
    val userService = UserService(mock)
    userService.notifyUser("test@test.com")
    assert(mock.lastMessage == "Привет!")
}

DI-фреймворки: Koin и Dagger для Kotlin

При ручном DI, если проект большой, вы пишете много шаблонного кода. Тут на помощь приходят DI-фреймворки. В мире Kotlin популярны два: Koin (простой) и Dagger/Hilt (мощный).

Koin: простота и скорость

Koin — это легковесный DI-фреймворк, написанный на Kotlin. Он не требует генерации кода и использует DSL (Domain Specific Language).

// 1. Добавьте зависимость в build.gradle.kts:
// implementation("io.insert-koin:koin-core:3.5.0")

// 2. Определите модуль
val appModule = module {
    single<NotificationService> { EmailService() }
    factory { UserService(get()) } // get() автоматически внедряет зависимость
}

// 3. Запустите Koin
fun main() {
    startKoin {
        modules(appModule)
    }

    // 4. Получите объект
    val userService: UserService by inject()
    userService.notifyUser("user@koin.com")
}

Ключевые особенности:

single — создает один экземпляр (синглтон);
factory — создает новый экземпляр каждый раз;
get() — автоматически разрешает зависимости.

Dagger / Hilt: производительность и строгость

Dagger генерирует код на этапе компиляции, что делает его очень быстрым. Hilt — это надстройка над Dagger для Android, но в обычном Kotlin-проекте можно использовать чистый Dagger.

// 1. Добавьте плагин и зависимость (через Gradle)
// 2. Создайте компонент
@Component
interface AppComponent {
    fun getUserService(): UserService
}

// 3. Аннотируйте конструктор
class UserService @Inject constructor(
    private val notificationService: NotificationService
) { ... }

// 4. Использование
fun main() {
    val component = DaggerAppComponent.create()
    val userService = component.getUserService()
}

Когда что выбирать?

Koin — для небольших и средних проектов, где важна простота;
Dagger/Hilt — для крупных проектов, где критична производительность и строгая проверка типов на этапе компиляции.