Flutter之异步编程（下）

最新推荐文章于 2024-03-24 10:19:21 发布
最新推荐文章于 2024-03-24 10:19:21 发布
阅读量1k 收藏 1
点赞数
分类专栏： Flutter移动开发 文章标签： flutter
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43547255/article/details/123702716
版权

Flutter之异步编程（下）
Stream

Stream是Dart语言中所谓异步数列的东西，直白点就是一个异步数据队列。为了控制Stream我们通常采用StreamController来进行管理，sink作为入口函数，StreamController提供stream属性作为数据的出口，StreamController.stream.listen用来监听Stream是否有数据

一、Stream分类
  • 单订阅流
  • 多订阅流
二、Stream 创建
  Flutter 提供了多种创建 Stream 的方式；

1.Stream.periodic

//stream_create_periodic.dart文件
import 'dart:async';

void main(){
  //创建Stream
  createStream();
}

createStream() async{
  //使用periodic创建流,第一个参数为间隔时间,第二个参数为回调函数
  Stream<int> stream = Stream<int>.periodic(Duration(seconds: 1), callBack);
  //await for循环从流中读取
  await for(var i in stream){
    print(i);
  }
}

//可以在回调函数中对值进行处理,这里直接返回了
int callBack(int value){
  return value;
}

2.Stream.fromFutrue

//stream_create_from_future.dart文件
import 'dart:async';

void main(){
  //创建一个Stream
  createStream();
}

createStream() async{
  print("开始测试");
  //创建一个Future对象
  Future<String> future = Future((){
    return "异步任务";
  });

  //从Future创建Stream
  Stream<String> stream = Stream<String>.fromFuture(future);
  //await for循环从流中读取
  await for(var s in stream){
    print(s);
  }
  print("结束测试");
}

3.Stream.fromFutrues

//stream_create_from_futures.dart文件
import  'dart:io';

void main(){
  //从多个Future创建Stream
  createStreamFromFutures();
}

createStreamFromFutures() async{
  print("开始测试");

  Future<String> future1 = Future((){
    //模拟耗时5秒
    sleep(Duration(seconds:5));
    return "异步任务1";
  });

  Future<String> future2 = Future((){
    return "异步任务2";
  });

  Future<String> future3 = Future((){
    return "异步任务3";
  });

  //将多个Future放入一个列表中,将该列表传入
  Stream<String> stream = Stream<String>.fromFutures([future1,future2,future3]);
  //读取Stream
  await for(var s in stream){
    print(s);
  }
  
  print("结束测试");
}

4.Stream.fromIterable

//stream_create_from_iterable.dart文件
import 'dart:async';

void main(){
  //从一个集合创建Stream
  createStream();
}

createStream() async{
  print("开始测试");
  //从集合创建Stream
  Stream<int> stream = Stream<int>.fromIterable([1,2,3,4,5,6]);
  //读取Stream
  await for(var s in stream){
    print(s);
  }
  print("结束测试");
}
  1. Stream 操作方法
    1.stream.take
//stream_take.dart文件
import 'dart:async';

void main(){
  //创建Stream
  createStream();
}

void createStream() async{
  //时间间隔为1秒
  Duration interval = Duration(seconds: 1);
  //每隔1秒发送1次的事件流
  Stream<int> stream = Stream.periodic(interval, (data) => data);
  //指定发送事件个数
  stream = stream.take(10);
  //输出Stream
  await for(int i in stream ){
    print(i);
  }
}

2.stream.takeWhile

//stream_take_while.dart文件
import 'dart:async';

void main(){
  //创建Stream
  createStream();
}

void createStream() async {
  //时间间隔为1秒
  Duration interval = Duration(seconds: 1);
  //每隔1秒发送1次的事件流
  Stream<int> stream = Stream.periodic(interval, (data) => data);
  //根据返回结果做返回值的限制
  stream = stream.takeWhile((data) {
    //返回值的限制条件
    return data < 8;
  });
  //输出Stream
  await for (int i in stream) {
    print(i);
  }
}

3.stream.skio(int count)

//stream_skip.dart文件
import 'dart:async';

void main(){
  //创建Stream,跳过指定个数元素
  testSkip();
}

void testSkip() async {
  //时间间隔为1秒
  Duration interval = Duration(seconds: 1);
  //每隔1秒发送1次的事件流
  Stream<int> stream = Stream.periodic(interval, (data) => data);
  //指定发送事件次数
  stream = stream.take(10);
  //跳过前两个元素
  stream = stream.skip(2);
  //输出Stream
  await for (int i in stream) {
    print(i);
  }
}

