MVI 让屏幕一次只有一个状态

本文译自「MVI in Android --- Designing Screens That Can Only Be in One State at a Time」,原文链接medium.com/@aleyvaschz...,由Adrian Leyva发布于2026年8月12日。

使用 Kotlin、协程和 Jetpack Compose 实现单向数据流的实用指南

有一种特定的 bug,每个 Android 开发者最终都会遇到。测试人员会附上一张截图,显示一个加载指示器在错误信息上方旋转,两者背后都显示着一个只填充了一半的列表。你无法重现这个问题。你反复读取 ViewModel 三次,逻辑看起来都没问题。两天后,你终于找到了原因:用户下拉刷新之后,一个网络请求才返回;某个布尔值以错误的顺序被翻转;屏幕最终停留在了没人设计过的值组合上。

这个 bug 并非传统意义上的编码错误,而是设计上的缺陷。当一个屏幕由五个独立变量描述时,它可以有 32 种不同的配置,而团队只考虑了其中的 4 种。其余的配置其实一直存在,只是等待着合适的竞态条件触发。

模型-视图-意图(Model View Intent,简称 MVI)正是为了解决这个问题而生的。它并非一个全新的库,也并非要取代你已有的所有知识。它是一种应用于你可能已经使用的架构之上的规范,其核心理念很简单:在任何时刻,你的屏幕都只有一种状态,这种状态只在一个地方产生,并且它只会在响应明确的、命名的事件时才会改变。

本文将介绍 MVI 在现代 Android 代码库中的实际含义、如何使用 Kotlin Flows 和 Jetpack Compose 实现它、如何测试它,以及何时它并不适用。

MVI 试图解决的问题

大多数 Android 团队编写的方案都接近 MVVM 模式。ViewModel 公开一些可观察的属性,UI 收集这些属性,用户操作调用 ViewModel 的公共方法。这种模式运行良好,对于大量屏幕来说,它的仪式感恰到好处。

随着屏幕变得越来越复杂,摩擦就出现了。考虑一个用传统方式编写的典型产品搜索 ViewModel:

kotlin 复制代码
class ProductListViewModel : ViewModel() {
    private val _isLoading = MutableStateFlow(false)
    val isLoading: StateFlow<Boolean> = _isLoading.asStateFlow()
    private val _products = MutableStateFlow<List<Product>>(emptyList())
    val products: StateFlow<List<Product>> = _products.asStateFlow()
    private val _error = MutableStateFlow<String?>(null)
    val error: StateFlow<String?> = _error.asStateFlow()
    private val _isEmpty = MutableStateFlow(false)
    val isEmpty: StateFlow<Boolean> = _isEmpty.asStateFlow()
}

这里存在四个独立的真值来源。类型系统中没有任何机制阻止 isLoading 为真而 error 不为空。也没有任何机制强制 isEmpty 与 products 保持一致。每个新功能都会增加一个标志,而每个标志都会使理论状态的数量翻倍。最终,UI 层会使用防御性条件语句来弥补,而正确性则取决于每个人是否记得按正确的顺序更新正确的字段。

MVI 将这四个属性合并为一个属性,从而消除了整个此类问题。

契约的三个部分

MVI 屏幕由一个包含三个部分的简短契约定义。在进行任何实现之前先编写这个契约,是该模式所教授的最有价值的习惯。

  • 状态 是屏幕渲染所需所有内容的不可变快照。如果某个元素不在状态中,则无法显示在屏幕上。
  • 意图 是用户操作或生命周期信号,以用户语言而非实现语言表达。RetryClicked 是一个意图,而 SetLoadingTrue 则不是。
  • 效果 是一次性事件,完全不属于状态:例如导航到另一个屏幕、显示 Snackbar、触发触觉反馈等。

产品搜索屏幕的契约如下:

kotlin 复制代码
data class ProductListState(
    val query: String = "",
    val content: Content = Content.Idle,
    val isRefreshing: Boolean = false
) {
    sealed interface Content {
        data object Idle : Content
        data object Loading : Content
        data class Success(val products: List<Product>) : Content
        data object Empty : Content
        data class Failure(val message: String) : Content
    }
}
sealed interface ProductListIntent {
    data class QueryChanged(val query: String) : ProductListIntent
    data object SearchSubmitted : ProductListIntent
    data object RetryClicked : ProductListIntent
    data class ProductClicked(val productId: String) : ProductListIntent
}
sealed interface ProductListEffect {
    data class NavigateToDetail(val productId: String) : ProductListEffect
    data class ShowMessage(val message: String) : ProductListEffect
}

