七爪源码:Kotlin Flows - 什么、为什么以及如何?

随波逐流！！

作为一名 Android 开发者，我们无法摆脱周围的协程嗡嗡声。当谈到协程时，我们经常会遇到另一个嗡嗡声，我们在 kotlin 中将其称为 FLOW。听起来很酷，它的功能也是如此。那么为什么不从基础开始探索和了解这些酷炫的 kotlin 流程。

在本文中，我们将尝试回答以下有关 kotlin 流程的问题

• 什么是 Flow，它们是做什么的？
• 我们为什么要使用它们？
• 我们应该如何使用它们？
• 取消基础知识
• 流量转换

如果你还没有流动，是时候开始了！

什么是 Flow，它们是做什么的？

流基本上是一些值的序列的发射。是的，这就是流量。就像我们有 LiveData 一样，我们有 Flows。尽管我们不会在此处介绍其中的差异，但您可以开始了解流程的工作原理。

考虑一个场景，我们希望在不阻塞主线程的情况下，在一些计算之后一个接一个地打印接收到的一些值序列。让我们看看如何实现它。

具有常规功能

example() 函数返回一个整数列表，在这里我们立即获得输出，这是同步的。所以这不能完全满足我们的需求。

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        Log.e("Tag", "main start")
        example().forEach { value ->
            Log.e("Tag", "example value: $value")
        }
        Log.e("Tag", "main end")
    }


private fun example() = listOf(1,2,3)

Tag: example value: 1
Tag: example value: 2
Tag: example value: 3

有序列

我们修改示例函数以返回一个序列，每个值等待 1。 在这里，我们看到在输出中打印了所有值之后打印了“主端”。 这意味着这也是同步的，我们必须寻找另一种解决方法。

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    Log.e("Tag", "main start")

    example().forEach { value ->
        Log.e("Tag", "sequence value: $value")
    }

    Log.e("Tag", "main end")
}

private fun example(): Sequence<Int> = sequence {
    for (i in 1..3) {
       Thread.sleep(1000)
       yield(i)
    }
}

Tag: main start
Tag: sequence value: 1
Tag: sequence value: 2
Tag: sequence value: 3
Tag: main end

带暂停功能

挂起函数也是常规函数，它在协程范围内按顺序运行，直到提供挂起的计算。 所以即使这样也无济于事。

随流

现在我们修改我们的 example() 函数来给我们一个流程。 在输出中，我们看到在 flow 收集其值之前打印了“main end”，这表明 flow 没有阻塞我们的主线程并且异步操作。

此外，我们注意到现在 example() 函数不是挂起函数，它会立即返回，我们会继续异步收集流。

override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)

    Log.e("Tag", "main start")

    lifecycleScope.launch {
        example().collect { value ->
            Log.e("Tag", "flow value: $value")
        } 
    }

    Log.e("Tag", "main end")
}

fun example(): Flow<Int> = flow {
    for (i in 1..3) {
        delay(1000)
        emit(i)
    }
}

Tag: main start
Tag: main end
Tag: flow value: 1
Tag: flow value: 2
Tag: flow value: 3

这就是流量的用处。 它们为我们提供了对异步值流的支持。 我们将在本文后面看到如何使用流做更多事情。

我们为什么要使用它们？

我们可以在许多场景中使用流，特别是当我们有一些后台任务正在进行时，它会根据任务的某些状态发出一些数据，我们需要对这些状态做出反应。

它们可能有用的几个场景如下：

在用例中

考虑进行 api 调用，其中我们的 UI 根据 api 调用的响应进行更新，即我们收到错误或成功，或者 api 调用已经开始并且我们需要显示一些正在加载的 UI。 我们在这里要捕获三种不同的状态，因此流在这里是一个不错的选择。

operator fun invoke(id: String): Flow<Resource<SomeModel>> = flow {
    try {
        emit(Resource.Loading<SomeModel>())
        val data = repository.detail(id)
        emit(Resource.Success<SomeModel>(data))
    } catch(e: HttpException) {
        emit(Resource.Error<SomeModel>(e.localizedMessage ?: "An unexpected error occured"))
    } catch(e: IOException) {
        emit(Resource.Error<SomeModel>("Couldn't reach server. Check your internet connection."))
    }
}