4.stream.skioWhile

//stream_skip_while.dart文件
import 'dart:async';

void main(){
  //创建Stream,按条件跳过元素
  testSkipWhile();
}

void testSkipWhile() async {
  //时间间隔为1秒
  Duration interval = Duration(seconds: 1);
  //每隔1秒发送1次的事件流
  Stream<int> stream = Stream.periodic(interval, (data) => data);
  //指定发送事件个数
  stream = stream.take(10);
  //根据条件跳过元素,条件为返回值小于5
  stream = stream.skipWhile((data) => data<5);
  //输出Stream
  await for (int i in stream) {
    print(i);
  }
}

5.stream.toList()

//stream_to_list.dart文件
import 'dart:async';

void main(){
  //创建Stream,将流中的数据放在List里
  testToList();
}

void testToList() async {
  //时间间隔为1秒
  Duration interval = Duration(seconds: 1);
  //每隔1秒发送1次的事件流
  Stream<int> stream = Stream.periodic(interval, (data) => data);
  //指定发送事件个数
  stream = stream.take(10);
  //将流中所有的数据收集存放在List中
  List<int> listData = await stream.toList();
  //输出List数据
  for(int i in listData){
    print(i);
  }
}

5.stream.listen()

//stream_listen.dart文件
import 'dart:async';

void main(){
  //创建Stream,使用list方法监听流
  testListen();
}

void testListen() async {
  //时间间隔为1秒
  Duration interval = Duration(seconds: 1);
  //每隔1秒发送1次的事件流
  Stream<int> stream = Stream.periodic(interval, (data) => data);
  stream = stream.take(10);
  //监听流
  stream.listen((data){
    print(data);
  },onError:(error){
    print("流发生错误");
  },onDone:(){
    print("流已完成");
  }, cancelOnError: false);
}

6.stream.forEach()

//stream_for_each.dart文件
import 'dart:async';

void main(){
  //创建Stream,使用Stream的forEach迭代输出数据
  testForEach();
}

void testForEach() async {
  //时间间隔为1秒
  Duration interval = Duration(seconds: 1);
  //每隔1秒发送1次的事件流
  Stream<int> stream = Stream.periodic(interval, (data) => data);
  stream = stream.take(5);
  //Stream迭代输出数据
  stream.forEach((data) {
    print(data);
  });
}

7.stream.length

//stream_length.dart文件
import 'dart:async';

void main(){
  //创建Stream,并统计事件的总数量
  testStreamLength();
}

void testStreamLength() async {
  //时间间隔为1秒
  Duration interval = Duration(seconds: 1);
  //每隔1秒发送1次的事件流
  Stream<int> stream = Stream.periodic(interval, (data) => data);
  stream = stream.take(5);
  //统计事件的总数量
  var allEvents = await stream.length;
  print(allEvents);
}

8.stream.length

//stream_length.dart文件
import 'dart:async';

void main(){
  //创建Stream,并统计事件的总数量
  testStreamLength();
}

void testStreamLength() async {
  //时间间隔为1秒
  Duration interval = Duration(seconds: 1);
  //每隔1秒发送1次的事件流
  Stream<int> stream = Stream.periodic(interval, (data) => data);
  stream = stream.take(5);
  //统计事件的总数量
  var allEvents = await stream.length;
  print(allEvents);
}

8.stream.where

//stream_where.dart文件
import 'dart:async';

void main(){
  //创建Stream,并按指定条件筛选出数据
  testWhere();
}

void testWhere() async {
  //时间间隔为1秒
  Duration interval = Duration(seconds: 1);
  //每隔1秒发送1次的事件流
  Stream<int> stream = Stream.periodic(interval, (data) => data);
  //筛选条件为返回值大于2的所有数据
  stream = stream.where((data)=>data>2);
  //筛选条件为返回值小于6的所有数据
  stream = stream.where((data)=> data<6);
  //最后取上面两件条件都满足的数据
  await for(int i in stream){
    print(i);
  }
}
三、StreamController使用

上面直接创建流的方式在实际开发中用途不是很大，基本都是用StreamController来创建流

构建单订阅流

//stream_single.dart文件
import 'dart:async';