注意 Content 层级结构的作用。加载和失败不再是碰巧共存的独立布尔值,而是密封接口中互斥的分支,因此导致我们最初遇到的 bug 的不可能组合现在无法表示。编译器强制执行了设计决策,而不是依赖代码审查意见。

状态与效果的分离比表面看起来更为重要。状态会被重放:当设备旋转或进程恢复时,UI 会根据最新状态重新渲染,这是正常行为。而效果则不应该被重放。没有人希望每次配置更改后都出现相同的 Snackbar,也没有人希望导航两次。将它们建模为独立的通道才能确保这种区分的有效性。

将用户操作与系统观察结果区分开来

在实际项目中,区分意图和内部事件可以大大减少很多麻烦。意图来自 ViewModel 外部。内部事件是 ViewModel 发起的工作所产生的结果:例如,仓库响应、定时器触发、缓存发出新数据等。

两者都需要修改状态,但它们的来源和名称不同。将它们分开可以防止意图层级结构中充斥着类似 DataLoadedSuccessfully 这样的条目,这些条目用户永远不会触发,也不应该从 UI 层调用。

kotlin 复制代码
internal sealed interface ProductListEvent {
    data class QueryUpdated(val query: String) : ProductListEvent
    data object LoadStarted : ProductListEvent
    data class LoadSucceeded(val products: List<Product>) : ProductListEvent
    data class LoadFailed(val message: String) : ProductListEvent
    data class RefreshingChanged(val isRefreshing: Boolean) : ProductListEvent
}

Reducer

MVI 的声誉主要归功于 reducer。它是一个纯函数,接受当前状态和一个事件作为参数,并返回下一个状态。它不进行任何输入或输出操作,不启动任何协程,也不会触及参数之外的任何内容。

kotlin 复制代码
internal fun ProductListState.reduce(event: ProductListEvent): ProductListState =
    when (event) {
        is ProductListEvent.QueryUpdated -> copy(query = event.query)
        ProductListEvent.LoadStarted -> copy(
            content = if (content is ProductListState.Content.Success) {
                content
            } else {
                ProductListState.Content.Loading
            }
        )
        is ProductListEvent.LoadSucceeded -> copy(
            content = if (event.products.isEmpty()) {
                ProductListState.Content.Empty
            } else {
                ProductListState.Content.Success(event.products)
            },
            isRefreshing = false
        )
        is ProductListEvent.LoadFailed -> copy(
            content = ProductListState.Content.Failure(event.message),
            isRefreshing = false
        )
        is ProductListEvent.RefreshingChanged -> copy(isRefreshing = event.isRefreshing)
    }

现在,所有关于此屏幕行为的规则都集中在一个易于阅读的代码块中。例如,在刷新过程中保持显示现有结果而不是闪现一个加载指示器的决定,只需在 LoadStarted 分支中写上三行代码即可实现。而以前,这条规则分散在协程、布尔赋值语句和布局中的条件语句里。

因为 reducer 是纯函数,所以它也很容易测试,这也是 MVI 屏幕往往具有异常高的测试覆盖率而无需任何人强制执行的原因。

ViewModel

有了契约和 reducer,ViewModel 就变得精简了。它的任务是接收意图、协调异步工作、将事件传递给 reducer 并发出效果。

kotlin 复制代码
@HiltViewModel
class ProductListViewModel @Inject constructor(
    private val searchProducts: SearchProductsUseCase
) : ViewModel() {
    private val _state = MutableStateFlow(ProductListState())
    val state: StateFlow<ProductListState> = _state.asStateFlow()
    private val _effects = Channel<ProductListEffect>(Channel.BUFFERED)
    val effects: Flow<ProductListEffect> = _effects.receiveAsFlow()
    private var searchJob: Job? = null
    fun onIntent(intent: ProductListIntent) {
        when (intent) {
            is ProductListIntent.QueryChanged -> {
                dispatch(ProductListEvent.QueryUpdated(intent.query))
            }
            ProductListIntent.SearchSubmitted -> search(_state.value.query)
            ProductListIntent.RetryClicked -> search(_state.value.query)
            is ProductListIntent.ProductClicked -> {
                sendEffect(ProductListEffect.NavigateToDetail(intent.productId))
            }
        }
    }
    private fun search(query: String) {
        searchJob?.cancel()
        searchJob = viewModelScope.launch {
            dispatch(ProductListEvent.LoadStarted)
            searchProducts(query)
                .onSuccess { products ->
                    dispatch(ProductListEvent.LoadSucceeded(products))
                }
                .onFailure { throwable ->
                    dispatch(ProductListEvent.LoadFailed(throwable.toUserMessage()))
                    sendEffect(ProductListEffect.ShowMessage(throwable.toUserMessage()))
                }
        }
    }
    private fun dispatch(event: ProductListEvent) {
        _state.update { current -> current.reduce(event) }
    }
    private fun sendEffect(effect: ProductListEffect) {
        _effects.trySend(effect)
    }
}

