2024年Kotlin flow实践总结_flow combine，2024年最新美团面试java

于 2024-05-14 07:28:58 发布
阅读量800 收藏 20
点赞数 17
分类专栏： 程序员 文章标签： 鸿蒙 面试 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84851314/article/details/138834423
版权

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

Image.png

  • 冷流：当执行collect的时候（也就是有消费者的时候），生产者才开始发射数据流。
    生产者与消费者是一对一的关系。当生产者发送数据的时候，对应的消费者才可以收到数据。
  • 热流：不管有没有执行collect（也就是不管有没有消费者），生产者都会发射数据流到内存中。
    生产者与消费者是一对多的关系。当生产者发送数据的时候，多个消费者都可以收到数据

实践场景

场景一：简单列表数据的加载状态

简单的列表显示场景，可以使用onStart，onEmpty，catch，onCompletion等回调操作符，监听数据流的状态，显示相应的加载状态UI。

  • onStart：在数据发射之前触发，onStart所在的线程，是数据产生的线程
  • onCompletion：在数据流结束时触发，onCompletion所在的线程，是数据产生的线程
  • onEmpty：当数据流结束了，缺没有发出任何元素的时候触发。
  • catch：数据流发生错误的时候触发
  • flowOn：指定上游数据流的CoroutineContext，下游数据流不会受到影响
private fun coldFlowDemo() {
    //创建一个冷流，在3秒后发射一个数据
    val coldFlow = flow<Int> {
        delay(3000)
        emit(1)
    }
    lifecycleScope.launch(Dispatchers.IO) {
        coldFlow.onStart {
            Log.d(TAG, "coldFlow onStart, thread:${Thread.currentThread().name}")
            mBinding.progressBar.isVisible = true
            mBinding.tvLoadingStatus.text = "加载中"
        }.onEmpty {
            Log.d(TAG, "coldFlow onEmpty, thread:${Thread.currentThread().name}")
            mBinding.progressBar.isVisible = false
            mBinding.tvLoadingStatus.text = "数据加载为空"
        }.catch {
            Log.d(TAG, "coldFlow catch, thread:${Thread.currentThread().name}")
            mBinding.progressBar.isVisible = false
            mBinding.tvLoadingStatus.text = "数据加载错误:$it"
        }.onCompletion {
            Log.d(TAG, "coldFlow onCompletion, thread:${Thread.currentThread().name}")
            mBinding.progressBar.isVisible = false
            mBinding.tvLoadingStatus.text = "加载完成"
        }
            //指定上游数据流的CoroutineContext，下游数据流不会受到影响
            .flowOn(Dispatchers.Main)
            .collect {
                Log.d(TAG, "coldFlow collect:$it, thread:${Thread.currentThread().name}")
            }
    }
}

比如上面的例子。 使用flow构建起函数，创建一个冷流，3秒后发送一个值到数据流中。 使用onStart，onEmpty，catch，onCompletion操作符，监听数据流的状态。

日志输出：

coldFlow onStart, thread:main
coldFlow onCompletion, thread:main
coldFlow collect:1, thread:DefaultDispatcher-worker-1

场景二：同一种数据，需要加载本地数据和网络数据

在实际的开发场景中，经常会将一些网络数据保存到本地，下次加载数据的时候，优先使用本地数据，再使用网络数据。
但是本地数据和网络数据的加载完成时机不一样，所以可能会有下面几种场景。

  1. 本地数据比网络数据先加载完成：那先使用本地数据，再使用网络数据
  2. 网络数据比本地数据先加载完成：
  • 网络数据加载成功，那只使用网络数据即可，不需要再使用本地数据了。
  • 网络数据加载失败，可以继续尝试使用本地数据进行兜底。
  1. 本地数据和网络数据都加载失败：通知上层数据加载失败
实现CacheRepositity

将上面的逻辑进行简单封装成一个基类，CacheRepositity。
相应的子类，只需要实现两个方法即可。

  • CResult：代表加载结果，Success 或者 Error。
  • fetchDataFromLocal()，实现本地数据读取的逻辑
  • fetchDataFromNetWork()，实现网络数据获取的逻辑
