Dependency Injection trong Android: So Sánh Hilt, Koin và Dagger

Trong một app Android đã lớn, thứ ngốn thời gian không phải viết màn hình mới, mà là trả lời ba câu: instance này tạo ở đâu, sống bao lâu, ai giải phóng nó. Dependency Injection (DI) gom ba câu trả lời vào một chỗ. Bài này so sánh Hilt 2.60.1, Koin, Dagger và manual DI, kèm code chạy được.

Điểm dễ hiểu nhầm: Hilt không đối đầu với Dagger. Hilt là bộ khuôn Google bọc quanh Dagger cho Android, Dagger là engine sinh code bên dưới. Koin ở trục khác: không sinh code, phân giải lúc chạy. Chọn thư viện là chọn loại lỗi bạn muốn bắt sớm.

Cập nhật 2026: những gì đã đổi

  • Hilt 2.60.1 (2026-07-06) vẫn là wrapper chính thức của Dagger cho Android; Dagger cùng version nằm dưới.
  • KSP2 là processor được hỗ trợ cho Hilt, Room, Moshi. KAPT chỉ còn legacy: chậm, sinh stub javac, không còn là đường mặc định.
  • Toolchain hiện tại: Kotlin 2.4.21, AGP 9.5, Gradle 9.9; Hilt chạy KSP trong cùng vòng biên dịch.
  • ViewModel vẫn giữ state của màn hình Compose 1.12.1: Hilt inject qua @HiltViewModel, Koin qua viewModel { }.

Bài này không pin version Koin: cú pháp DSL giữ nguyên, nhưng kiểm tra version trên Maven Central trước khi thêm vào build.

Vì sao cần Dependency Injection trong Android

DI đảo ngược quyền tạo object: class không tự dựng dependency, nó nhận qua constructor. Thay đổi nhỏ này kéo theo ba thứ lớn.

Testability. Class nhận dependency qua constructor được kiểm thử bằng cách truyền fake — không cần Hilt, Robolectric hay máy ảo, test chạy vài mili giây.

Constructor injection làm dependency hiện trong chữ ký. Nhìn constructor là biết class cần gì: không lateinit gán ở đâu đó, không singleton ẩn, không thứ tự khởi tạo bí mật. Codebase Android cũ khó đọc chủ yếu vì dependency lấy bằng static call hoặc field injection rải rác, không ai dựng lại được đồ thị trong đầu.

// Không DI: dependency bị chôn trong thân class
class NotesRepository {
    private val api = RetrofitNotesApi(Retrofit.Builder().baseUrl(BASE_URL).build())
}

// Có DI: dependency nằm trong chữ ký
class NotesRepository(
    private val api: NotesApi,
    private val dao: NotesDao,
)

Scope. Scope trả lời “instance này sống bao lâu”. Trong Android có ít nhất bốn vòng đời chồng nhau: Application, Activity (qua cấu hình thay đổi), ViewModel, composition. Không quản lý scope thì bạn nhận một trong ba lỗi: rò rỉ vì singleton giữ Activity đã finish, state chia sẻ ngoài ý muốn giữa hai màn hình, hoặc crash vì object sống lâu hơn tài nguyên nó trỏ tới. Manual DI giải quyết được cả ba, nhưng bằng tay.

Hilt 2.60.1: Dagger có khuôn cho Android

Hilt giữ engine compile-time của Dagger nhưng thay bạn dựng component cho các lớp Android chuẩn. Bạn khai module, Hilt sinh phần còn lại, và graph được kiểm tra lúc build: thiếu binding, sai scope, dependency vòng đều thành lỗi biên dịch thay vì crash lúc người dùng mở màn hình.

Gradle: KSP2, đừng thêm KAPT

Thêm plugin Hilt 2.60.1 và plugin KSP với bản khớp Kotlin 2.4.21 (con số KSP đổi theo từng release Kotlin, đừng copy từ bài cũ).

// File: app/build.gradle.kts
plugins {
    id("com.google.devtools.ksp")          // version khai báo ở root
    id("com.google.dagger.hilt.android")   // 2.60.1
}
dependencies {
    implementation("com.google.dagger:hilt-android:2.60.1")
    ksp("com.google.dagger:hilt-android-compiler:2.60.1")
}

Nếu project còn plugin kotlin-kapt chỉ vì Hilt, bạn trả giá hai lần: một vòng KAPT sinh stub Java, một vòng KSP. Bỏ hẳn KAPT cho Hilt, chỉ giữ nếu còn processor khác chưa hỗ trợ KSP.