void main(){
  //StreamController里面会创建一个Stream,我们实际操控的Stream
  StreamController<String> streamController = StreamController();
  //监听流数据
  streamController.stream.listen((data)=> print(data));
  //添加数据
  streamController.sink.add("aaa");
  //添加数据
  streamController.add("bbb");
  //添加数据
  streamController.add("ccc");
  //关闭流
  streamController.close();
}

构建多订阅流

  • 直接创建多订阅流
//stream_broadcast.dart文件
import 'dart:async';

void main(){
  //使用StreamController的broadcast方法可以直接创建多订阅流
  StreamController<String> streamController = StreamController.broadcast();
  //第一个监听
  streamController.stream.listen((data){
    print('第一次的监听数据:'+ data);
  },onError: (error){
    print(error.toString());
  });
  //第一个监听
  streamController.stream.listen((data){
      print('第二次的监听数据:'+ data);
  });
  //添加数据
  streamController.add("Dart...");
}

将单订阅流转化为多订阅流

//stream_as_broadcast.dart文件
import 'dart:async';

void main(){
  //实例化StreamController对象
  StreamController<String> streamController = StreamController();
  //将单订阅流转换成多订阅流
  Stream stream =streamController.stream.asBroadcastStream();
  //添加第一次监听
  stream.listen((data){
    print('第一次的监听数据:'+ data);
  });
  //添加第二次监听
  stream.listen((data){
    print('第二次的监听数据:'+ data);
  });
  streamController.sink.add("Dart...");
  //关闭流
  streamController.close();
}
四、StreamBuilder

Futter里面提供了一个Widget名叫StreamBuilder其实是一直记录这流中最新的数据，当数据流发生变化时，会自动调用build方法重新渲染组件

//stream_stream_builder.dart文件
import 'dart:async';
import 'package:flutter/material.dart';

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'StreamBuilder示例',
      home: MyHomePage(),
    );
  }
}

//有状态组件
class MyHomePage extends StatefulWidget {
  @override
  _MyHomePageState createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  //计数器值
  int _count = 0;
  //实例化一个StreamController对象
  final StreamController<int> _streamController = StreamController();

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('StreamBuilder示例'),
      ),
      body: Container(
        child: Center(
          //StreamBuilder组件,数据类型为int
          child: StreamBuilder<int>(
              //指定stream属性
              stream: _streamController.stream,
              //构建器,可以通过AsyncSnapshot拿到流中的数据
              builder: (BuildContext context, AsyncSnapshot snapshot) {
                //这里不需要_count值,从流中取出data即可
                return snapshot.data == null
                    ? Text("0",style: TextStyle(fontSize: 36.0))
                    : Text("${snapshot.data}", style: TextStyle(fontSize: 36.0),
                );
              }),
        ),
      ),
      //操作按钮
      floatingActionButton: FloatingActionButton(
          child: const Icon(Icons.add),
          onPressed: (){
            //向Stream里添加数据
            _streamController.sink.add(++_count);
          }),
    );
  }

  @override
  void dispose() {
    //当界面销毁时关闭Stream流
    _streamController.close();
    super.dispose();
  }
}

响应式编程，Bloc解耦

//stream_bloc_base.dart文件
//定义Bloc抽象类
abstract class BlocBase {
  //定义销毁方法,子类必需实现此方法
  void dispose();
}

//stream_bloc_counter.dart文件
import 'dart:async';
import 'bloc_base.dart';

//继承BlocBase
class BlocCounter extends BlocBase {

  //初例化StreamController,数据类型为int
  final _controller = StreamController<int>();

  //获取到StreamController的sink,即入口可以添加数据
  get _counter => _controller.sink;

  //获取到StreamController的stream,即出口可以取数据
  get counter => _controller.stream;

  //增加计算器值
  void increment(int count) {
    //向流中添加数据
    _counter.add(++count);
  }

  //销毁
  void dispose() {
    //关闭流
    _controller.close();
  }
}

//stream_bloc_main.dart文件
import 'package:flutter/material.dart';

import 'blocs/bloc_counter.dart';

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Bloc示例',
      home: MyHomePage(),
    );
  }
}

class MyHomePage extends StatefulWidget {
  @override
  _MyHomePageState createState() => _MyHomePageState(BlocCounter());
}

class _MyHomePageState extends State<MyHomePage> {

  //组件计数变量
  int _counter = 0;

  //计数器Bloc
  final BlocCounter bloc;

