ViewModel与LiveData使用初体验：从理论到实践的完整指南

一、为什么需要ViewModel与LiveData？

在传统Android开发中，Activity/Fragment直接持有数据会导致内存泄漏和配置变更（如屏幕旋转）时的数据丢失问题。ViewModel通过与Activity/Fragment生命周期绑定解决了这一问题，而LiveData则提供了响应式编程能力，使得UI组件能自动感知数据变化。

核心优势：

1. 生命周期感知：自动在组件销毁时移除观察者
2. 线程安全：支持主线程设置值，观察回调自动切换到主线程
3. 配置变更存活：ViewModel实例在配置变更时保留
4. 单向数据流：通过观察者模式实现清晰的数据流向

二、基础环境配置

1. 依赖引入

在module的build.gradle中添加：

dependencies {
    def lifecycle_version = "2.6.2"
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
    implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"
    // 可选：ViewModel的SavedState集成
    implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"
}

2. 基础ViewModel实现

class UserViewModel : ViewModel() {
    // 封装LiveData
    private val _userName = MutableLiveData<String>()
    val userName: LiveData<String> = _userName
    fun updateUserName(newName: String) {
        _userName.value = newName // 自动在主线程执行
    }
}

关键点：

• 使用MutableLiveData内部修改，暴露LiveData接口
• 所有数据修改通过ViewModel方法集中处理
• 无需手动处理线程切换

三、核心使用场景详解

1. 组件间通信

Activity/Fragment观察ViewModel：

class MainActivity : AppCompatActivity() {
    private lateinit var viewModel: UserViewModel
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 获取ViewModel实例
        viewModel = ViewModelProvider(this)[UserViewModel::class.java]
        // 观察LiveData
        viewModel.userName.observe(this) { name ->
            userNameTextView.text = name
        }
    }
}

Fragment间共享数据：

// 在Activity中共享ViewModel
class SharedViewModel : ViewModel() {
    val sharedData = MutableLiveData<String>()
}
// Fragment1中设置数据
val sharedViewModel = ViewModelProvider(requireActivity())[SharedViewModel::class.java]
sharedViewModel.sharedData.value = "Hello from Fragment1"
// Fragment2中观察数据
val sharedViewModel = ViewModelProvider(requireActivity())[SharedViewModel::class.java]
sharedViewModel.sharedData.observe(viewLifecycleOwner) { data ->
    // 更新UI
}

2. 异步数据处理

结合协程处理网络请求：

class RepoViewModel : ViewModel() {
    private val _repoData = MutableLiveData<List<Repo>>()
    val repoData: LiveData<List<Repo>> = _repoData
    fun fetchRepos() {
        viewModelScope.launch {
            val result = withContext(Dispatchers.IO) {
                // 模拟网络请求
                delay(1000)
                listOf(Repo("ViewModel", "Android"))
            }
            _repoData.value = result
        }
    }
}

关键实践：

• 使用viewModelScope自动取消协程
• 业务逻辑封装在ViewModel中
• UI层仅处理显示逻辑

3. 事件处理模式

解决LiveData重复发送相同值不触发观察的问题：

class Event<T>(private val content: T) {
    private var hasBeenHandled = false
    fun getContentIfNotHandled(): T? {
        return if (hasBeenHandled) {
            null
        } else {
            hasBeenHandled = true
            content
        }
    }
}
// 在ViewModel中使用
private val _snackbarMessage = MutableLiveData<Event<String>>()
val snackbarMessage: LiveData<Event<String>> = _snackbarMessage
fun showSnackbar(message: String) {
    _snackbarMessage.value = Event(message)
}
// 在Activity中处理
viewModel.snackbarMessage.observe(this) { event ->
    event.getContentIfNotHandled()?.let {
        Snackbar.make(rootView, it, Snackbar.LENGTH_SHORT).show()
    }
}

四、高级使用技巧

1. 单次事件处理

使用SingleLiveEvent模式：

class SingleLiveEvent<T> : MutableLiveData<T>() {
    private val pending = AtomicBoolean(false)
    override fun setValue(value: T?) {
        pending.set(true)
        super.setValue(value)
    }
    override fun observe(owner: LifecycleOwner, observer: Observer<in T>) {
        super.observe(owner, Observer { t ->
            if (pending.compareAndSet(true, false)) {
                observer.onChanged(t)
            }
        })
    }
}

2. 转换操作

使用Transformations进行数据转换：

class ProfileViewModel : ViewModel() {
    private val userId = MutableLiveData<String>()
    val userProfile: LiveData<User> = Transformations.switchMap(userId) { id ->
        // 根据id获取用户数据
        repository.getUserProfile(id)
    }
    fun loadUser(id: String) {
        userId.value = id
    }
}

3. 测试实践

编写ViewModel单元测试：

@Test
fun `test user name update`() {
    val viewModel = UserViewModel()
    val testObserver = mock(Observer::class.java)
    viewModel.userName.observeForever(testObserver as Observer<String>)
    viewModel.updateUserName("Test User")
    // 验证观察者是否收到更新
    verify(testObserver).onChanged("Test User")
}

五、常见问题解决方案

1. 内存泄漏排查

现象：Activity销毁后ViewModel仍被引用
解决方案：

• 检查是否在Fragment中使用requireActivity()获取ViewModel
• 确保没有静态引用ViewModel实例
• 使用Android Profiler检查内存泄漏

2. 数据重复通知

现象：相同值设置多次触发观察者
解决方案：

• 使用distinctUntilChanged()：

  viewModel.userName.distinctUntilChanged().observe(this) { /*...*/ }

• 或使用前文提到的Event模式

3. 配置变更数据丢失

现象：屏幕旋转后数据重置
解决方案：

• 确保使用ViewModelProvider获取实例

• 对于需要跨配置变更保存的数据，使用SavedStateHandle：

  class SavedViewModel(savedStateHandle: SavedStateHandle) : ViewModel() {
    private val key = "user_name"
    private val _userName = savedStateHandle.getLiveData<String>(key)
    val userName: LiveData<String> = _userName
    fun updateName(name: String) {
        savedStateHandle[key] = name
    }
  }

六、最佳实践总结

1. 分离关注点：

   • ViewModel处理业务逻辑
   • Activity/Fragment仅处理UI
   • Repository层处理数据获取

2. 命名规范：

   • 使用_前缀表示可变的LiveData
   • 暴露不可变的LiveData接口

3. 线程管理：

   • 所有耗时操作在IO线程执行
   • 数据更新在主线程执行

4. 测试策略：

   • 单元测试ViewModel逻辑
   • UI测试观察者响应
   • 集成测试完整流程

5. 性能优化：

   • 避免在observe块中执行耗时操作
   • 合理使用switchMap/map转换
   • 及时移除不再需要的观察者

通过系统掌握ViewModel与LiveData的协同使用，开发者能够构建出更健壮、更易维护的Android应用架构。这种架构模式不仅解决了传统开发中的常见问题，还为后续添加新功能提供了清晰的扩展点。