有两个细节值得我们停下来注意。

首先是 _state.update { }。使用原子更新函数而不是赋值给 _state.value 可以确保来自不同协程的并发更新彼此叠加,而不是相互覆盖。在具有多个并行数据源的屏幕中,这决定了结果是始终正确还是偶尔出错。

第二个是 searchJob?.cancel()。结构化并发会处理取消操作,但前提是你持有引用。在开始新的搜索之前取消之前的搜索,可以防止查询 "sh" 的慢响应在查询 "shoes" 的快速响应之后到达并覆盖后者。MVI 本身并不处理乱序结果,它为你提供了一个统一解决它们的地方。

连接用户界面

Compose 层接收一个状态对象,并把意图发送回去。它不包含任何业务决策。

kotlin 复制代码
@Composable
fun ProductListRoute(
    onNavigateToDetail: (String) -> Unit,
    viewModel: ProductListViewModel = hiltViewModel()
) {
    val state by viewModel.state.collectAsStateWithLifecycle()
    val snackbarHostState = remember { SnackbarHostState() }
    val lifecycleOwner = LocalLifecycleOwner.current
    LaunchedEffect(viewModel, lifecycleOwner) {
        viewModel.effects
            .flowWithLifecycle(lifecycleOwner.lifecycle, Lifecycle.State.STARTED)
            .collect { effect ->
                when (effect) {
                    is ProductListEffect.NavigateToDetail -> {
                        onNavigateToDetail(effect.productId)
                    }
                    is ProductListEffect.ShowMessage -> {
                        snackbarHostState.showSnackbar(effect.message)
                    }
                }
            }
    }
    ProductListScreen(
        state = state,
        snackbarHostState = snackbarHostState,
        onIntent = viewModel::onIntent
    )
}
@Composable
private fun ProductListScreen(
    state: ProductListState,
    snackbarHostState: SnackbarHostState,
    onIntent: (ProductListIntent) -> Unit
) {
    Scaffold(
        snackbarHost = { SnackbarHost(snackbarHostState) }
    ) { padding ->
        Column(modifier = Modifier.padding(padding)) {
            SearchField(
                query = state.query,
                onQueryChange = { onIntent(ProductListIntent.QueryChanged(it)) },
                onSubmit = { onIntent(ProductListIntent.SearchSubmitted) }
            )
            when (val content = state.content) {
                ProductListState.Content.Idle -> IdleHint()
                ProductListState.Content.Loading -> FullScreenLoader()
                ProductListState.Content.Empty -> EmptyResults(query = state.query)
                is ProductListState.Content.Failure -> ErrorMessage(
                    message = content.message,
                    onRetry = { onIntent(ProductListIntent.RetryClicked) }
                )
                is ProductListState.Content.Success -> ProductGrid(
                    products = content.products,
                    onProductClick = { onIntent(ProductListIntent.ProductClicked(it)) }
                )
            }
        }
    }
}

对密封接口进行详尽的 when 判断是一项低调但意义重大的优势。例如,下个季度添加一个新的内容分支,编译器会自动指出所有需要处理该分支的屏幕。而当状态是一串布尔值时,则无法提供类似的保证。

将路由从无状态屏幕中分离出来,也意味着屏幕可组合函数接受普通参数,这使得预览和屏幕截图测试变得简单明了。

测试变得机械化

reducer 是一个纯函数,因此测试行为完全不需要协程机制。

kotlin 复制代码
@Test
fun `keeps existing results visible while refreshing`() {
    val initial = ProductListState(
        query = "shoes",
        content = ProductListState.Content.Success(listOf(sampleProduct))
    )
    val result = initial.reduce(ProductListEvent.LoadStarted)
    assertThat(result.content).isEqualTo(initial.content)
}
@Test
fun `empty response maps to empty content`() {
    val result = ProductListState(query = "shoes")
        .reduce(ProductListEvent.LoadSucceeded(products = emptyList()))
    assertThat(result.content).isEqualTo(ProductListState.Content.Empty)
}