getDetails(id).onEach { result ->
    when (result) {
        is Resource.Success -> {
            _state.value = SomeState(data = result.data)
        }
        is Resource.Error -> {
            _state.value = SomeState(
                error = result.message ?: "An unexpected error occured"
            )
        }
        is Resource.Loading -> {
            _state.value = SomeState(isLoading = true)
        }
    }
}.launchIn(viewModelScope)

在流式 API

如果我们正在使用一些流式 API 并且需要经常捕获事件，那么在这种情况下流可以派上用场。

对于事件或数据状态

MutableSharedFlow、MutableStateFlow 等流类型可分别用于 UI 的事件和状态更新。

我们应该如何使用它们？

到目前为止，我们对流程的内容和原因有了一些基本的了解。 现在让我们了解流程的“方式”。

首先是如何使用流量。 出色地！ 通过简单地在流构建器中编写代码或使用 asFlow() 转换任何集合/序列。

fun example(): Flow<Int> = flow {   // flowCollector
    for (i in 1..3) {
        delay(1000)
        emit(i)
    }
}

// converting sequence into flow
fun exampleFlow(): Flow<Int> = (1..10).asFlow()

是的，就是这么简单。 注意这里函数没有挂起。 这意味着函数通过给我们一个操作流来立即返回。

现在有趣且重要的一点是，流仅在收集时才开始执行，即在我们为流设置收集器之前，它们不会开始执行。

这就是为什么流动是冷流。

如果我们将收集两次流，那么它将再次发出值。 考虑下面的代码：

fun example(): Flow<Int> = flow {   // flowCollector
    for (i in 1..3) {
        delay(1000)
        emit(i)
    }
}

// -------- in view model or somewhere else ------- //

example().collect {
    Log.e("Tag", "collected once value: $it")
}
delay(2000)
example().collect {
    Log.e("Tag", "collected again value: $it")
}

它的输出是：

Tag: collected once value: 1
Tag: collected once value: 2
Tag: collected once value: 3
Tag: collected again value: 1
Tag: collected again value: 2
Tag: collected again value: 3

是的！ 这很酷。 让我们更进一步。

取消基础知识

我们知道协程遵循合作取消。 同理，流也坚持合作取消。

Log.e("Tag", "main start")
runBlocking {
    withTimeoutOrNull(2000) {
        exampleFlow().collect {
            Log.e("Tag", "collected value: $it")
        }
    }
}
Log.e("Tag", "main end")

fun exampleFlow(): Flow<Int> = flow {
        for (i in 1..3) {
            delay(1000)
            emit(i)
        }
    }

Tag: main start
Tag: collected value: 1
Tag: main end

正如我们所看到的，一旦时间到了，流就不会发出值，我们只会在时间限制内得到一个值。

流量转换

流可以使用像我们对集合和序列的操作符进行转换。 这些运算符应用于上游流并返回下游流。 这些运算符很冷，就像流一样。

main() {
  Log.e("Tag", "main start")

  runBlocking {
      exampleFlow()
          .filter {
              it % 2 == 0
          }
          .map {
              request(it)
          }
          .collect {
              Log.e("Tag", "collected $it")
          }
  }
  Log.e("Tag", "main end")
  
}

private suspend fun request(value: Int): String {
    delay(1000)
    return "request $value"
}

private fun exampleFlow(): Flow<Int> = (1..10).asFlow()

Tag: main start
Tag: collected request 2
Tag: collected request 4
Tag: collected request 6
Tag: collected request 8
Tag: collected request 10
Tag: main end

考虑这个示例，其中流发出 10 个值，但在上游使用运算符，我们创建了一个新的下游。

• 过滤器运算符过滤掉值。
• Map 运算符将 int 值转换为字符串值，延迟为 1s。
• 然后最后收集打印结果。

在此要注意的一件重要事情是，操作员按顺序执行每个发出的值。

您可以寻找更多的运算符来从给定的流创建新流，这就是流转换的含义。

哇！ 现在我们对 kotlin 中的流有了更好的理解，是时候开始使用流了。 我们将在进一步的文章中讨论更多关于流的内容，但现在这已经足够了。

关注七爪网，获取更多APP/小程序/网站源码资源！