abstract class CacheRepositity<T> {
    private val TAG = "CacheRepositity"

    fun getData() = channelFlow<CResult<T>> {
        supervisorScope {
            val dataFromLocalDeffer = async {
                fetchDataFromLocal().also {
                    Log.d(TAG,"fetchDataFromLocal result:$it , thread:${Thread.currentThread().name}")
                    //本地数据加载成功  
                    if (it is CResult.Success) {
                        send(it)
                    }
                }
            }

            val dataFromNetDeffer = async {
                fetchDataFromNetWork().also {
                    Log.d(TAG,"fetchDataFromNetWork result:$it , thread:${Thread.currentThread().name}")
                    //网络数据加载成功  
                    if (it is CResult.Success) {
                        send(it)
                        //如果网络数据已加载，可以直接取消任务,就不需要处理本地数据了
                        dataFromLocalDeffer.cancel()
                    }
                }
            }

            //本地数据和网络数据，都加载失败的情况
            val localData = dataFromLocalDeffer.await()
            val networkData = dataFromNetDeffer.await()
            if (localData is CResult.Error && networkData is CResult.Error) {
                send(CResult.Error(Throwable("load data error")))
            }
        }
    }

    protected abstract suspend fun fetchDataFromLocal(): CResult<T>

    protected abstract suspend fun fetchDataFromNetWork(): CResult<T>

}

sealed class CResult<out R> {
    data class Success<out T>(val data: T) : CResult<T>()
    data class Error(val throwable: Throwable) : CResult<Nothing>()
}
测试验证

写个TestRepositity，实现CacheRepositity的抽象方法。
通过delay延迟耗时来模拟各种场景，观察日志的输出顺序。

private fun cacheRepositityDemo(){
    val repositity=TestRepositity()
    lifecycleScope.launch {
        repositity.getData().onStart {
            Log.d(TAG, "TestRepositity: onStart")
        }.onCompletion {
            Log.d(TAG, "TestRepositity: onCompletion")
        }.collect {
            Log.d(TAG, "collect: $it")
        }
    }
}
本地数据比网络数据加载快
class TestRepositity : CacheRepositity<String>() {
    override suspend fun fetchDataFromLocal(): CResult<String> {
        delay(1000)
        return CResult.Success("data from fetchDataFromLocal")
    }

    override suspend fun fetchDataFromNetWork(): CResult<String> {
        delay(2000)
        return CResult.Success("data from fetchDataFromNetWork")
    }
}

模拟数据：本地加载delay1秒，网络加载delay2秒
日志输出：collect 执行两次，先收到本地数据，再收到网络数据。

onStart
fetchDataFromLocal result:Success(data=data from fetchDataFromLocal) , thread:main
collect: Success(data=data from fetchDataFromLocal)
fetchDataFromNetWork result:Success(data=data from fetchDataFromNetWork) , thread:main
collect: Success(data=data from fetchDataFromNetWork)
onCompletion
网络数据比本地数据加载快
class TestRepositity : CacheRepositity<String>() {
    override suspend fun fetchDataFromLocal(): CResult<String> {
        delay(2000)
        return CResult.Success("data from fetchDataFromLocal")
    }

    override suspend fun fetchDataFromNetWork(): CResult<String> {
        delay(1000)
        return CResult.Success("data from fetchDataFromNetWork")
    }
}

模拟数据：本地加载delay 2秒，网络加载delay 1秒
日志输出：collect 只执行1次，只收到网络数据。

onStart
fetchDataFromNetWork result:Success(data=data from fetchDataFromNetWork) , thread:main
collect: Success(data=data from fetchDataFromNetWork)
onCompletion
网络数据加载失败，使用本地数据
class TestRepositity : CacheRepositity<String>() {
    override suspend fun fetchDataFromLocal(): CResult<String> {
        delay(2000)
        return CResult.Success("data from fetchDataFromLocal")
    }

    override suspend fun fetchDataFromNetWork(): CResult<String> {
        delay(1000)
        return CResult.Error(Throwable("fetchDataFromNetWork Error"))
    }
}