对于 ViewModel 本身,你只需断言已发出的状态序列,读起来几乎就像是该功能的一份规格说明。

kotlin 复制代码
@Test
fun `failed search emits failure state and a message effect`() = runTest {
    coEvery { searchProducts("shoes") } returns Result.failure(IOException())
    val viewModel = ProductListViewModel(searchProducts)
    viewModel.state.test {
        assertThat(awaitItem().content).isEqualTo(ProductListState.Content.Idle)
        viewModel.onIntent(ProductListIntent.QueryChanged("shoes"))
        awaitItem()
        viewModel.onIntent(ProductListIntent.SearchSubmitted)
        assertThat(awaitItem().content).isEqualTo(ProductListState.Content.Loading)
        assertThat(awaitItem().content).isInstanceOf(ProductListState.Content.Failure::class.java)
    }
}

重要注意事项

MVI 确实存在实际成本,而那些不讨论这些成本就采用 MVI 的团队往往会在中途放弃它。

  • 状态类会变成垃圾场。 在复杂的屏幕上,很容易为了应对各种极端情况而添加一个可空字段。务必克制这种做法。如果某条数据属于屏幕的某个独立部分,请将其建模为嵌套的密封类型或独立的子状态,并独立进行归约。
  • 如果不小心,重组的成本会增加。 单个大型状态对象意味着任何更改都会发出一个新的实例。当状态稳定且可组合对象只读取所需内容时,Compose 可以很好地处理这种情况,但如果将整个状态对象向下传递五层,就会破坏这种特性。请传递每个可组合对象实际需要的最小切片。
  • 效果可能会丢失。 Channel 会将数据传递给单个收集器。如果你的效果流在可组合对象中被收集,而该可组合对象在错误的时间点退出组合,则事件可能会丢失。如上所示,使用带有生命周期感知收集的缓冲通道可以涵盖常见情况。任何真正重要的信息,例如已完成的付款,都应该保存在状态或持久存储中,而不是瞬态效果中。
  • 样板代码确实存在。 为一个显示静态设置列表的屏幕编写三个类型和一个 reducer 并不划算。共享的通用基类或小型内部库可以减少重复代码,但无法消除概念上的开销。
  • 并非所有地方都需要。 启动画面、静态的"关于我们"页面或只有两个字段的简单表单并不需要 MVI。MVI 的收益与屏幕协调的异步源数量以及它可以占据的视觉状态数量成正比。建议在结账流程和搜索结果中使用 MVI,但在条款和条件页面则不需要。

结论

MVI 与其说是一个框架,不如说是一组你自愿接受的约束。你放弃了修改几个独立字段的便利,作为交换,你得到了一个屏幕,其行为由一个不可变类型和一个纯函数描述。重现错误变成了构建一个状态对象,添加新功能变成了添加一个编译器会确保你不会忘记处理的分支。从你已经感到担忧的屏幕开始。在实现之前编写契约,保持 reducer 的纯净性,并让密封类型消除那些本不应该存在的组合。

感谢阅读!

欢迎搜索并关注 公众号「稀有猿诉」 获取更多的优质文章!

保护原创,请勿转载!

相关推荐
二流小码农6 小时前
鸿蒙开发:证书只能创建3个,第4个应用怎么办
android·ios·harmonyos
阿杰m8 小时前
Android源码第十七章:PowerManager 与后台任务——锁屏后怎么跑?
android
JMchen1238 小时前
【Android 性能优化实战 60 讲】10 Jetpack App Startup 内核魔改:手写异步懒加载启动框架,根治串行初始化耗时
android·性能优化·源码分析·启动优化·kotlin协程·app startup
2601_967980118 小时前
python+appium自动化测试如何控制App的启动和退出
android·自动化测试·python·appium·设备调试
booboosui9 小时前
不写安装器:点一下就往对话里塞 152 个字符
android
一条破秋裤10 小时前
【1117】【内存资源管控】【笔记】
android·笔记
AI导出鸭PC端10 小时前
用 AI 导出鸭高效处理:豆包导 pdf 怎么压缩但清晰
android·人工智能·pdf·豆包·ai导出鸭
therese_1008612 小时前
流媒体协议RTMP推流demo-安卓端
android
疯华整猫12 小时前
同一个 App,五种手机五种死法:2026 年 Android 五大 ROM 兼容的 8 个真实坑
android·性能优化