Kotlin中Flow的用法及在Jetpack Compose中使用

发表于 更新于 分类于
Kotlin中Flow的用法

前言

在 Android 开发中，Flow 是 Kotlin 协程库提供的一种响应式编程的工具，用于处理异步的、流式的数据序列。

下面将从多个方面详细讲解 Android 开发中的 Flow。

基本概念

Flow 代表一个异步的数据流，它可以发出零个或多个值，并且可以在流的生命周期内处理各种状态，如开始、结束、取消等。

与传统的回调和 RxJava 等响应式库相比，Flow 与 Kotlin 协程紧密集成，使用起来更加简洁和直观。

执行线程

在默认情况下，Flow 中的代码会在调用 collect 方法的协程所在的线程执行。

也就是说，如果 collect 方法是在主线程的协程中调用的，那么 flow 构建器中的代码以及 collect 代码块中的代码都会在主线程执行。

创建 Flow

可以通过多种方式创建 Flow，以下是几种常见的创建方式：

使用 flow 构建器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
    val flow = flow {
        for (i in 1..3) {
            delay(100) // 模拟异步操作
            emit(i) // 发射值
        }
    }
    flow.collect { value ->
        println(value)
    }
}

在上述代码中，flow 构建器用于创建一个 Flow，在 flow 块中使用 emit 函数发射值，collect 函数用于收集 Flow 中的值。

使用 flowOf 函数

1
2
3
4
5
6
7
8
9
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
    val flow = flowOf(1, 2, 3)
    flow.collect { value ->
        println(value)
    }
}

flowOf 函数用于创建一个发射固定值的 Flow。

使用 asFlow 扩展函数

1
2
3
4
5
6
7
8
9
10
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
    val list = listOf(1, 2, 3)
    val flow = list.asFlow()
    flow.collect { value ->
        println(value)
    }
}

asFlow 扩展函数可以将一个集合转换为 Flow。

操作符

Flow 提供了丰富的操作符，用于对数据流进行转换、过滤、合并等操作。

map 操作符

1
2
3
4
5
6
7
8
9
10
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
    val flow = flowOf(1, 2, 3)
    val newFlow = flow.map { value -> value * 2 }
    newFlow.collect { value ->
        println(value)
    }
}

map 操作符用于对 Flow 中的每个值进行转换。

filter 操作符

1
2
3
4
5
6
7
8
9
10
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
    val flow = flowOf(1, 2, 3)
    val newFlow = flow.filter { value -> value % 2 == 0 }
    newFlow.collect { value ->
        println(value)
    }
}

filter 操作符用于过滤 Flow 中的值。

zip 操作符

1
2
3
4
5
6
7
8
9
10
11
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
    val flow1 = flowOf(1, 2, 3)
    val flow2 = flowOf("a", "b", "c")
    val newFlow = flow1.zip(flow2) { a, b -> "$a$b" }
    newFlow.collect { value ->
        println(value)
    }
}

zip 操作符用于将两个 Flow 中的值按顺序配对，并对每对值进行操作。

背压处理

背压是指当生产者发射数据的速度快于消费者处理数据的速度时，可能会导致数据积压的问题。

Flow 提供了多种背压策略来处理这种情况：

buffer 策略

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
    val flow = flow {
        for (i in 1..5) {
            delay(100)
            emit(i)
        }
    }
    flow.buffer().collect { value ->
        delay(200)
        println(value)
    }
}

buffer 策略会将发射的值缓冲起来，以便消费者可以在需要时获取。

conflate 策略

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
    val flow = flow {
        for (i in 1..5) {
            delay(100)
            emit(i)
        }
    }
    flow.conflate().collect { value ->
        delay(200)
        println(value)
    }
}

conflate 策略会丢弃中间值，只处理最新的值。

collectLatest 策略

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
    val flow = flow {
        for (i in 1..5) {
            delay(100)
            emit(i)
        }
    }
    flow.collectLatest { value ->
        println("Processing $value")
        delay(200)
        println("Processed $value")
    }
}

collectLatest 策略会在有新值发射时，取消当前正在处理的值，只处理最新的值。

Android 中的应用

在 Android 开发中，Flow 通常用于处理异步数据，如网络请求、数据库查询等。

以下是一个简单的示例，使用 Flow 进行网络请求：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import retrofit2.http.GET

data class Post(val id: Int, val title: String)

interface ApiService {
    @GET("posts")
    suspend fun getPosts(): List<Post>
}

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

        val retrofit = Retrofit.Builder()
           .baseUrl("https://jsonplaceholder.typicode.com/")
           .addConverterFactory(GsonConverterFactory.create())
           .build()
        val apiService = retrofit.create(ApiService::class.java)

        val postFlow = flow {
            val posts = apiService.getPosts()
            emit(posts)
        }

        lifecycleScope.launch {
            postFlow.collect { posts ->
                for (post in posts) {
                    println(post.title)
                }
            }
        }
    }
}

在上述代码中，使用 Flow 封装了一个网络请求，并在 MainActivity 中使用 lifecycleScope 来收集数据。

通过以上介绍，你应该对 Android 开发中的 Flow 有了一个全面的了解。

Flow 提供了一种简洁、直观的方式来处理异步数据流，并且与 Kotlin 协程紧密集成，使得代码更加易于维护和理解。