@HiltAndroidApp và @AndroidEntryPoint

@HiltAndroidApp đặt trên Application để Hilt sinh component gốc và gắn vào vòng đời app. @AndroidEntryPoint đặt trên Activity, Fragment, Service, View để Hilt biết nơi nào được field injection.

@HiltAndroidApp
class NotesApplication : Application()

@AndroidEntryPoint
class NotesActivity : ComponentActivity()

Thiếu @AndroidEntryPoint, field @Inject vẫn null và bạn nhận UninitializedPropertyAccessException ở dòng đầu dùng tới nó. Đây là lỗi số một khi thêm Hilt vào màn hình có sẵn: annotation bị quên ở Activity ít dùng, nên chỉ crash khi tester mở đúng màn hình đó.

@Module, @InstallIn, @Provides, @Binds

@Provides dùng khi bạn phải tự dựng object: OkHttpClient, Retrofit, Context, hoặc thứ không có constructor để @Inject. @Binds dùng khi implementation đã có @Inject constructor và bạn chỉ cần map interface sang implementation; nó rẻ hơn vì không sinh thêm method gọi constructor.

// File: app/src/main/java/vn/evotek/notes/di/NetworkModule.kt
@Module
@InstallIn(SingletonComponent::class)
object NetworkModule {
    @Provides
    @Singleton
    fun provideOkHttp(): OkHttpClient = OkHttpClient.Builder().build()

    @Provides
    @Singleton
    fun provideRetrofit(client: OkHttpClient): Retrofit =
        Retrofit.Builder()
            .baseUrl("https://api.evotek.vn/")
            .client(client)
            .addConverterFactory(MoshiConverterFactory.create())
            .build()
}

// File: app/src/main/java/vn/evotek/notes/di/AnalyticsModule.kt
interface AnalyticsLogger { fun log(event: String) }
class FirebaseAnalyticsLogger @Inject constructor() : AnalyticsLogger {
    override fun log(event: String) { /* ... */ }
}

@Module
@InstallIn(SingletonComponent::class)
abstract class AnalyticsModule {
    @Binds @Singleton
    abstract fun bindLogger(impl: FirebaseAnalyticsLogger): AnalyticsLogger
}

Hai chi tiết dễ sai: @Binds bắt buộc trong abstract class hoặc interface, không được là hàm có thân; @InstallIn quyết định module sống ở component nào — đặt sai là lỗi graph ngay lúc build.

Scope của Hilt: theo vòng đời, không theo cảm giác

Annotation Component Sống đến khi
@Singleton SingletonComponent Process chết
@ActivityRetainedScoped ActivityRetainedComponent Activity finish; sống qua xoay màn hình
@ViewModelScoped ViewModelComponent ViewModel bị clear
@ActivityScoped ActivityComponent onDestroy của Activity
@FragmentScoped FragmentComponent Fragment bị hủy
@ServiceScoped ServiceComponent Service dừng
@ViewScoped ViewComponent View bị hủy

@Singleton chỉ nên dùng cho thứ thật sự stateless: OkHttp, database, repository không giữ state màn hình. Thứ giữ state gắn với màn hình để @ViewModelScoped hoặc unscoped. @ActivityRetainedScoped sống qua cấu hình thay đổi nhưng không qua process death, đừng dùng như nơi lưu dữ liệu bền.

ViewModel injection

Hilt sinh factory cho ViewModel, nên @HiltViewModel là điều kiện để constructor injection hoạt động với ViewModelProvider. Không có nó, viewModel() dùng factory mặc định và không biết truyền tham số.

// File: app/src/main/java/vn/evotek/notes/ui/NotesViewModel.kt
@HiltViewModel
class NotesViewModel @Inject constructor(
    private val repository: NotesRepository,
    private val logger: AnalyticsLogger,
) : ViewModel() {
    private val _state = MutableStateFlow(NotesUiState())
    val state: StateFlow<NotesUiState> = _state.asStateFlow()

    fun refresh() = viewModelScope.launch {
        runCatching { repository.load() }
            .onSuccess { notes -> _state.update { it.copy(notes = notes) } }
            .onFailure { e -> _state.update { it.copy(error = e.message) } }
    }
}

