kotlin与MVVM结合使用总结（一）

news2025/3/14 13:05:59

一、Kotlin 与 MVVM 结合的核心优势

代码简洁性
- 数据类（data class）简化 Model 层定义，自动生成equals/hashCode/toString
- 扩展函数简化 View 层逻辑（如点击事件扩展）
- lateinit/by lazy优化 ViewModel 属性初始化
异步处理优化
- 协程（Coroutines）替代 RxJava，轻量且代码可读性强
- withContext(Dispatchers.IO)切换线程，配合LiveData更新 UI
响应式编程
- LiveData + StateFlow实现数据双向绑定
- Flow替代LiveData处理复杂数据流（如网络请求重试）
生命周期感知
- ViewModel配合SavedStateHandle保存状态
- LifecycleOwner简化生命周期监听

二、MVVM 实现细节

ViewModel 层
- 使用 Kotlin @HiltViewModel注解依赖注入（结合 Hilt）
- 协程启动任务：viewModelScope.launch { ... }
- StateFlow封装业务状态，替代可变 LiveData
View 层
- DataBinding 绑定布局，Kotlin 表达式简化逻辑（如@{user.name ?: "Guest"}）
- ViewBinding替代findViewById，类型安全
- 协程与lifecycleScope结合处理异步任务
Model 层
- 数据类定义实体，@SerializedName配合 Retrofit 解析 JSON
- 仓库（Repository）模式隔离数据源，Kotlin 密封类定义请求状态（如Result.Success/Error）

三、面试高频问题

Kotlin 在 MVVM 中的优势
- 协程简化异步代码，数据类减少样板代码，扩展函数提升开发效率
协程与 LiveData 的结合
- 使用LiveData包装协程结果，或通过Flow转LiveData：
  viewModelScope.launch { flow.collect { data -> liveData.value = data } }
DataBinding 的高级用法
- 自定义 BindingAdapter 处理复杂逻辑（如图片加载）
- BR类动态更新绑定变量
如何避免内存泄漏
- ViewModel 自动绑定生命周期，协程使用viewModelScope，避免在 View 层持有长生命周期引用

四、最佳实践

单一数据源原则
- StateFlow 作为唯一数据源，通过collectAsState()在 View 层订阅
依赖注入
- Hilt 管理 ViewModel 和 Repository 的依赖，避免手动创建对象
单元测试
- 使用 MockK 模拟依赖，协程测试库验证异步逻辑
- ViewModel 测试独立于 UI 层，验证 StateFlow 的输出
状态管理
- 密封类定义 UI 状态（如 Loading/Success/Error），结合when表达式处理

演示代码：

ViewModel：

@HiltViewModel
class MainViewModel @Inject constructor(
    private val repository: UserRepository
) : ViewModel() {

    private val _user = MutableStateFlow<User?>(null)
    val user: StateFlow<User?> = _user

    fun fetchUser(userId: String) {
        viewModelScope.launch {
            try {
                _user.value = repository.getUser(userId)
            } catch (e: Exception) {
                // 处理错误
            }
        }
    }
}

View 层（Fragment）：

class MainFragment : Fragment() {
    private val viewModel by viewModels<MainViewModel>()

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        viewModel.user.collectAsState().observe(viewLifecycleOwner) { user ->
            // 更新UI
        }
    }
}

真实操作：

首先，确保在项目的 build.gradle 中添加必要的依赖，如 ViewModel、LiveData、Kotlin 协程等：

dependencies {
    // ViewModel 和 LiveData
    implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.6.2'
    implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.6.2'
    // Kotlin 协程
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3'
}

Model 层

Model 层主要负责数据的定义和数据的获取。这里以一个简单的用户数据为例：

// 定义用户数据类
data class User(val id: Int, val name: String, val age: Int)

// 模拟数据获取的仓库类
class UserRepository {
    // 模拟网络请求，使用协程进行异步操作
    suspend fun getUser(id: Int): User {
        // 模拟耗时操作
        delay(1000)
        return User(id, "John Doe", 30)
    }
}

ViewModel 层

ViewModel 层负责处理业务逻辑，并将数据暴露给 View 层。它通过 LiveData 或 StateFlow 来实现数据的响应式更新。

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.launch

class UserViewModel(private val userRepository: UserRepository) : ViewModel() {
    // 使用 MutableStateFlow 来存储和更新用户数据
    private val _user = MutableStateFlow<User?>(null)
    // 对外暴露不可变的 StateFlow
    val user: StateFlow<User?> = _user

    // 获取用户数据的方法
    fun fetchUser(id: Int) {
        viewModelScope.launch {
            try {
                // 调用仓库类的方法获取用户数据
                val user = userRepository.getUser(id)
                // 更新 StateFlow 的值
                _user.value = user
            } catch (e: Exception) {
                // 处理异常
                e.printStackTrace()
            }
        }
    }
}

View 层

View 层通常是 Activity 或 Fragment，负责显示数据和处理用户交互。这里以 Fragment 为例：

import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment
import androidx.lifecycle.lifecycleScope
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.launch

class UserFragment : Fragment() {

    private val userViewModel: UserViewModel by lazy {
        UserViewModel(UserRepository())
    }

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        return inflater.inflate(R.layout.fragment_user, container, false)
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        // 启动协程来收集 StateFlow 的数据
        lifecycleScope.launch {
            userViewModel.user.collect { user ->
                user?.let {
                    // 更新 UI
                    // 这里可以根据实际情况更新 TextView 等视图组件
                    // 例如：textView.text = "${it.name}, ${it.age}"
                }
            }
        }

        // 触发数据获取
        userViewModel.fetchUser(1)
    }
}

代码解释

Model 层：
- data class User：使用 Kotlin 的数据类简洁地定义了用户数据结构。
- UserRepository：模拟了数据的获取过程，使用 suspend 关键字和 delay 函数模拟网络请求的异步操作。
ViewModel 层：
- MutableStateFlow 和 StateFlow：用于存储和暴露用户数据，实现数据的响应式更新。
- viewModelScope.launch：在 ViewModel 中使用协程进行异步操作，确保在 ViewModel 的生命周期内执行。
View 层：
- lifecycleScope.launch：在 Fragment 中使用协程来收集 StateFlow 的数据，确保在 Fragment 的生命周期内执行。
- userViewModel.fetchUser(1)：触发数据获取操作。