入門學習如何使用 Dagger 依賴注入

在現代 Android 開發中，依賴注入（Dependency Injection, DI）是構建可維護、可測試程式碼的關鍵技術。Dagger 作為 Google 推出的依賴注入框架，透過編譯時代碼生成大幅提升效能。本文將以 Kotlin 示範 Dagger 的實際應用。

一、導入 Dagger 依賴（Kotlin 配置）

// build.gradle (Module)
plugins {
    id("kotlin-kapt") // 新增 Kapt 插件
}

dependencies {
    // Dagger 核心庫
    implementation("com.google.dagger:dagger:2.55") // 建議使用最新版本
    kapt("com.google.dagger:dagger-compiler:2.55")   // Kotlin 需用 kapt 取代 annotationProcessor
}

二、基礎依賴注入範例

1. 建立被注入類別

// User.kt
import javax.inject.Inject

class User @Inject constructor() // Kotlin 簡潔構造函數標注

2. 建立 Dagger 元件

// ApplicationComponent.kt
import dagger.Component
import com.tiger.dagger.MainActivity

@Component
interface ApplicationComponent {
    fun inject(activity: MainActivity) // 函數參數自動辨識注入目標
}

3. Activity 中使用注入

// MainActivity.kt
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import javax.inject.Inject

class MainActivity : AppCompatActivity() {
    @Inject
    lateinit var user: User // Kotlin 使用 lateinit 延遲初始化

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        DaggerApplicationComponent.create().inject(this)
        println("注入成功: ${user.hashCode()}")
    }
}

三、模組化依賴注入

1. 建立 Retrofit 模組

// NetModule.kt
import dagger.Module
import dagger.Provides
import retrofit2.Retrofit

@Module
object NetModule { // Kotlin 建議使用 object 單例模組
    @Provides
    fun provideRetrofit(): Retrofit = 
        Retrofit.Builder()
            .baseUrl("https://api.example.com/")
            .build()
}

2. 更新元件配置

// ApplicationComponent.kt
@Component(modules = [NetModule::class])
interface ApplicationComponent {
    fun inject(activity: MainActivity)
}

3. 多依賴注入使用

// MainActivity.kt
class MainActivity : AppCompatActivity() {
    @Inject lateinit var user: User
    @Inject lateinit var retrofit: Retrofit

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        DaggerApplicationComponent.create().inject(this)
        
        println("Retrofit 實例: ${retrofit.baseUrl()}")
    }
}

四、參數依賴注入

// ServiceModule.kt
@Module
object ServiceModule {
    @Provides
    fun provideApiService(retrofit: Retrofit, user: User): ApiService {
        println("注入使用者到服務: ${user.hashCode()}")
        return retrofit.create(ApiService::class.java)
    }
}

五、作用域與單例模式

1. 應用級單例

// ApplicationScope.kt
import javax.inject.Scope

@Scope
@Retention(AnnotationRetention.RUNTIME)
annotation class AppScope

2. 單例元件配置

@AppScope
@Component(modules = [NetModule::class, ServiceModule::class])
interface ApplicationComponent {
    fun inject(activity: MainActivity)
}

3. 模組單例實現

@Module
object DatabaseModule {
    @AppScope
    @Provides
    fun provideDatabase(): AppDatabase = 
        Room.databaseBuilder(...).build()
}

六、進階技巧：Kotlin 擴展優化

元件初始化封裝

// DaggerExtensions.kt
fun Application.initDagger(): ApplicationComponent = 
    DaggerApplicationComponent
        .factory()
        .create(this)

在 Application 中使用

class MyApp : Application() {
    val appComponent by lazy { initDagger() }
}

總結

通過以上步驟，我們成功地在 Kotlin 專案項目中使用了 Dagger 依賴注入框架。Dagger 可以幫助我們更好地管理依賴關係，使程式碼結構更加清晰，提高代碼的可維護性和可測試性。在實際的開發中，你可以根據項目的需求，擴展和完善 Dagger 的使用，引入更多的模塊和組件，以適應不同的業務場景。