Dependency Injection trên Android: Hilt vs Koin - Hướng dẫn Toàn diện và Câu hỏi Phỏng vấn 2026

Dependency injection xác định cách một class nhận các dependency của mình thay vì tự tạo trực tiếp. Trong hệ sinh thái Android năm 2026, hai framework chiếm ưu thế: Hilt (giải pháp compile-time của Google xây dựng trên Dagger) phiên bản 2.57.1, và Koin (service locator nhẹ hoạt động tại runtime) phiên bản 4.2.1. Việc lựa chọn framework phù hợp ảnh hưởng đến thời gian build, hiệu năng khởi động, khả năng kiểm thử và tốc độ onboarding thành viên mới trong team.

Cơ chế Hoạt động của Hilt

Hilt sinh ra các component Dagger được ánh xạ tới các class lifecycle Android. Annotation @HiltAndroidApp kích hoạt code generation tại thời điểm biên dịch, tạo ra factory và provider cho mỗi binding được khai báo. KSP (Kotlin Symbol Processing) đã thay thế KAPT làm annotation processor được khuyến nghị kể từ Hilt 2.48, giảm thời gian xử lý annotation xuống khoảng một nửa.

Một cấu hình Hilt điển hình gồm ba phần: module khai báo binding, entry point (Activity, Fragment hoặc ViewModel) và class Application được đánh dấu @HiltAndroidApp.

@Module
@InstallIn(SingletonComponent::class)
object AppModule {

    @Provides
    @Singleton
    fun provideRetrofit(): Retrofit {
        return Retrofit.Builder()
            .baseUrl("https://api.example.com/")
            .addConverterFactory(GsonConverterFactory.create())
            .build()
    }

    @Provides
    @Singleton
    fun provideUserRepository(
        retrofit: Retrofit
    ): UserRepository {
        return UserRepositoryImpl(retrofit.create(UserApi::class.java))
    }
}

@HiltViewModel
class UserViewModel @Inject constructor(
    private val userRepository: UserRepository
) : ViewModel() {

    private val _users = MutableStateFlow<List<User>>(emptyList())
    val users: StateFlow<List<User>> = _users.asStateFlow()

    fun loadUsers() {
        viewModelScope.launch {
            _users.value = userRepository.getUsers()
        }
    }
}

Compiler xác minh rằng UserRepository có provider hợp lệ trước khi ứng dụng chạy. Binding bị thiếu sẽ xuất hiện dưới dạng build error chứ không phải runtime crash.

Thiết lập Koin với Kotlin DSL

Koin áp dụng cách tiếp cận ngược lại: không code generation, không annotation processing. Dependency được khai báo bằng Kotlin thuần túy thông qua DSL, và framework phân giải chúng tại runtime qua một service registry toàn cục. Koin 4.2 giới thiệu lazy modules cho phép tải song song khi khởi động, cùng engine CoreResolverV2 mới tối ưu hóa quá trình phân giải scope.

val appModule = module {
    // Instance Retrofit singleton
    single<Retrofit> {
        Retrofit.Builder()
            .baseUrl("https://api.example.com/")
            .addConverterFactory(GsonConverterFactory.create())
            .build()
    }

    // Repository singleton liên kết với interface
    single<UserRepository> {
        UserRepositoryImpl(get<Retrofit>().create(UserApi::class.java))
    }

    // ViewModel với repository được inject
    viewModel { UserViewModel(get()) }
}

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        startKoin {
            androidContext(this@MyApplication)
            modules(appModule)
        }
    }
}

DSL Koin dễ đọc một cách tự nhiên và không yêu cầu plugin annotation processing trong cấu hình Gradle. Đánh đổi là: lỗi đánh máy trong phân giải get() chỉ xuất hiện tại runtime khi điểm injection đó được thực thi.

Benchmark Hiệu năng: Thời gian Build vs Chi phí Runtime

Câu hỏi về hiệu năng gần như luôn xuất hiện trong mỗi buổi phỏng vấn Android. Số liệu cụ thể có giá trị hơn nhận định chủ quan.

| Chỉ số | Hilt 2.57 (KSP) | Koin 4.2 | |--------|-----------------|----------| | Overhead clean build | +8-15 giây (KSP code generation) | ~0 giây (không code generation) | | Overhead incremental build | +2-4 giây | ~0 giây | | Khởi động ứng dụng (50 binding) | ~0 ms (code được sinh sẵn) | ~5-15 ms (phân giải graph) | | Khởi động ứng dụng (500 binding) | ~0 ms | ~30-80 ms | | Ảnh hưởng kích thước APK | +200-400 KB (generated code) | +100 KB (runtime library) | | Phát hiện binding thiếu | Lỗi biên dịch | Crash runtime |