Trong Activity, by viewModels() tự lấy factory Hilt đã sinh; trong Compose, hiltViewModel() từ androidx.hilt:hilt-navigation-compose lấy ViewModelStoreOwner từ scope hiện tại. Repository bên dưới chỉ cần @Inject constructor, không biết gì về Hilt.

Test với @HiltAndroidTest và @UninstallModules

@HiltAndroidTest bật graph test; HiltAndroidRule inject trước mỗi test; @UninstallModules gỡ module thật; @BindValue thay một binding bằng field trong test class. Test instrumentation cần Application là HiltTestApplication — qua runner riêng hoặc @CustomTestApplication; với Robolectric thêm @Config(application = HiltTestApplication::class).

Module bị thay ở hầu hết test thì @TestInstallIn gọn hơn @UninstallModules. ViewModel không phụ thuộc Android thì bỏ Hilt test: gọi constructor trực tiếp với fake, nhanh hơn nhiều.

Koin: cùng ý tưởng, khác cơ chế

Koin viết hoàn toàn bằng Kotlin, không annotation processor. Bạn khai báo graph bằng DSL, Koin dựng registry lúc chạy và phân giải khi có người gọi get(). Đổi lại: setup nhanh, không tăng thời gian build, nhưng thiếu binding chỉ lộ ra lúc chạy.

// File: app/src/main/java/vn/evotek/notes/di/AppModule.kt
val appModule = module {
    single { OkHttpClient.Builder().build() }
    single {
        Retrofit.Builder()
            .baseUrl("https://api.evotek.vn/")
            .client(get())
            .addConverterFactory(MoshiConverterFactory.create())
            .build()
    }
    single<NotesApi> { RetrofitNotesApi(get()) }
    factory { NotesRepository(get(), get()) }
    viewModel { NotesViewModel(get(), get()) }
}

single tạo một instance cho cả container; factory tạo mới mỗi lần được yêu cầu; viewModel tạo factory cho ViewModelProvider và gắn vòng đời với ViewModel. get() bên trong block phân giải dependency khác từ cùng registry. Cùng một graph với Hilt, nhưng không component, không @InstallIn, và không ai kiểm tra giúp lúc build.

startKoin tạo container toàn cục gắn với process; koinApplication tạo KoinApplication độc lập, không đụng global state, dùng cho test và preview:

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

// Container riêng cho test, đóng được sau khi chạy
@Test
fun load_writesThroughCache() = runTest {
    val koinApp: KoinApplication = koinApplication {
        modules(module {
            single<NotesApi> { FakeNotesApi() }
            factory { NotesRepository(get(), NotesDaoFake()) }
        })
    }
    val repository = koinApp.koin.get<NotesRepository>()
    koinApp.close()
}

Vì container không global, bạn chạy được nhiều test song song với graph khác nhau — thứ startKoin toàn cục không làm tốt. Trong Activity, by viewModel() lấy ViewModel từ định nghĩa viewModel { }; trong Compose là koinViewModel(). Cả hai là field injection tại entry point, hạn chế cố hữu của Koin với lớp do hệ thống khởi tạo.

Dagger gốc: vẫn dùng, nhưng không phải mặc định

Dagger trần vẫn có chỗ đứng, chỉ không còn là lựa chọn đầu cho app Android mới. Bốn tình huống còn dùng trực tiếp: codebase Java cũ đã có @Component và scope riêng (viết lại graph là rủi ro không đáng); đồ thị scope tùy biến không khớp bộ component cố định của Hilt, ví dụ graph theo feature hay user session; module JVM thuần dùng chung với backend hoặc thư viện không muốn kéo phụ thuộc Android; và team đã thành thạo, cần kiểm soát chính xác code sinh ra.

Khác biệt cốt lõi so với Hilt: bạn tự khai component bằng @Component, tự nối subcomponent, tự đặt entry point, và có toàn quyền về scope — như @Scope annotation class ActivityScope cùng subcomponent cho từng Activity, thứ Hilt chỉ cho trong khuôn của nó. Cái giá là boilerplate và graph dễ vỡ khi refactor.

Manual DI: phương án không thư viện

Với app nhỏ hoặc prototype, container viết tay đủ dùng và không tốn thời gian build: giữ một AppContainer trong Application, khai báo dependency bằng by lazy, truyền xuống entry point, còn constructor injection áp dụng cho mọi class bên dưới.

Giới hạn không nằm ở code mà ở việc kiểm tra: không ai báo lỗi nếu bạn quên một dependency, và scope chỉ là quy ước. Với 10–20 dependency thì ổn; qua 50, chi phí bảo trì tăng nhanh hơn chi phí học Hilt.