模拟数据：本地加载delay 2秒，网络数据加载失败
日志输出：collect 只执行1次，只收到本地数据。

onStart
fetchDataFromNetWork result:Error(throwable=java.lang.Throwable: fetchDataFromNetWork Error) , thread:main
fetchDataFromLocal result:Success(data=data from fetchDataFromLocal) , thread:main
collect: Success(data=data from fetchDataFromLocal)
onCompletion
网络数据和本地数据都加载失败
class TestRepositity : CacheRepositity<String>() {
    override suspend fun fetchDataFromLocal(): CResult<String> {
        delay(2000)
        return CResult.Error(Throwable("fetchDataFromLocal Error"))
    }

    override suspend fun fetchDataFromNetWork(): CResult<String> {
        delay(1000)
        return CResult.Error(Throwable("fetchDataFromNetWork Error"))
    }
}

模拟数据：本地数据加载失败，网络数据加载失败
日志输出: collect 只执行1次，结果是CResult.Error，代表加载数据失败。

onStart


**深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**

![](https://img-blog.csdnimg.cn/direct/743b668910224b259a5ffe804fa6d0db.png)
![img](https://img-blog.csdnimg.cn/img_convert/a647526be9ffbe8df82553c440cbec20.png)
![img](https://img-blog.csdnimg.cn/img_convert/c3979e584bb81e8d6e249707b12b35f5.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上鸿蒙开发知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化的资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618636735)**

8910224b259a5ffe804fa6d0db.png)
[外链图片转存中...(img-Ld4ieJpF-1715642916125)]
[外链图片转存中...(img-kmWkHaBC-1715642916125)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上鸿蒙开发知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化的资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618636735)**
2401_84851314
关注
  • 17
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Kotlin：Flow 全面详细指南，附带源码解析。
Pumpkin's Blog
11-14 7554
Flow 来了来了它终于来了，这篇本应在好几个个月前就需要发布的文章????。一拖再拖????，毕竟对于flow还是的有敬畏之心的，不好好研究一下真心不敢乱写，有什么问题，欢迎指出，欢迎私信技术交流????。那么现在就正式进入Flow的世界吧！ Flow简介 Flow是什么❓ A suspending function asynchronously returns a single value, but how can we return multiple asynchronously computed
Kotlin协程：Flow基础原理
LeeDuoZuiShuai的博客
08-30 1009
AbstractFlow类是一个抽象类，实现了Flow接口和CancellableFlow接口。// 核心方法 @InternalCoroutinesApi public final override suspend fun collect(collector : FlowCollector < T >) {
Kotlin Flow详解
ymeddmn的博客
08-15 9246
官方 flow 地址：https://www.kotlincn.net/docs/reference/coroutines/flow.html flow 说明 流简单使用 suspend fun flow1() { flow<Int> { (0..4).forEach { emit(it)//生产者发送数据 } }.collect { println(it)//消费者处理数据 } } 本例中 flo
Kotlin协程：Flow 异步流
七夜聖君的博客
01-06 1520
Kotlin协程异步流 Flow
Kotlin flow实践总结
嘴巴吃糖了
02-19 4456
背景 最近学了下Kotlin Flow，顺便在项目中进行了实践，做一下总结。 Flow是什么 按顺序发出多个值的数据流。 本质就是一个生产者消费者模型，生产者发送数据给消费者进行消费。 冷流：当执行collect的时候（也就是有消费者的时候），生产者才开始发射数据流。 生产者与消费者是一对一的关系。当生产者发送数据的时候，对应的消费者才可以收到数据。 热流：不管有没有执行collect（也就是不管有没有消费者），生产者都会发射数据流到内存中。 生产者与消费者是一对多的关系。当生产者发送数据的时候，多个
kotlin-flow-extensions：Kotlin Flow库的扩展
02-03
Kotlin Flow 是一个用于处理异步序列的构建块，它在Kotlin中提供了类似于Java 8的Stream API的功能，但更适用于并发和协程环境。Flow库允许开发者以一种安全、简洁的方式处理一系列的数据流，而无需担心线程同步问题...
Flow-Response-Retrofit-Adapter:带有Kotlin Flow支持的Retrofit 2 CallAdapterFactory
03-27
流量响应改造适配器一个小型库，其中包含使用Kotlin Flow实现的网络请求包装程序以及一个允许将此包装与Retrofit 2库一起使用的适配器。用法将添加到您的Retrofit配置中： Retrofit . Builder () // Some other ...
Kotlin_in_Action_v12_MEAP_javaprogramming_kotlin_identityl3j_
09-29
Thanks for purchasing the MEAP for Kotlin in Action! We're looking forward to introducing you to Kotlin
kotlin_flow
02-26
关ルダー关数であるFlowメソッドでFlowオブジェクトを生成する Flowメソッドのblockはsuspend关数になる emitメソッドで値を送信する， collectメソッドで値の受信を开始する 流动很冷 Flowメソッドで作成される， ...
flowmarbles:Kotlin Flow的互动图https
04-14
6. **学习资源**：除了FlowMarbles之外，还可以参考Kotlin官方文档、博客文章、视频教程等，深入学习Kotlin Flow的用法和最佳实践。 总之，FlowMarbles是一个强大的学习和调试工具，通过互动图的方式揭示了Kotlin ...
【Android】Kotlin 中的Flow是个什么东西
每天不是在写bug就是在写bug的路上
06-09 2306
flow
【Kotlin】Flow简介
最新发布
little_fat_sheep
04-24 2065
Flow 是 Kotlin 标准库中的一个新的异步流处理框架，旨在简化异步数据流的操作和处理，它提供了一种声明式的方式来处理数据流。Flow 中一些接口调用有些类似 Sequence（详见 →），协程的使用详见 →。Flow 有以下特性和概念。：Flow 允许以一种非阻塞的方式处理一系列的值或事件，这使得在处理大量数据或涉及 IO 操作时能够更加高效。：只有在收集器（collector）订阅（或启动）了之后才会开始发射（emit）数据。
Kotlin系列之认识一下Flow
datian1234的博客
01-09 793
Flow是谷歌官方提供的一套基于kotlin协程响应式编程模型，与我们熟知的RxJava使用起来类似，但相比较起来，Flow使用起来更加简单，而且Flow是作用在协程内，可以跟协程的生命周期绑定在一起，线程切换起来也比RxJava灵活，所以，我们学习Flow也跟学习RxJava一样，先从操作符开始学。
Kotlin-Flow基础学习
且听真言
10-23 1267
一、Flow简单介绍Flow——数据流Flow的特点是可以在发送和接收的过程中对数据进行变更。
Kotlin数据流 - - - Flow
m0_47914176的博客
02-17 1738
一.Flow的简单使用
Kotlin 协程Flow主要操作符（二）
Gary__123456的博客
04-23 4917
Kotlin 协程Flow主要操作符（二）前言1. collect接收操作符2. launchIn操作符3. onEach操作符4. 组合操作符4.1 zip操作符4.2 combine操作符5. 展平流5.1 flatMapConcat连接模式5.2 flatMapMerge并发模式5.3 flatMapLatest参考 前言 协程操作符的第二篇，请参考第一篇Kotlin 协程Flow主要操作符(一) 1. collect接收操作符 用于数据接收，此操作符没有返回对象，后面不可再添加操作符。 fun
kotlin--Flow的运用
aruba的博客
09-03 1961
Flow是kotlin提供的一个工具，使用协程封装成生产者-消费者模式，上流来负责生产，下流来接收消耗。 一、Flow的使用 1.Flow的创建 1.可以使用flow构建函数构建一个Flow类型返回值的函数 2.flow{}构建体中可以调用挂起函数，即上流 3.上流使用emit函数发射值 4.下流使用collect函数收集值 //上流函数 fun simpleFlow() = flow ...
kotlin flow combine
05-01
Kotlin Flow 中的 combineLatest 和 merge 都是将多个 Flow 合并为一个的操作符，但是它们有着不同的行为和用途。 combineLatest 操作符会在多个 Flow 中的任何一个 Flow 推送新值时重新合并所有 Flow 的最新值，并...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值