在 Kotlin 中，可以使用依賴注入（DI）庫來處理依賴關系。其中 KTX 和 Dagger 是兩個常用的庫。下面分別介紹這兩個庫的使用方法。

1. KTX

KTX 是一個用于簡化 Android 應用開發的庫，它支持依賴注入。要在 Kotlin 項目中使用 KTX 進行依賴注入，首先需要在項目的 build.gradle 文件中添加相關依賴：

dependencies {
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:[version]'
    implementation 'androidx.lifecycle:lifecycle-runtime-ktx:[version]'
    implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:[version]'
    implementation 'androidx.lifecycle:lifecycle-livedata-ktx:[version]'
    implementation 'org.koin:koin-android:[version]'
}

接下來，創建一個模塊類，用于定義依賴關系：

import org.koin.dsl.module

val appModule = module {
    single { UserRepositoryImpl() as UserRepository }
    single { UserViewModel(get()) as UserViewModel }
}

在這個例子中，我們定義了一個 UserRepositoryImpl 類和 UserViewModel 類，并使用 single 函數來創建它們的單例實例。

然后，在 Application 類中初始化 Koin 上下文并啟動 DI：

import org.koin.android.ext.koin.androidContext
import org.koin.core.context.startKoin

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

最后，在需要使用依賴的地方，通過 Koin 注入：

import org.koin.core.component.KoinComponent
import org.koin.core.component.inject

class MainActivity : AppCompatActivity(), KoinComponent {
    private val userViewModel: UserViewModel by inject()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // 使用 userViewModel
    }
}

2. Dagger

Dagger 是一個功能強大的依賴注入庫，它可以幫助我們管理復雜的依賴關系。要在 Kotlin 項目中使用 Dagger 進行依賴注入，首先需要在項目的 build.gradle 文件中添加相關依賴：

dependencies {
    implementation 'com.google.dagger:dagger:[version]'
    kapt 'com.google.dagger:dagger-compiler:[version]'
    implementation 'androidx.lifecycle:lifecycle-runtime-ktx:[version]'
    implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:[version]'
    implementation 'androidx.lifecycle:lifecycle-livedata-ktx:[version]'
}

接下來，創建一個模塊類，用于定義依賴關系：

import dagger.Module
import dagger.Provides
import javax.inject.Singleton

@Module
class AppModule {
    @Provides
    @Singleton
    fun provideUserRepository(): UserRepository {
        return UserRepositoryImpl()
    }

    @Provides
    @Singleton
    fun provideUserViewModel(userRepository: UserRepository): UserViewModel {
        return UserViewModel(userRepository)
    }
}

然后，創建一個組件類，用于組合模塊和提供依賴：

import dagger.Component

@Component(modules = [AppModule::class])
interface AppComponent {
    fun inject(mainActivity: MainActivity)
}

接下來，在 Application 類中初始化 Dagger 組件并啟動 DI：

import android.app.Application
import javax.inject.Inject

class MyApplication : Application() {
    @Inject
    lateinit var appComponent: AppComponent

    override fun onCreate() {
        super.onCreate()
        appComponent = DaggerAppComponent.builder().build()
    }
}

最后，在需要使用依賴的地方，通過 Dagger 注入：

import javax.inject.Inject

class MainActivity : AppCompatActivity() {
    @Inject
    lateinit var userViewModel: UserViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        (application as MyApplication).appComponent.inject(this)

        // 使用 userViewModel
    }
}

這樣，我們就完成了 Kotlin 項目中使用 KTX 和 Dagger 進行依賴注入的過程。