Bảng quyết định: Hilt, Koin, manual, Dagger

Tình huống Chọn Lý do
App Android mới, team từ 2 người, nhiều màn hình Hilt 2.60.1 Scope sẵn, lỗi graph ở compile-time, tích hợp ViewModel/Worker
App nhỏ, 1–3 người, muốn graph đọc như code Koin DSL ngắn, không processor, setup trong một buổi
Prototype, dưới 20 dependency Manual DI Không plugin, không build cost, dễ xóa khi bỏ
Codebase Java cũ đã có @Component Dagger Không viết lại graph; Hilt chỉ thêm lớp bọc
Module JVM/KMP dùng chung ngoài Android Dagger hoặc Koin Hilt gắn với Android; Koin hỗ trợ KMP
Nhiều dynamic feature, scope theo feature Hilt hoặc Dagger subcomponent Cần component tách biệt theo module

Nếu chưa có lý do rõ ràng để làm khác, Hilt là mặc định cho Android — không vì tốt nhất mọi tiêu chí, mà vì nó có tài liệu chính thức từ Google, tích hợp Jetpack và lỗi biên dịch đủ rõ để team mới đọc hiểu.

Bảy bẫy làm DI thành gánh nặng

Bẫy Dấu hiệu Cách sửa
Activity-scoped dependency lọt vào singleton Hilt báo lỗi scope lúc build; manual/Koin rò rỉ Activity Đưa xuống ActivityComponent hoặc truyền qua tham số
Quên @AndroidEntryPoint lateinit chưa khởi tạo, crash ở màn hình ít dùng Soát mọi entry point; test mở từng màn hình
Lạm dụng @Singleton State của màn hình A xuất hiện ở màn hình B Singleton chỉ cho object stateless; state để @ViewModelScoped
Service locator trá hình get(), KoinComponent, container static rải khắp class Constructor injection; chỉ resolve ở entry point
Koin lỗi chỉ lúc chạy NoDefinitionFound khi mở flow hiếm Kiểm tra module trong koin-test, chạy trong CI
KAPT còn sót Build chậm gấp đôi, cảnh báo stub Java Bỏ plugin kapt, chuyển hẳn sang KSP2
Hai binding cho cùng một type Duplicate binding, chọn nhầm implementation Một binding duy nhất; phân biệt bằng qualifier

Ba dòng đầu cùng gốc: ai sở hữu vòng đời. Hai dòng giữa: dependency bị giấu khỏi chữ ký. Sửa gốc rẻ hơn sửa triệu chứng.

Nhìn tới 2027

Hilt nhiều khả năng vẫn là mặc định Android: Google duy trì nó cùng Dagger, và KSP2 đã xóa phần lớn chi phí build từng bị phàn nàn. Kotlin 2.5.0 dự kiến ra tháng 12/2026, kéo theo việc chọn lại bản KSP — kiểm tra mỗi lần nâng Kotlin thay vì giả định bản cũ còn đúng. Với Navigation 3, ViewModel gắn theo từng NavEntry khi có decorator lưu ViewModelStore, nên scope dependency phải đi theo đơn vị điều hướng chứ không chỉ theo Activity.

Koin sẽ mạnh thêm ở Kotlin Multiplatform và ở team ưu tiên graph đọc bằng mắt. Dagger trần thu hẹp vào codebase cũ và module JVM; manual DI vẫn đúng cho prototype, miễn bạn biết lúc nào nên dừng.

Checklist trước khi chọn

  • Xác định scope từng dependency trước khi viết module.
  • Với Hilt: dùng KSP2, pin 2.60.1, không giữ KAPT chỉ vì Hilt.
  • Đặt @AndroidEntryPoint cho mọi entry point và test mở từng màn hình.
  • Chỉ @Singleton cho object stateless; state màn hình để @ViewModelScoped.
  • Với Koin: kiểm tra module trong test và dùng koinApplication thay global container.
  • Đừng để domain class gọi get() hay giữ tham chiếu container; chỉ entry point được resolve.

Đọc tiếp trong series: Repository, Factory và Builder để thấy DI nối các mẫu thiết kế này, kiến trúc MVVM/MVI để đặt ViewModel đúng chỗ, LiveData, Flow và lập trình phản ứng để nối state vào UI, và toàn bộ lộ trình Android cho bài tiếp theo.