Kotlin：用源码来深入理解 ‘StateFlow和SharedFlow的区别和联系‘

Kotlin：用源码来深入理解 ‘StateFlow和SharedFlow的区别和联系’

在这里插入图片描述

在这篇文章中，我们将深入研究Kotlin中的StateFlow和SharedFlow，以及它们的相似之处和不同之处。我们将通过查看它们的源代码来理解它们的工作原理，这将帮助我们更好地理解它们的用途和优势。

StateFlow

StateFlow是Kotlin中的一个概念，它是一个热Flow，可以存储状态。它的主要特点是始终保持最新的状态值，而且任何时候都可以访问这个状态值。当你观察StateFlow时，你将首先接收到当前的状态值，然后每当状态改变时，你都会收到新的状态值。

StateFlow的源代码如下：
伪源码：

public abstract class StateFlow<out T> : Flow<T> {public abstract val value: Tpublic abstract val replayCache: List<T>
}

在这段代码中，我们可以看到StateFlow有一个value属性，这是当前的状态值。还有一个replayCache属性，它是一个包含最近发出的值的列表。在StateFlow的情况下，这个列表总是包含一个元素，即当前的状态值。

当然实际上的源码是继承自SharedFlow，但是因为SharedFlow中有个public abstract val replayCache: List<T> 所以就相当于上面的伪源码
实际上的源码：

public interface StateFlow<out T> : SharedFlow<T> {/*** The current value of this state flow.*/public val value: T
}

SharedFlow

SharedFlow也是一个热Flow，但它和StateFlow有一些关键的区别。首先，SharedFlow没有一个固定的当前值。相反，它只是广播它接收到的所有值。其次，SharedFlow可以有一个回放缓存，它是一个包含最近发出的值的列表。这个列表的大小可以在创建SharedFlow时设置。

SharedFlow的源代码如下：

public abstract class SharedFlow<out T> : Flow<T> {public abstract val replayCache: List<T>
}

在这段代码中，我们可以看到SharedFlow只有一个replayCache属性，没有value属性。这反映了SharedFlow和StateFlow的主要区别：SharedFlow没有一个固定的当前值，而StateFlow有。

StateFlow和SharedFlow的联系和区别

StateFlow和SharedFlow都是热Flow，它们都可以广播值给多个观察者。然而，它们在如何处理这些值方面有一些关键的区别。StateFlow始终有一个当前值，而SharedFlow没有。相反，SharedFlow只是广播它接收到的所有值。

另一方面，SharedFlow可以有一个回放缓存，这是一个包含最近发出的值的列表。这个列表的大小可以在创建SharedFlow时设置。而StateFlow的回放缓存总是只包含当前的状态值。

StateFlow的使用示例

让我们看一个StateFlow的使用示例。在这个例子中，我们有一个名为uiState的StateFlow，它保存了UI的状态。

private val _uiState = MutableStateFlow(UiState())
val uiState: StateFlow<UiState> = _uiState

在这个例子中，我们首先创建了一个MutableStateFlow，它是一个可以改变的StateFlow。然后，我们创建了一个只读的StateFlow，它的值是MutableStateFlow的值。这样，我们可以在内部改变_uiState的值，但外部只能观察uiState的值。

SharedFlow的使用示例

现在让我们看一个SharedFlow的使用示例。在这个例子中，我们有一个名为events的SharedFlow，它用于发送事件。

private val _events = MutableSharedFlow<Event>()
val events: SharedFlow<Event> = _events

在这个例子中，我们首先创建了一个MutableSharedFlow，它是一个可以改变的SharedFlow。然后，我们创建了一个只读的SharedFlow，它的值是MutableSharedFlow的值。这样，我们可以在内部发送事件到_events，但外部只能观察events。

StateFlow和SharedFlow的比较

从这两个例子中，我们可以看出StateFlow和SharedFlow的一些关键区别。StateFlow有一个固定的当前值，这个值可以被观察者获取。这使得StateFlow非常适合用于表示状态，如UI状态。

另一方面，SharedFlow没有固定的当前值。相反，它只是广播它接收到的所有值。这使得SharedFlow非常适合用于表示事件，如用户操作。

复杂的StateFlow示例

在这个例子中，我们有一个名为uiState的StateFlow，它保存了UI的状态。我们还有一个名为loadData的函数，它从网络加载数据，并更新uiState。

private val _uiState = MutableStateFlow(UiState())
val uiState: StateFlow<UiState> = _uiStatesuspend fun loadData() {_uiState.value = UiState.Loadingval data = repository.loadData()_uiState.value = UiState.Success(data)
}

在这个例子中，loadData函数首先将uiState的值设置为Loading，然后加载数据，最后将uiState的值设置为Success。这样，观察者可以观察到uiState的变化，并根据其值来更新UI。

复杂的SharedFlow示例

在这个例子中，我们有一个名为events的SharedFlow，它用于发送事件。我们还有一个名为sendEvent的函数，它发送一个事件到events。

private val _events = MutableSharedFlow<Event>()
val events: SharedFlow<Event> = _eventssuspend fun sendEvent(event: Event) {_events.emit(event)
}

在这个例子中，sendEvent函数发送一个事件到events。观察者可以观察到events，并根据接收到的事件来执行相应的操作。

`StateFlow`和`SharedFlow`的比较

从这两个例子中，我们可以看到StateFlow和SharedFlow在复杂场景下的使用。StateFlow非常适合用于表示可以随时间变化的状态，如UI状态。SharedFlow则非常适合用于表示一次性的事件，如用户操作。

StateFlow和SharedFlow的区别

StateFlow和SharedFlow虽然都是Flow，但它们有一些关键的区别。

StateFlow有一个固定的当前值，这个值可以被观察者获取。这使得StateFlow非常适合用于表示状态，如UI状态。
SharedFlow没有固定的当前值。相反，它只是广播它接收到的所有值。这使得SharedFlow非常适合用于表示事件，如用户操作。

StateFlow和SharedFlow的使用建议

在选择使用StateFlow还是SharedFlow时，你应该根据你的需求来决定。

如果你需要表示一个可以随时间变化的状态，你应该使用StateFlow。例如，你可以使用StateFlow来表示UI的状态。
如果你需要表示一次性的事件，你应该使用SharedFlow。例如，你可以使用SharedFlow来表示用户操作。

这就是我们对StateFlow和SharedFlow的深入理解。希望这篇文章能帮助你更好地理解和使用Kotlin的Flow。

举例说明

在我们的应用中，我们有一个购物车功能。购物车的内容是一个状态，它随着用户添加或删除商品而变化。我们可以使用StateFlow来表示这个状态。

private val _cart = MutableStateFlow<List<Product>>(emptyList())
val cart: StateFlow<List<Product>> = _cartsuspend fun addProduct(product: Product) {_cart.value = _cart.value + product
}suspend fun removeProduct(product: Product) {_cart.value = _cart.value - product
}

在这个例子中，我们有一个名为cart的StateFlow，它表示购物车的内容。我们还有两个函数addProduct和removeProduct，它们分别用于添加商品到购物车和从购物车中删除商品。

另一方面，我们的应用还有一个消息通知功能。当有新消息时，我们需要通知所有的观察者。我们可以使用SharedFlow来实现这个功能。

private val _messages = MutableSharedFlow<Message>()
val messages: SharedFlow<Message> = _messagessuspend fun sendMessage(message: Message) {_messages.emit(message)
}