Với dự án dưới 100 binding, overhead runtime của Koin hầu như không thể cảm nhận. Trên 300 binding, chi phí khởi động trở nên đáng kể, dù lazy modules trong Koin 4.2 giảm thiểu vấn đề này bằng cách tải module song song.

Chiến lược Kiểm thử cho Từng Framework

Khả năng kiểm thử là nơi sự khác biệt kiến trúc trở nên thực tiễn nhất. Hilt cung cấp @TestInstallIn để thay thế module production bằng test double tại thời điểm biên dịch. Koin cung cấp loadKoinModules() để ghi đè định nghĩa tại runtime.

// Module test Hilt — thay thế binding AppModule trong test
@Module
@TestInstallIn(
    components = [SingletonComponent::class],
    replaces = [AppModule::class]
)
object FakeAppModule {

    @Provides
    @Singleton
    fun provideUserRepository(): UserRepository {
        return FakeUserRepository() // Test double trong bộ nhớ
    }
}

// Test Koin — ghi đè tại runtime
class UserViewModelTest : KoinTest {

    @Before
    fun setUp() {
        startKoin {
            modules(
                module {
                    single<UserRepository> { FakeUserRepository() }
                    viewModel { UserViewModel(get()) }
                }
            )
        }
    }

    @Test
    fun `loads users from repository`() {
        val viewModel: UserViewModel = get()
        viewModel.loadUsers()
        assertEquals(3, viewModel.users.value.size)
    }

    @After
    fun tearDown() {
        stopKoin()
    }
}

Test Hilt phát hiện lỗi cấu hình test module ngay tại thời điểm biên dịch. Test Koin đòi hỏi quản lý lifecycle cẩn thận (startKoin/stopKoin) nhưng linh hoạt hơn trong việc ghi đè từng phần module.

Kiến trúc Multi-Module: Mở rộng DI Xuyên suốt Các Tính năng

Các dự án Android quy mô lớn chia tính năng thành nhiều Gradle module riêng biệt. Framework DI cần hỗ trợ ranh giới giữa các module một cách rõ ràng.

Với Hilt, mỗi feature module khai báo @Module riêng kèm annotation @InstallIn. Hilt hợp nhất tất cả module thành một hệ thống phân cấp component duy nhất tại thời điểm biên dịch. Kiến trúc MVVM kết hợp tự nhiên với scoped component của Hilt.

@Module
@InstallIn(ViewModelComponent::class)
object PaymentModule {

    @Provides
    fun providePaymentGateway(
        retrofit: Retrofit // Được cung cấp bởi module :app
    ): PaymentGateway {
        return StripePaymentGateway(retrofit.create(PaymentApi::class.java))
    }
}

Với Koin, feature module xuất khai báo module {} của mình, và app module tải tất cả khi khởi động. Lazy modules trong Koin 4.2 cho phép trì hoãn việc tải feature module cho đến lần truy cập đầu tiên.

val paymentModule = module {
    factory<PaymentGateway> {
        StripePaymentGateway(get<Retrofit>().create(PaymentApi::class.java))
    }
}

// app/MyApplication.kt — tải tất cả feature module
startKoin {
    modules(appModule, paymentModule, analyticsModule)
}

Hilt kiểm soát khả năng truy cập dependency thông qua component scope. Koin dựa vào quy ước — bất kỳ module nào cũng có thể truy cập định nghĩa của module khác, mang lại sự linh hoạt nhưng có thể dẫn đến coupling ngầm.

Cân nhắc về Kotlin Multiplatform

Koin hỗ trợ Kotlin Multiplatform (KMP) một cách tự nhiên. Cùng một DSL module {} hoạt động trên Android, iOS, Desktop và Web target. Hilt chỉ dành cho Android — nó phụ thuộc vào các component lifecycle đặc thù Android và annotation processor Dagger.

Đối với các dự án nhắm đến nhiều nền tảng, Koin là lựa chọn khả thi duy nhất giữa hai framework. Các module business logic dùng chung có thể khai báo dependency một lần và inject chúng trên tất cả các target.