  _MyHomePageState(this.bloc);

  //计数增加方法
  void _incrementCounter() {
    //调用bloc的方法
    bloc.increment(_counter);
  }

  @override
  void initState() {
    //监听Bloc里的数据
    bloc.counter.listen((_count) {
      //设置状态值
      setState(() {
        _counter = _count;
      });
    });
    super.initState();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('Bloc示例'),
      ),
      body: Center(
        child: Text(
          '$_counter',
          style: Theme.of(context).textTheme.display1,
        ),
      ),
      //增加按钮
      floatingActionButton: FloatingActionButton(
        //点击事件
        onPressed: _incrementCounter,
        child: Icon(Icons.add),
      ),
    );
  }
}
可可鸭~
关注
专栏目录
Flutter异步编程：掌握Streams和Futures的流动艺术
07-10
Flutter使用Dart语言作为开发语言，这是一门简洁、强类型、并且专为客户端应用性能设计的编程语言。 ### Flutter的主要特点包括： 1. **跨平台**：Flutter允许开发者编写一次代码，同时编译为iOS和Android两个平台...
Flutter 知识点集结
ai_pple的博客
09-29 581
Flutter生命周期 一个StatefulWidget的生命周期 APP进入前后台 WidgetsBindingObserver class _MyScreenState extends State<MyScreen> with WidgetsBindingObserver void initState() { super.initState(); WidgetsBinding.instance.addObserver(this); } void dispose
【Flutter 异步编程 - 玖】 | 学习 Stream 的元素转换操作
张风捷特烈的博客
11-15 573
theme: cyanosis 本文为稀土掘金技术社区首发签约文章，14天内禁止转载，14天后未获授权禁止转载，侵权必究！ 张风捷特烈 - 出品 0. 前言 - 测试说明 Stream 是一种可连续监听的 事件序列 ，它本质上是对 发布-订阅 模式的具体实现，人们习惯于称其为 响应式 模式。很多编程语言都有 Rx[language] ， 它们由 【ReactiveX】 ...
Flutter学习之旅，集合Iterable（List、Set、Map）。
qq_27793151的博客
05-22 3957
Iterable的集合 迭代对象是各种Dart应用程序的基本构建块，即使您没有注意到，您可能已经在使用它们。本文可帮助您充分利用它们。 本文涵盖以下内容： 如何读取Iterable的元素。 如何检查Iterable的元素是否满足条件。 如何过滤Iterable的内容。 如何将Iterable的内容映射到其他值。 什么是集合？ 集合是代表一组对象（称为元素）的对象。可迭代对象是一种集合。 集合可以为空，也可以包含许多元素。根据目的，集合可以具有不同的结构和实现。这些是一些最常见的集合类型：
入坑 Flutter 前你需要知道的一些 XXX
AigeStudio
08-23 4831
扳指一算，这已经是 Flutter 出道的第三个年头了。这两年来，用它写过几个类似计算器、手电筒、罗盘之类小到不能再小的应用，也算是对其有一点点拙见，本文纯属爽完后的瞎掰，不涉及过多的代码，只对准备入坑或者想要入坑的童鞋简单地聊一聊 Flutter，包括它的基础架构、设计原理、应用场景以及未来发展等等。 What is Flutter? Flutter 是什么？套用目前 Flutter 官网的原话...
flutter入门之dart中的并发编程、异步和事件驱动详解
Dream It Possible
11-28 1451
在java开发中，我们进行并发编程的时候，经常会使用future来处理任务，获取返回的结果，或者延迟处理任务等操作，而在dart中，我们执行一个任务同样也可以使用future来处理，而Future默认情况下执行的是一个event-queue任务，也就是和我们正常执行的业务逻辑一样的任务级别，然而future提供了多个api和特性来完成任务队列的使用，例如我们在js开发的时候经常使用ajax的then函数进行回调，then中的参数即为当前任务执行完的参数，我们可以在。isolate自身的任务又是如何处理的？
【Flutter】Future 与 FutureBuilder 异步编程代码示例.zip
08-26
【Flutter】Future 与 FutureBuilder 异步编程代码示例 ( FutureBuilder 构造函数设置 | 处理 Flutter 中文乱码 | 完整代码示例 ) https://hanshuliang.blog.csdn.net/article/details/119924412 博客源码快照
Flutter异步风暴：揭秘UI更新的极速之旅
最新发布
07-10
Flutter使用Dart语言作为开发语言，这是一门简洁、强类型、并且专为客户端应用性能设计的编程语言。 ### Flutter的主要特点包括： 1. **跨平台**：Flutter允许开发者编写一次代码，同时编译为iOS和Android两个平台...
flutter开发之dart语言
06-12
3. 异步编程：Dart的异步处理非常强大，使用`async/await`语法可以编写简洁的异步代码，避免回调地狱。 4. 静态类型：Dart虽然支持动态类型，但推荐使用静态类型，以提高编译时的错误检查和性能。 5. 原生性能：...
Flutter之商用项目实战——直播回放
06-17
1. **Dart语言**：Flutter的基础是Dart编程语言，它是一种现代、面向对象、类型安全的语言，支持函数式和命令式编程风格。Dart的强项在于它的编译速度、垃圾回收机制以及对异步操作的良好支持。 2. **Widget体系**...
flutter_take_5：Flutter Take 5视频系列
02-04
flutter_take_5 Flutter Take 5视频系列 01-您的第一个项目 博客文章： ： 视频： ： 来源： ：
Flutter/Dart第03天：Dart可迭代集合
老牛啊
09-28 76
在Dart学习的第02天，我们通过基础语法说明和样例代码的方式，学习了Dart的16个基础语法，这些基础语法给我们后面编写的Flutter程序打下来坚实基础。今天，我们继续深入学习Dart乃至所有编程语言都非常重要的部分：可迭代的集合……
Flutter Stream 简介及部分操作符使用
2401_83703999的博客
03-24 986
这里我希望可以帮助到大家提升进阶。Android学习PDF+架构视频+面试文档+源码笔记高级架构技术进阶脑图、Android开发面试专题资料，高级进阶架构资料这几块的内容。非常适合近期有面试和想在技术道路上继续精进的朋友。喜欢本文的话，不妨给我点个小赞、评论区留言或者转发支持一下呗~《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》点击传送门，即可免费领取！级架构技术进阶脑图、Android开发面试专题资料，高级进阶架构资料** 这几块的内容。
Flutter有用知识点集锦
jamesxchen的博客
02-27 800
我是初学者，只是做记录。。。 １、截取数组 //源数据 List aa = [1,2,3,4,5,6,7,8]; //目录，截取3,4,5,6 //用数组take和skip成员函数 //take(n)，从当前开始的n个 //skip(n)，从当前位置跳过n个 //3,4,5,6就是从初始位置跳过2个，并从那个位置开始取4个 List bb = aa.skip(2).take(4); ...
【Dart 教程系列第 26 篇】Dart 之 takeWhile 从索引为 0 位置处，查询满足指定条件的元素
“Allen Su”的博客
09-09 727
Dart 之 takeWhile 从索引为 0 位置处，查询满足指定条件的元素
rxjava : take / takeLast / takeUntil / takeWhile
火星男孩的分享空间
09-24 1642
//take : 取前n个item @Test public void take() { Disposable disposable = Observable.just(1, 2, 3, 4, 5) .take(3)// 发射这个被观察者的【前n个item】，这里为取前三个 .subscribe(new Consumer<Integ...
谨慎使用TakeWhile来筛选数据
Here I am
02-25 1020
    对于实现IEnumerable接口的集合，当我们使用TakeWhile来筛选数据的时候，要注意TakeWhile在顺序执行过程中，一旦发现查询条件不符合，就会马上终止，而不会继续筛选后面的数据，下面是一个例子：int[] test = new int[]{5,6,7, 11, 2, 8,12,1};var r = test.TakeWhile(a => a < 10);Co
RxJava（十四）interval、takeWhile 操作符实现获取验证码功能
Chiclaim
01-11 3335
RxJava系列文章目录导读： 一、RxJava create操作符的用法和源码分析 二、RxJava map操作符用法详解 三、RxJava flatMap操作符用法详解 四、RxJava concatMap操作符用法详解 五、RxJava onErrorResumeNext操作符实现app与服务器间token机制 六、RxJava retryWhen操作符...
Flutter伪异步实现：Future与消息队列解析
Future是Flutter异步编程的核心，它表示一个可能尚未完成的异步操作的结果。当你创建一个Future时，实际上是在将一个回调函数添加到消息队列中等待执行。例如： ```dart void test() { print("AA"); Future(() ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

可可鸭~

想吃糖~我会甜

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值