В чем разница между Dagger и Koin?

Dagger vs Koin: различия DI фреймворков

Dagger и Koin — это два популярных фреймворка для управления зависимостями (Dependency Injection) в Android. Они решают одну задачу, но совершенно разными способами.

Dagger

Dagger — это фреймворк для compile-time DI (зависимости разрешаются на этапе компиляции).

Как это работает

// Определение модуля
@Module
class AppModule {
    @Provides
    @Singleton
    fun provideUserRepository(): UserRepository {
        return UserRepositoryImpl()
    }
    
    @Provides
    fun provideUserService(repo: UserRepository): UserService {
        return UserService(repo)
    }
}

// Компонент
@Singleton
@Component(modules = [AppModule::class])
interface AppComponent {
    fun inject(activity: MainActivity)
}

// Использование
class MainActivity : AppCompatActivity() {
    @Inject
    lateinit var userService: UserService
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        DaggerAppComponent.create().inject(this)
        // userService готов к использованию
    }
}

Ключевые характеристики:

• Compile-time зависимости — весь граф зависимостей создаётся во время компиляции
• Проверка типов — ошибки видны сразу во время компиляции
• Генерация кода — Dagger создаёт java-файлы с injectors и providers
• Производительность — нулевые runtime overhead

Плюсы Dagger

✓ Быстрый — никакой рефлексии, чистый Java код
✓ Безопасный — ошибки на compile-time, не runtime
✓ IDE поддержка — прыгание по коду, рефакторинг работает идеально
✓ Отлично для больших проектов — граф зависимостей явный
✓ Проверка циклических зависимостей — на compile-time

Минусы Dagger

✗ Крутая кривая обучения — сложный синтаксис и концепции
✗ Много boilerplate кода — @Module, @Component, @Provides
✗ Время компиляции — долгая генерация кода
✗ Сложная отладка — generated-code понимать сложновато

Koin

Koin — это фреймворк для runtime DI (зависимости разрешаются во время выполнения).

Как это работает

// Определение модуля (DSL синтаксис)
val appModule = module {
    single<UserRepository> { UserRepositoryImpl() }  // Singleton
    factory { UserService(get()) }  // Factory: новый экземпляр каждый раз
    factory { UserViewModel(get()) }
}

// Инициализация (обычно в Application)
class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        startKoin {
            androidLogger()
            androidContext(this@MyApp)
            modules(appModule)
        }
    }
}

// Использование
class MainActivity : AppCompatActivity() {
    private val userService: UserService by inject()
    private val viewModel: UserViewModel by viewModel()
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // userService и viewModel автоматически injected
    }
}

Ключевые характеристики:

• Runtime зависимости — граф зависимостей строится во время выполнения
• Никакой генерации кода — используется рефлексия иServiceLocator паттерн
• DSL синтаксис — простой и понятный API
• Kotlin-first — создан специально для Kotlin

Плюсы Koin

✓ Простой синтаксис — DSL легко понять даже новичку
✓ Быстрое написание — меньше boilerplate
✓ Быстрая компиляция — нет генерации кода
✓ Flexibility — легко менять конфигурацию runtime-ом
✓ Хороший для малых/средних проектов — не усложняет архитектуру
✓ Встроенная поддержка ViewModel — by viewModel()

Минусы Koin

✗ Runtime ошибки — проблемы с DI видны только во время выполнения
✗ Медленнее Dagger — рефлексия стоит времени
✗ Нет IDE поддержки — не видно незарегистрированные зависимости
✗ Service Locator паттерн — не очень clean, зависит от глобального состояния
✗ Циклические зависимости — видишь только на runtime

Сравнительная таблица

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

Выбирай Dagger если:

• Большой проект (100+ экранов, сложная архитектура)
• Команда опытная (знают паттерны DI)
• Performance критичен (нужна максимальная скорость)
• Хочешь catch ошибок на compile-time
• IDE поддержка важна

Выбирай Koin если:

• Стартап или MVP (надо быстро писать)
• Команда новичков (нужен простой синтаксис)
• Небольшой до среднего проект
• Runtime flexibility нужен
• Хочешь минимум boilerplate

Практический пример с обоими

Dagger:

@Singleton
@Component(modules = [NetworkModule::class, RepositoryModule::class])
interface AppComponent {
    fun inject(activity: MainActivity)
}

Koin:

val appModule = module {
    single { Retrofit.Builder().build().create(ApiService::class.java) }
    single<UserRepository> { UserRepositoryImpl(get()) }
}

Заключение

Dagger — это профессиональный инструмент для больших, сложных приложений. Требует понимания паттернов DI, но гарантирует safety и performance.

Koin — это прагматичный инструмент для быстрой разработки. Легче учится и использовать, но требует дополнительной осторожности с ошибками runtime.

В реальных проектах часто видишь Dagger в больших компаниях (Google, Uber, Yandex), а Koin — в стартапах и индивидуальных проектах.