Câu hỏi Phỏng vấn Thường gặp về DI Android

Những câu hỏi dưới đây thường xuyên xuất hiện trong các buổi phỏng vấn kỹ thuật Android. Mỗi câu trả lời được trình bày ngắn gọn và tập trung vào những gì nhà tuyển dụng mong đợi.

H: Sự khác biệt giữa dependency injection compile-time và runtime là gì?

Compile-time DI (Hilt/Dagger) sinh code injection trong quá trình build. Compiler xác thực toàn bộ dependency graph, phát hiện binding thiếu trước runtime. Runtime DI (Koin) phân giải dependency khi chúng được yêu cầu lần đầu, sử dụng mô hình service registry. Compile-time DI cho khởi động nhanh hơn nhưng build chậm hơn; runtime DI không tốn thêm thời gian build nhưng trì hoãn việc phát hiện lỗi.

H: Các scope component của Hilt gồm những gì và ánh xạ với lifecycle Android như thế nào?

SingletonComponent tồn tại suốt vòng đời ứng dụng. ActivityRetainedComponent tồn tại qua các thay đổi cấu hình. ViewModelComponent có scope theo lifecycle của ViewModel. ActivityComponent, FragmentComponent và ViewComponent tuân theo lifecycle owner Android tương ứng. Có thể tạo custom scope để mở rộng hệ thống phân cấp này.

H: Koin xử lý việc inject ViewModel trong Jetpack Compose như thế nào?

Koin cung cấp koinViewModel() dưới dạng hàm Composable, tạo hoặc truy xuất ViewModel có scope theo ViewModelStoreOwner gần nhất. Từ Koin 4.2, koinNavViewModel() cho phép scope ViewModel theo các entry trong navigation graph khi sử dụng điều hướng Jetpack Compose.

H: Khi nào Koin là lựa chọn tốt hơn Hilt?

Koin phù hợp hơn cho các dự án KMP (Hilt chỉ dành cho Android), ứng dụng vừa và nhỏ nơi thời gian build quan trọng hơn thời gian khởi động, và các team ưa thích DSL Kotlin tường minh hơn cấu hình dựa trên annotation. Các dự án prototyping và proof-of-concept cũng hưởng lợi từ việc thiết lập Koin tối giản.

Khung Quyết định: Chọn giữa Hilt và Koin

| Yếu tố | Hilt | Koin | |---------|------|------| | Xác thực graph | Compile-time | Runtime | | Ảnh hưởng thời gian build | Cao hơn (KSP codegen) | Không ảnh hưởng | | Chi phí khởi động | Gần bằng không | Tỷ lệ thuận với kích thước graph | | Độ dốc học tập | Cao hơn (khái niệm Dagger) | Thấp (Kotlin DSL thuần túy) | | Hỗ trợ KMP | Không | Có | | Tích hợp Jetpack | Sâu (chính thức từ Google) | Tốt (cộng đồng) | | Khả năng mở rộng team | Mạnh hơn (scope được kiểm soát) | Linh hoạt (dựa trên quy ước) | | Kiểm thử | @TestInstallIn (compile-safe) | loadKoinModules (runtime) |

Không có framework nào vượt trội tuyệt đối. Sự lựa chọn phụ thuộc vào quy mô dự án, kinh nghiệm team và nền tảng mục tiêu.

Kết luận

• Hilt 2.57 với KSP cung cấp xác thực dependency graph tại thời điểm biên dịch và chi phí khởi động gần bằng không, trở thành lựa chọn vững chắc hơn cho các dự án Android đơn nền tảng quy mô lớn với yêu cầu độ tin cậy cao
• Koin 4.2 với lazy modules và CoreResolverV2 thu hẹp khoảng cách hiệu năng khởi động trong khi duy trì không có overhead build và tương thích đầy đủ với KMP
• Cả hai framework đều hỗ trợ kiến trúc multi-module, nhưng Hilt kiểm soát ranh giới scope tại thời điểm biên dịch còn Koin dựa vào quy ước của team
• Để chuẩn bị phỏng vấn Android, việc hiểu sự đánh đổi compile-time vs runtime cùng khả năng trình bày rõ ràng khi nào mỗi framework phù hợp là nền tảng được kỳ vọng
• Chuyển đổi giữa hai framework không đơn giản — lựa chọn ban đầu cần tính đến lộ trình nền tảng và khả năng mở rộng dài hạn của dự án