likes
comments
collection
share

03-📝Flutter核心知识|Dart语言快速入门|面向对象【类和对象、泛型、库的使用、异步模型、异步操作】

作者站长头像
站长
· 阅读数 5

03-📝Flutter核心知识|Dart语言快速入门|面向对象【类和对象、泛型、库的使用、异步模型、异步操作】

一、前言

本系列文章旨在快速复习并上手Flutter开发,并在适当分享在项目实战过程中遇到的一些比较有价值的知识内容:

本系列文章内容篇幅如下:

  • 一、了解Flutter开发
      1. Flutter的特性与应用场景
      1. Flutter绘制原理
      1. 与Flutter相关的技术原理
      1. 搭建Flutter开发环境
      1. 创建Flutter项目的几种方式
  • 二、快速入门Flutter开发知识大纲
      1. Dart语言快速入门
      1. Flutter的Widget
  • 三、常见应用功能模块与开源项目
      1. 常见应用功能模块
      1. 不错的开源项目

二、类和对象

Dart是一个面向对象的语言,面向对象中非常重要的概念就是类,类产生了对象。

这一节,我们就具体来学习类和对象,但是Dart对类进行了很多其他语言没有的特性,所以,这里我会花比较长的篇幅来讲解。

1. 类的定义

在Dart中,定义类用class关键字

  • 类通常有两部分组成:
    • 成员(member)和方法(method)
    • 同其他语言的 属性和方法
  • 定义类的伪代码如下:
    class 类名 {
      类型 成员名;
      返回值类型 方法名(参数列表) {
        方法体
      }
    }
    
  • 示例: 编写一个简单的Person类:
    • 这里有一个注意点: 我们在方法中使用属性(成员/实例变量)时,并没有加this
    • Dart的开发风格中,在方法中通常使用属性时,会省略this,但是有命名冲突时,this不能省略
    class Person {
      String name;
    
      eat() {
        print('$name在吃东西');
      }
    }
    
    • 我们来使用这个类,创建对应的对象: 注意:从Dart2开始,new关键字可以省略
    main(List<String> args) {
      // 创建类的对象
      var p = new Person(); // 直接使用Person()也可以创建
    
      // 给对象的属性赋值
      p.name = 'why';
    
      // 调用对象的方法
      p.eat();
    }
    

2. 构造方法

2.1 普通构造方法

我们知道, 当通过类创建一个对象时,会调用这个类的构造方法。

  • 当类中没有明确指定构造方法时,将默认拥有一个无参的构造方法
  • 前面的Person中我们就是在调用这个构造方法.
  • 可以根据自己的需求,定义自己的构造方法:
    • 注意一: 当有了自己的构造方法时,默认的构造方法将会失效,不能使用
      • 当然,你可能希望明确的写一个默认的构造方法,但是会和我们自定义的构造方法冲突;
      • 这是因为Dart本身不支持函数的重载(名称相同, 参数不同的方式)。
    • 注意二: 这里我还实现了toString方法
      class Person {
        String name;
        int age;
      
        Person(String name, int age) {
          this.name = name;
          this.age = age;
        }
      
        @override
        String toString() {
          return 'name=$name age=$age';
        }
      }
      
  • 更简洁的赋值
    • 在实现构造方法时,通常做的事情就是通过 参数属性 赋值
    • 为了简化这一过程, Dart提供了一种更加简洁的语法糖形式.
    • 示例: 上面的构造方法可以优化成下面的写法:
      Person(String name, int age) {
        this.name = name;
        this.age = age;
      }
      // 等同于
      Person(this.name, this.age);
    

2.2 命名构造方法

在开发中, 我们有时候希望实现更多的构造方法 虽然Dart不支持方法(函数)的重载,但我们可以命名构造方法:

class Person {
  String name;
  int age;

  Person() {
    name = '';
    age = 0;
  }
  // 命名构造方法
  Person.withArgments(String name, int age) {
    this.name = name;
    this.age = age;
  }

  @override
  String toString() {
    return 'name=$name age=$age';
  }
}

// 创建对象
var p1 = new Person();
print(p1);
var p2 = new Person.withArgments('why', 18);
print(p2);

在之后的开发中, 我们也可以利用命名构造方法,提供更加便捷的创建对象方式:

  • 比如开发中,我们需要经常将一个Map转成对象,可以提供如下的构造方法
  // 新的构造方法
  Person.fromMap(Map<String, Object> map) {
    this.name = map['name'];
    this.age = map['age'];
  }

  // 通过上面的构造方法创建对象
  var p3 = new Person.fromMap({'name': 'kobe', 'age': 30});
  print(p3);

3. 初始化列表

我们来重新定义一个类Point, 传入x/y,可以得到它们的距离distance:

class Point {
  final num x;
  final num y;
  final num distance;

  // 错误写法
  // Point(this.x, this.y) {
  //   distance = sqrt(x * x + y * y);
  // }

  // 正确的写法
  Point(this.x, this.y) : distance = sqrt(x * x + y * y);
}

上面这种初始化变量的方法, 我们称之为初始化列表(Initializer list)

4. 重定向构造方法

在某些情况下, 我们希望在一个构造方法中去调用另外一个构造方法, 这个时候可以使用重定向构造方法

  • 在一个构造函数中,去调用另外一个构造函数(注意:是在冒号后面使用this调用)
class Person {
  String name;
  int age;

  Person(this.name, this.age);
  Person.fromName(String name) : this(name, 0);
}

5. 常量构造方法

在某些情况下,传入相同值时,我们希望返回同一个对象,这个时候,可以使用常量构造方法.

默认情况下,创建对象时,即使传入相同的参数,创建出来的也不是同一个对象,看下面代码:

  • 这里我们使用identical(对象1, 对象2)函数来判断两个对象是否是同一个对象:
main(List<String> args) {
  var p1 = Person('why');
  var p2 = Person('why');
  print(identical(p1, p2)); // false
}

class Person {
  String name;

  Person(this.name);
}

但是, 如果将构造方法前加const进行修饰,那么可以保证同一个参数,创建出来的对象是相同的

  • 这样的构造方法就称之为常量构造方法
main(List<String> args) {
  var p1 = const Person('why');
  var p2 = const Person('why');
  print(identical(p1, p2)); // true
}

class Person {
  final String name;

  const Person(this.name);
}

常量构造方法有一些注意点:

  • 注意一:拥有常量构造方法的类中,所有的成员变量必须是final修饰的.
  • 注意二: 为了可以通过常量构造方法,创建出相同的对象,不再使用 new关键字,而是使用const关键字
    • 如果是将结果赋值给const修饰的标识符时,const可以省略.

6. 工厂构造方法

dart提供了factory关键字, 用于通过工厂去获取对象

main(List<String> args) {
  var p1 = Person('why');
  var p2 = Person('why');
  print(identical(p1, p2)); // true
}

class Person {
  String name;

  static final Map<String, Person> _cache = <String, Person>{};

  factory Person(String name) {
    if (_cache.containsKey(name)) {
      return _cache[name];
    } else {
      final p = Person._internal(name);
      _cache[name] = p;
      return p;
    }
  }

  Person._internal(this.name);
}

7. setter和getter

默认情况下,Dart中类定义的属性是可以直接被外界访问的。

但是某些情况下,我们希望监控这个类的属性被访问的过程,这个时候就可以使用setter和getter

main(List<String> args) {
  final d = Dog("黄色");
  d.setColor = "黑色";
  print(d.getColor);
}

class Dog {
  String color;

  String get getColor {
    return color;
  }
  set setColor(String color) {
    this.color = color;
  }

  Dog(this.color);
}

8. 类的继承

面向对象的其中一大特性就是继承,继承不仅仅可以减少我们的代码量,也是多态的使用前提。 dart中的继承使用extends关键字,子类中使用super来访问父类。

父类中的所有成员变量和方法都会被继承,,但是构造方法除外。

main(List<String> args) {
  var p = new Person();
  p.age = 18;
  p.run();
  print(p.age);
}

class Animal {
  int age;

  run() {
    print('在奔跑ing');
  }
}

class Person extends Animal {

}

子类可以拥有自己的成员变量, 并且可以对父类的方法进行重写

class Person extends Animal {
  String name;

  @override
  run() {
    print('$name在奔跑ing');
  }
}

子类中可以调用父类的构造方法,对某些属性进行初始化:

  • 子类的构造方法在执行前,将隐含调用父类的无参默认构造方法(没有参数且与类同名的构造方法)。
  • 如果父类没有无参默认构造方法,则子类的构造方法必须在初始化列表中通过super显式调用父类的某个构造方法。
class Animal {
  int age;

  Animal(this.age);

  run() {
    print('在奔跑ing');
  }
}

class Person extends Animal {
  String name;

  Person(String name, int age) : name=name, super(age);

  @override
  run() {
    print('$name在奔跑ing');
  }

  @override
  String toString() {
    return 'name=$name, age=$age';
  }
}

9. 抽象类

我们知道,继承是多态使用的前提。

所以在定义很多通用的 调用接口 时, 我们通常会让调用者传入父类,通过多态来实现更加灵活的调用方式。

但是,父类本身可能并不需要对某些方法进行具体的实现,所以父类中定义的方法,,我们可以定义为 抽象方法

什么是 抽象方法? 在Dart中没有具体实现的方法(没有方法体),就是抽象方法。

  • 抽象方法,必须存在于抽象类中。
  • 抽象类是使用abstract声明的类。

下面的代码中, Shape类就是一个抽象类, 其中包含一个抽象方法.

abstract class Shape {
  getArea();
}

class Circle extends Shape {
  double r;

  Circle(this.r);

  @override
  getArea() {
    return r * r * 14;
  }
}

class Reactangle extends Shape {
  double w;
  double h;

  Reactangle(this.w, this.h);

  @override
  getArea() {
    return w * h;
  }
}

注意事项:

  • 注意一: 抽象类不能实例化.
  • 注意二: 抽象类中的抽象方法必须被子类实现, 抽象类中的已经被实现方法, 可以不被子类重写.

10. 隐式接口

dart中的接口比较特殊, 没有一个专门的关键字来声明接口.

默认情况下,定义的每个类都相当于默认也声明了一个接口,可以由其他的类来实现(因为Dart不支持多继承)

在开发中,我们通常将用于给别人实现的类声明为抽象类:

abstract class Runner {
  run();
}

abstract class Flyer {
  fly();
}

class SuperMan implements Runner, Flyer {
  @override
  run() {
    print('超人在奔跑');
  }

  @override
  fly() {
    print('超人在飞');
  }
}

11. Mixin混入

在通过implements实现某个类时,类中所有的方法都必须被重新实现(无论这个类原来是否已经实现过该方法)。

但是某些情况下,一个类可能希望直接复用之前类的原有实现方案,怎么做呢?

  • 使用继承吗?但是Dart只支持单继承,那么意味着你只能复用一个类的实现。 dart提供了另外一种方案: Mixin混入的方式

  • 除了可以通过class定义类之外,也可以通过mixin关键字来定义一个类。

  • 只是通过mixin定义的类用于被其他类混入使用,通过with关键字来进行混入。

main(List<String> args) {
  var superMan = SuperMain();
  superMan.run();
  superMan.fly();
}

mixin Runner {
  run() {
    print('在奔跑');
  }
}

mixin Flyer {
  fly() {
    print('在飞翔');
  }
}

// implements的方式要求必须对其中的方法进行重新实现
// class SuperMan implements Runner, Flyer {}

class SuperMain with Runner, Flyer {

}

12. 类成员和方法

前面我们在类中定义的成员和方法都属于对象级别的, 在开发中, 我们有时候也需要定义类级别的成员和方法

在Dart中我们使用static关键字来定义:

main(List<String> args) {
  var stu = Student();
  stu.name = 'why';
  stu.sno = 110;
  stu.study();

  Student.time = '早上8点';
  // stu.time = '早上9点'; 错误做法, 实例对象不能访问类成员
  Student.attendClass();
  // stu.attendClass(); 错误做法, 实现对象补鞥呢访问类方法
}

class Student {
  String name;
  int sno;

  static String time;

  study() {
    print('$name在学习');
  }

  static attendClass() {
    print('去上课');
  }
}

13. 枚举类型

枚举在开发中也非常常见, 枚举也是一种特殊的类, 通常用于表示固定数量的常量值

14. 枚举的定义

枚举使用enum关键字来进行定义:

main(List<String> args) {
  print(Colors.red);
}

enum Colors {
  red,
  green,
  blue
}

15. 枚举的属性

枚举类型中有两个比较常见的属性:

  • index: 用于表示每个枚举常量的索引, 从0开始.
  • values: 包含每个枚举值的List.
main(List<String> args) {
  print(Colors.red.index);
  print(Colors.green.index);
  print(Colors.blue.index);

  print(Colors.values);
}

enum Colors {
  red,
  green,
  blue
}

枚举类型的注意事项:

  • 注意一: 您不能子类化、混合或实现枚举。
  • 注意二: 不能显式实例化一个枚举

三、 泛型

1. 为什么使用泛型?

对于有基础的同学, 这部分不再解释

2. List和Map的泛型

List使用时的泛型写法:

  // 创建List的方式
  var names1 = ['why', 'kobe', 'james', 111];
  print(namesruntimeType); // List<Object>

  // 限制类型
  var names2 = <String>['why', 'kobe', 'james', 111]; // 最后一个报错
  List<String> names3 = ['why', 'kobe', 'james', 111]; // 最后一个报错

Map使用时的泛型写法:

  // 创建Map的方式
  var infos1 = {1: 'one', 'name': 'why', 'age': 18}; 
  print(infosruntimeType); // _InternalLinkedHashMap<Object, Object>

  // 对类型进行显示
  Map<String, String> infos2 = {'name': 'why', 'age': 18}; // 18不能放在value中
  var infos3 = <String, String>{'name': 'why', 'age': 18}; // 18不能放在value中

3. 类定义的泛型

如果我们需要定义一个类, 用于存储位置信息Location, 但是并不确定使用者希望使用的是int类型,还是double类型, 甚至是一个字符串, 这个时候如何定义呢?

  • 一种方案是使用Object类型, 但是在之后使用时, 非常不方便
  • 另一种方案就是使用泛型.

Location类的定义: Object方式

main(List<String> args) {
  Location l1 = Location(10, 20);
  print(lx.runtimeType); // Object
}

class Location {
  Object x;
  Object y;

  Location(this.x, this.y);
}

Location类的定义: 泛型方式

main(List<String> args) {
  Location l2 = Location<int>(10, 20);
  print(lx.runtimeType); // int 

  Location l3 = Location<String>('aaa', 'bbb');
  print(lx.runtimeType); // String
}
}

class Location<T> {
  T x;
  T y;

  Location(this.x, this.y);
}

如果我们希望类型只能是num类型, 怎么做呢?

main(List<String> args) {
  Location l2 = Location<int>(10, 20);
  print(lx.runtimeType);
  
  // 错误的写法, 类型必须继承自num
  Location l3 = Location<String>('aaa', 'bbb');
  print(lx.runtimeType);
}

class Location<T extends num> {
  T x;
  T y;

  Location(this.x, this.y);
}

4. 泛型方法的定义

最初,Dart仅仅在类中支持泛型。后来一种称为泛型方法的新语法允许在方法和函数中使用类型参数。

main(List<String> args) {
  var names = ['why', 'kobe'];
  var first = getFirst(names);
  print('$first ${first.runtimeType}'); // why String
}

T getFirst<T>(List<T> ts) {
  return ts[0];
}

四. 库的使用

在Dart中,你可以导入一个库来使用它所提供的功能。

库的使用可以使代码的重用性得到提高,并且可以更好的组合代码。

Dart中任何一个dart文件都是一个库,即使你没有用关键字library声明

1.库的导入

import语句用来导入一个库,后面跟一个字符串形式的Uri来指定表示要引用的库,语法如下:

import '库所在的uri';

常见的库URI有三种不同的形式

  • 来自dart标准版,比如dart:io、dart:html、dart:math、dart:core(但是这个可以省略)
//dart:前缀表示Dart的标准库,如dart:io、dart:html、dart:math
import 'dart:io';
  • 使用相对路径导入的库,通常指自己项目中定义的其他dart文件
//当然,你也可以用相对路径或绝对路径的dart文件来引用
import 'lib/student/student.dart';
  • Pub包管理工具管理的一些库,包括自己的配置以及一些第三方的库,通常使用前缀package
//Pub包管理系统中有很多功能强大、实用的库,可以使用前缀 package:
import 'package:flutter/material.dart';

库文件中内容的显示和隐藏

如果希望只导入库中某些内容,或者刻意隐藏库里面某些内容,可以使用showhide关键字

  • **show关键字:**可以显示某个成员(屏蔽其他)
  • **hide关键字:**可以隐藏某个成员(显示其他)
import 'lib/student/student.dart' show Student, Person;

import 'lib/student/student.dart' hide Person;

库中内容和当前文件中的名字冲突

当各个库有命名冲突的时候,可以使用as关键字来使用命名空间

import 'lib/student/student.dart' as Stu;

Stu.Student s = new Stu.Student();

2.库的定义

library关键字

通常在定义库时,我们可以使用library关键字给库起一个名字。

但目前我发现,库的名字并不影响导入,因为import语句用的是字符串URI

library math;

part关键字

在之前我们使用student.dart作为演练的时候,只是将该文件作为一个库。

在开发中,如果一个库文件太大,将所有内容保存到一个文件夹是不太合理的,我们有可能希望将这个库进行拆分,这个时候就可以使用part关键字了

不过官方已经不建议使用这种方式了:

03-📝Flutter核心知识|Dart语言快速入门|面向对象【类和对象、泛型、库的使用、异步模型、异步操作】

mathUtils.dart文件

part of "utils.dart";

int sum(int num1, int num2) {
  return num1 + num2;
}

dateUtils.dart文件

part of "utils.dart";

String dateFormat(DateTime date) {
  return "2020-12-12";
}

utils.dart文件

part "mathUtils.dart";
part "dateUtils.dart";

test_libary.dart文件

import "lib/utils.dart";

main(List<String> args) {
  print(sum(10, 20));
  print(dateFormat(DateTime.now()));
}

03-📝Flutter核心知识|Dart语言快速入门|面向对象【类和对象、泛型、库的使用、异步模型、异步操作】 export关键字

官方不推荐使用part关键字,那如果库非常大,如何进行管理呢?

  • 将每一个dart文件作为库文件,使用export关键字在某个库文件中单独导入

mathUtils.dart文件

int sum(int num1, int num2) {
  return num1 + num2;
}

dateUtils.dart文件

String dateFormat(DateTime date) {
  return "2020-12-12";
}

utils.dart文件

library utils;

export "mathUtils.dart";
export "dateUtils.dart";

test_libary.dart文件

import "lib/utils.dart";

main(List<String> args) {
  print(sum(10, 20));
  print(dateFormat(DateTime.now()));
}

最后,也可以通过Pub管理自己的库自己的库,在项目开发中个人觉得不是非常有必要,所以暂时不讲解这种方式。

五. Dart的异步模型

我们先来搞清楚Dart是如何搞定异步操作的

1. Dart是单线程的

1.1. 程序中的耗时操作

开发中的耗时操作:

  • 在开发中,我们经常会遇到一些耗时的操作需要完成,比如网络请求、文件读取等等;
  • 如果我们的主线程一直在等待这些耗时的操作完成,那么就会进行阻塞,无法响应其它事件,比如用户的点击;
  • 显然,我们不能这么干!!

如何处理耗时的操作呢?

  • 针对如何处理耗时的操作,不同的语言有不同的处理方式。
  • 处理方式一: 多线程,比如Java、C++,我们普遍的做法是开启一个新的线程(Thread),在新的线程中完成这些异步的操作,再通过线程间通信的方式,将拿到的数据传递给主线程。
  • 处理方式二: 单线程+事件循环,比如JavaScript、Dart都是基于单线程加事件循环来完成耗时操作的处理。不过单线程如何能进行耗时的操作呢?!

1.2. 单线程的异步操作

我之前碰到很多开发者都对单线程的异步操作充满了问号???

03-📝Flutter核心知识|Dart语言快速入门|面向对象【类和对象、泛型、库的使用、异步模型、异步操作】

其实它们并不冲突:

  • 因为我们的一个应用程序大部分时间都是处于空闲的状态的,并不是无限制的在和用户进行交互。
  • 比如等待用户点击、网络请求数据的返回、文件读写的IO操作,这些等待的行为并不会阻塞我们的线程;
  • 这是因为类似于网络请求、文件读写的IO,我们都可以基于非阻塞调用;

阻塞式调用和非阻塞式调用

如果想搞懂这个点,我们需要知道操作系统中的阻塞式调用非阻塞式调用的概念。

  • 阻塞和非阻塞关注的是程序在等待调用结果(消息,返回值)时的状态。
  • 阻塞式调用: 调用结果返回之前,当前线程会被挂起,调用线程只有在得到调用结果之后才会继续执行。
  • 非阻塞式调用: 调用执行之后,当前线程不会停止执行,只需要过一段时间来检查一下有没有结果返回即可。

我们用一个生活中的例子来模拟:

  • 你中午饿了,需要点一份外卖,点外卖的动作就是我们的调用,拿到最后点的外卖就是我们要等待的结果。
  • 阻塞式调用: 点了外卖,不再做任何事情,就是在傻傻的等待,你的线程停止了任何其他的工作。
  • 非阻塞式调用: 点了外卖,继续做其他事情:继续工作、打把游戏,你的线程没有继续执行其他事情,只需要偶尔去看一下有没有人敲门,外卖有没有送到即可。

而我们开发中的很多耗时操作,都可以基于这样的 非阻塞式调用

  • 比如网络请求本身使用了Socket通信,而Socket本身提供了select模型,可以进行非阻塞方式的工作
  • 比如文件读写的IO操作,我们可以使用操作系统提供的基于事件的回调机制

这些操作都不会阻塞我们单线程的继续执行,我们的线程在等待的过程中可以继续去做别的事情:喝杯咖啡、打把游戏,等真正有了响应,再去进行对应的处理即可。

这时,我们可能有两个问题:

  • 问题一: 如果在多核CPU中,单线程是不是就没有充分利用CPU呢?这个问题,我会放在后面来讲解。
  • 问题二: 单线程是如何来处理网络通信、IO操作它们返回的结果呢?答案就是事件循环(Event Loop)。

2. Dart事件循环

2.1 什么是事件循环

单线程模型中主要就是在维护着一个事件循环(Event Loop)。

事件循环是什么呢?

  • 事实上事件循环并不复杂,它就是将需要处理的一系列事件(包括点击事件、IO事件、网络事件)放在一个事件队列(Event Queue)中。
  • 不断的从事件队列(Event Queue)中取出事件,并执行其对应需要执行的代码块,直到事件队列清空位置。

我们来写一个事件循环的伪代码:

// 这里我使用数组模拟队列, 先进先出的原则
List eventQueue = []; 
var event;

// 事件循环从启动的一刻,永远在执行
while (true) {
  if (eventQueue.length > 0) {
    // 取出一个事件
    event = eventQueue.removeAt(0);
    // 执行该事件
    event();
  }
}

当我们有一些事件时,比如点击事件、IO事件、网络事件时,它们就会被加入到eventLoop中,当发现事件队列不为空时发现,就会取出事件,并且执行。

  • 齿轮就是我们的事件循环,它会从队列中一次取出事件来执行。

03-📝Flutter核心知识|Dart语言快速入门|面向对象【类和对象、泛型、库的使用、异步模型、异步操作】

2.2 事件循环代码模拟

这里我们来看一段伪代码,理解点击事件和网络请求的事件是如何被执行的:

  • 这是一段Flutter代码,很多东西大家可能不是特别理解,但是耐心阅读你会读懂我们在做什么。
  • 一个按钮RaisedButton,当发生点击时执行onPressed函数。
  • onPressed函数中,我们发送了一个网络请求,请求成功后会执行then中的回调函数。
RaisedButton(
  child: Text('Click me'),
  onPressed: () {
    final myFuture = http.get('https://example.com');
    myFuture.then((response) {
      if (response.statusCode == 200) {
        print('Success!');
      }
    });
  },
)

这些代码是如何放在事件循环中执行呢?

  • 1、当用户发生点击的时候,onPressed回调函数被放入事件循环中执行,执行的过程中发送了一个网络请求。
  • 2、网络请求发出去后,该事件循环不会被阻塞,而是发现要执行的onPressed函数已经结束,会将它丢弃掉。
  • 3、网络请求成功后,会执行then中传入的回调函数,这也是一个事件,该事件被放入到事件循环中执行,执行完毕后,事件循环将其丢弃。

尽管onPressed和then中的回调有一些差异,但是它们对于事件循环来说,都是告诉它:我有一段代码需要执行,快点帮我完成。

六. Dart的异步操作

Dart中的异步操作主要使用Future以及async、await。

如果你之前有过前端的ES6、ES7编程经验,那么完全可以将Future理解成Promise,async、await和ES7中基本一致。

但是如果没有前端开发经验,Future以及async、await如何理解呢?

1. 认识Future

我思考了很久,这个Future到底应该如何讲解

1.1. 同步的网络请求

我们先来看一个例子吧:

  • 在这个例子中,我使用getNetworkData来模拟了一个网络请求;
  • 该网络请求需要3秒钟的时间,之后返回数据;
import "dart:io";

main(List<String> args) {
  print("main function start");
  print(getNetworkData());
  print("main function end");
}

String getNetworkData() {
  sleep(Duration(seconds: 3));
  return "network data";
}

这段代码会运行怎么的结果呢?

  • getNetworkData会阻塞main函数的执行
main function start
// 等待3秒
network data
main function end

显然,上面的代码不是我们想要的执行效果,因为网络请求阻塞了main函数,那么意味着其后所有的代码都无法正常的继续执行。

1.2. 异步的网络请求

我们来对我们上面的代码进行改进,代码如下:

  • 和刚才的代码唯一的区别在于我使用了Future对象来将耗时的操作放在了其中传入的函数中;
  • 稍后,我们会讲解它具体的一些API,我们就暂时知道我创建了一个Future实例即可;
import "dart:io";

main(List<String> args) {
  print("main function start");
  print(getNetworkData());
  print("main function end");
}

Future<String> getNetworkData() {
  return Future<String>(() {
    sleep(Duration(seconds: 3));
    return "network data";
  });
}

我们来看一下代码的运行结果:

  • 1、这一次的代码顺序执行,没有出现任何的阻塞现象;
  • 2、和之前直接打印结果不同,这次我们打印了一个Future实例;
  • 结论:我们将一个耗时的操作隔离了起来,这个操作不会再影响我们的主线程执行了。
  • 问题:我们如何去拿到最终的结果呢?
main function start
Instance of 'Future<String>'
main function end

获取Future得到的结果

有了Future之后,如何去获取请求到的结果:通过.then的回调:

main(List<String> args) {
  print("main function start");
  // 使用变量接收getNetworkData返回的future
  var future = getNetworkData();
  // 当future实例有返回结果时,会自动回调then中传入的函数
  // 该函数会被放入到事件循环中,被执行
  future.then((value) {
    print(value);
  });
  print(future);
  print("main function end");
}

上面代码的执行结果:

main function start
Instance of 'Future<String>'
main function end
// 3s后执行下面的代码
network data

执行中出现异常

如果调用过程中出现了异常,拿不到结果,如何获取到异常的信息呢?

import "dart:io";

main(List<String> args) {
  print("main function start");
  var future = getNetworkData();
  future.then((value) {
    print(value);
  }).catchError((error) { // 捕获出现异常时的情况
    print(error);
  });
  print(future);
  print("main function end");
}

Future<String> getNetworkData() {
  return Future<String>(() {
    sleep(Duration(seconds: 3));
    // 不再返回结果,而是出现异常
    // return "network data";
    throw Exception("网络请求出现错误");
  });
}

上面代码的执行结果:

main function start
Instance of 'Future<String>'
main function end
// 3s后没有拿到结果,但是我们捕获到了异常
Exception: 网络请求出现错误

1.3. Future使用补充

补充一:上面案例的小结

我们通过一个案例来学习了一些Future的使用过程:

  • 1、创建一个Future(可能是我们创建的,也可能是调用内部API或者第三方API获取到的一个Future,总之你需要获取到一个Future实例,Future通常会对一些异步的操作进行封装);
  • 2、通过.then(成功回调函数)的方式来监听Future内部执行完成时获取到的结果;
  • 3、通过.catchError(失败或异常回调函数)的方式来监听Future内部执行失败或者出现异常时的错误信息;

补充二:Future的两种状态

事实上Future在执行的整个过程中,我们通常把它划分成了两种状态:

状态一:未完成状态(uncompleted)

  • 执行Future内部的操作时(在上面的案例中就是具体的网络请求过程,我们使用了延迟来模拟),我们称这个过程为未完成状态

状态二:完成状态(completed)

  • 当Future内部的操作执行完成,通常会返回一个值,或者抛出一个异常。
  • 这两种情况,我们都称Future为完成状态。 dart官网有对这两种状态解析,之所以贴出来是区别于Promise的三种状态

03-📝Flutter核心知识|Dart语言快速入门|面向对象【类和对象、泛型、库的使用、异步模型、异步操作】

补充三:Future的链式调用

上面代码我们可以进行如下的改进:

  • 我们可以在then中继续返回值,会在下一个链式的then调用回调函数中拿到返回的结果
import "dart:io";

main(List<String> args) {
  print("main function start");

  getNetworkData().then((value1) {
    print(value1);
    return "content data2";
  }).then((value2) {
    print(value2);
    return "message data3";
  }).then((value3) {
    print(value3);
  });

  print("main function end");
}

Future<String> getNetworkData() {
  return Future<String>(() {
    sleep(Duration(seconds: 3));
    // 不再返回结果,而是出现异常
     return "network data1";
  });
}

打印结果如下:

main function start
main function end
// 3s后拿到结果
network data1
content data2
message data3

补充四:Future其他API

Future.value(value)

  • 直接获取一个完成的Future,该Future会直接调用then的回调函数
main(List<String> args) {
  print("main function start");

  Future.value("哈哈哈").then((value) {
    print(value);
  });

  print("main function end");
}

打印结果如下:

main function start
main function end
哈哈哈

疑惑:为什么立即执行,但是哈哈哈是在最后打印的呢?

  • 这是因为Future中的then会作为新的任务会加入到事件队列中(Event Queue),加入之后你肯定需要排队执行了

Future.error(object)

  • 直接获取一个完成的Future,但是是一个发生异常的Future,该Future会直接调用catchError的回调函数
main(List<String> args) {
  print("main function start");

  Future.error(Exception("错误信息")).catchError((error) {
    print(error);
  });

  print("main function end");
}

打印结果如下:

main function start
main function end
Exception: 错误信息

Future.delayed(时间, 回调函数)

  • 在延迟一定时间时执行回调函数,执行完回调函数后会执行then的回调;
  • 之前的案例,我们也可以使用它来模拟,但是直接学习这个API会让大家更加疑惑;
main(List<String> args) {
  print("main function start");

  Future.delayed(Duration(seconds: 3), () {
    return "3秒后的信息";
  }).then((value) {
    print(value);
  });

  print("main function end");
}

2. await、async

2.1. 理论概念理解

如果你已经完全搞懂了Future,那么学习await、async应该没有什么难度。

await、async是什么呢?

  • 它们是Dart中的关键字(你这不是废话吗?废话也还是要强调的,万一你用它做变量名呢,无辜脸。)
  • 它们可以让我们用同步的代码格式,去实现异步的调用过程
  • 并且,通常一个async的函数会返回一个Future(别着急,马上就看到代码了)。

我们已经知道,Future可以做到不阻塞我们的线程,让线程继续执行,并且在完成某个操作时改变自己的状态,并且回调then或者errorCatch回调。

如何生成一个Future呢?

  • 1、通过我们前面学习的Future构造函数,或者后面学习的Future其他API都可以。
  • 2、还有一种就是通过async的函数。

2.2. 案例代码演练

Talk is cheap. Show me the code.

我们来对之前的Future异步处理代码进行改造,改成await、async的形式。

我们知道,如果直接这样写代码,代码是不能正常执行的:

  • 因为Future.delayed返回的是一个Future对象,我们不能把它看成同步的返回数据:"network data"去使用
  • 也就是我们不能把这个异步的代码当做同步一样去使用!
import "dart:io";

main(List<String> args) {
  print("main function start");
  print(getNetworkData());
  print("main function end");
}

String getNetworkData() {
  var result = Future.delayed(Duration(seconds: 3), () {
    return "network data";
  });

  return  "请求到的数据:" + result;
}

现在我使用await修改下面这句代码:

  • 你会发现,我在Future.delayed函数前加了一个await。
  • 一旦有了这个关键字,那么这个操作就会等待Future.delayed的执行完毕,并且等待它的结果。
String getNetworkData() {
  var result = await Future.delayed(Duration(seconds: 3), () {
    return "network data";
  });

  return  "请求到的数据:" + result;
}

修改后执行代码,会看到如下的错误:

  • 错误非常明显:await关键字必须存在于async函数中。
  • 所以我们需要将getNetworkData函数定义成async函数。

03-📝Flutter核心知识|Dart语言快速入门|面向对象【类和对象、泛型、库的使用、异步模型、异步操作】

继续修改代码如下:

  • 也非常简单,只需要在函数的()后面加上一个async关键字就可以了
String getNetworkData() async {
  var result = await Future.delayed(Duration(seconds: 3), () {
    return "network data";
  });

  return  "请求到的数据:" + result;
}

运行代码,依然报错(心想:你妹啊):

  • 错误非常明显:使用async标记的函数,必须返回一个Future对象。
  • 所以我们需要继续修改代码,将返回值写成一个Future。

03-📝Flutter核心知识|Dart语言快速入门|面向对象【类和对象、泛型、库的使用、异步模型、异步操作】

继续修改代码如下:

Future<String> getNetworkData() async {
  var result = await Future.delayed(Duration(seconds: 3), () {
    return "network data";
  });

  return "请求到的数据:" + result;
}

这段代码应该是我们理想当中执行的代码了

  • 我们现在可以像同步代码一样去使用Future异步返回的结果;
  • 等待拿到结果之后和其他数据进行拼接,然后一起返回;
  • 返回的时候并不需要包装一个Future,直接返回即可,但是返回值会默认被包装在一个Future中;

3. 读取json案例

我这里给出了一个在Flutter项目中,读取一个本地的json文件,并且转换成模型对象,返回出去的案例;

这个案例作为大家学习前面Future和await、async的一个参考,我并不打算展开来讲,因为需要用到Flutter的相关知识;

后面我会在后面的案例中再次讲解它在Flutter中我使用的过程中;

读取json案例代码(了解一下即可)

import 'package:flutter/services.dart' show rootBundle;
import 'dart:convert';
import 'dart:async';

main(List<String> args) {
  getAnchors().then((anchors) {
    print(anchors);
  });
}

class Anchor {
  String nickname;
  String roomName;
  String imageUrl;

  Anchor({
    this.nickname,
    this.roomName,
    this.imageUrl
  });

  Anchor.withMap(Map<String, dynamic> parsedMap) {
    this.nickname = parsedMap["nickname"];
    this.roomName = parsedMap["roomName"];
    this.imageUrl = parsedMap["roomSrc"];
  }
}

Future<List<Anchor>> getAnchors() async {
  // 1.读取json文件
  String jsonString = await rootBundle.loadString("assets/yz.json");

  // 2.转成List或Map类型
  final jsonResult = json.decode(jsonString);

  // 3.遍历List,并且转成Anchor对象放到另一个List中
  List<Anchor> anchors = new List();
  for (Map<String, dynamic> map in jsonResult) {
    anchors.add(Anchor.withMap(map));
  }
  return anchors;
}

三. Dart的异步补充

1. 任务执行顺序

1.1. 认识微任务队列

在前面学习学习中,我们知道Dart中有一个事件循环(Event Loop)来执行我们的代码,里面存在一个事件队列(Event Queue),事件循环不断从事件队列中取出事件执行。

但是如果我们严格来划分的话,在Dart中还存在另一个队列:微任务队列(Microtask Queue)。

  • 微任务队列的优先级要高于事件队列;
  • 也就是说事件循环都是优先执行微任务队列中的任务,再执行 事件队列 中的任务;

那么在Flutter开发中,哪些是放在事件队列,哪些是放在微任务队列呢?

  • 所有的外部事件任务都在事件队列中,如IO、计时器、点击、以及绘制事件等;
  • 而微任务通常来源于Dart内部,并且微任务非常少。这是因为如果微任务非常多,就会造成事件队列排不上队,会阻塞任务队列的执行(比如用户点击没有反应的情况);

说道这里,你可能已经有点凌乱了,在Dart的单线程中,代码到底是怎样执行的呢?

  • 1、Dart的入口是main函数,所以main函数中的代码会优先执行;
  • 2、main函数执行完后,会启动一个事件循环(Event Loop)就会启动,启动后开始执行队列中的任务;
  • 3、首先,会按照先进先出的顺序,执行 微任务队列(Microtask Queue)中的所有任务;
  • 4、其次,会按照先进先出的顺序,执行 事件队列(Event Queue)中的所有任务;

03-📝Flutter核心知识|Dart语言快速入门|面向对象【类和对象、泛型、库的使用、异步模型、异步操作】

1.2. 如何创建微任务

在开发中,我们可以通过dart中async下的scheduleMicrotask来创建一个微任务:

import "dart:async";

main(List<String> args) {
  scheduleMicrotask(() {
    print("Hello Microtask");
  });
}

在开发中,如果我们有一个任务不希望它放在Event Queue中依次排队,那么就可以创建一个微任务了。

Future的代码是加入到事件队列还是微任务队列呢?

Future中通常有两个函数执行体:

  • Future构造函数传入的函数体
  • then的函数体(catchError等同看待)

那么它们是加入到什么队列中的呢?

  • Future构造函数传入的函数体放在事件队列中
  • then的函数体要分成三种情况:
  • 情况一:Future没有执行完成(有任务需要执行),那么then会直接被添加到Future的函数执行体后;
  • 情况二:如果Future执行完后就then,该then的函数体被放到如微任务队列,当前Future执行完后执行微任务队列;
  • 情况三:如果Future世链式调用,意味着then未执行完,下一个then不会执行;
// future_1加入到eventqueue中,紧随其后then_1被加入到eventqueue中
Future(() => print("future_1")).then((_) => print("then_1"));

// Future没有函数执行体,then_2被加入到microtaskqueue中
Future(() => null).then((_) => print("then_2"));

// future_3、then_3_a、then_3_b依次加入到eventqueue中
Future(() => print("future_3")).then((_) => print("then_3_a")).then((_) => print("then_3_b"));

1.3. 代码执行顺序

我们根据前面的规则来学习一个极的代码执行顺序案例:

import "dart:async";

main(List<String> args) {
  print("main start");

  Future(() => print("task1"));
  
  final future = Future(() => null);

  Future(() => print("task2")).then((_) {
    print("task3");
    scheduleMicrotask(() => print('task4'));
  }).then((_) => print("task5"));

  future.then((_) => print("task6"));
  scheduleMicrotask(() => print('task7'));

  Future(() => print('task8'))
    .then((_) => Future(() => print('task9')))
    .then((_) => print('task10'));

  print("main end");
}

代码执行的结果是:

main start
main end
task7
task1
task6
task2
task3
task5
task4
task8
task9
task10

代码分析:

  • 1、main函数先执行,所以main startmain end先执行,没有任何问题;
  • 2、main函数执行过程中,会将一些任务分别加入到EventQueueMicrotaskQueue中;
  • 3、task7通过scheduleMicrotask函数调用,所以它被最早加入到MicrotaskQueue,会被先执行;
  • 4、然后开始执行EventQueue,task1被添加到EventQueue中被执行;
  • 5、通过final future = Future(() => null);创建的future的then被添加到微任务中,微任务直接被优先执行,所以会执行task6;
  • 6、一次在EventQueue中添加task2、task3、task5被执行;
  • 7、task3的打印执行完后,调用scheduleMicrotask,那么在执行完这次的EventQueue后会执行,所以在task5后执行task4(注意:scheduleMicrotask的调用是作为task3的一部分代码,所以task4是要在task5之后执行的)
  • 8、task8、task9、task10一次添加到EventQueue被执行;

事实上,上面的代码执行顺序有可能出现在面试中,我们开发中通常不会出现这种复杂的嵌套,并且需要完全搞清楚它的执行顺序;

但是,了解上面的代码执行顺序,会让你对EventQueuemicrotaskQueue有更加深刻的理解。

2. 多核CPU的利用

2.1. Isolate的理解

在Dart中,有一个Isolate的概念,它是什么呢?

  • 我们已经知道Dart是单线程的,这个线程有自己可以访问的内存空间以及需要运行的事件循环;
  • 我们可以将这个空间系统称之为是一个Isolate;
  • 比如Flutter中就有一个Root Isolate,负责运行Flutter的代码,比如UI渲染、用户交互等等;

在 Isolate 中,资源隔离做得非常好,每个 Isolate 都有自己的 Event Loop 与 Queue,

  • Isolate 之间不共享任何资源,只能依靠消息机制通信,因此也就没有资源抢占问题。

但是,如果只有一个Isolate,那么意味着我们只能永远利用一个线程,这对于多核CPU来说,是一种资源的浪费。

如果在开发中,我们有非常多耗时的计算,完全可以自己创建Isolate,在独立的Isolate中完成想要的计算操作。

如何创建Isolate呢?

创建Isolate是比较简单的,我们通过Isolate.spawn就可以创建了:

import "dart:isolate";

main(List<String> args) {
  Isolate.spawn(foo, "Hello Isolate");
}

void foo(info) {
  print("新的isolate:$info");
}

2.2. Isolate通信机制

但是在真实开发中,我们不会只是简单的开启一个新的Isolate,而不关心它的运行结果:

  • 我们需要新的Isolate进行计算,并且将计算结果告知Main Isolate(也就是默认开启的Isolate);
  • Isolate 通过发送管道(SendPort)实现消息通信机制;
  • 我们可以在启动并发Isolate时将Main Isolate的发送管道作为参数传递给它;
  • 并发在执行完毕时,可以利用这个管道给Main Isolate发送消息;
import "dart:isolate";

main(List<String> args) async {
  // 1.创建管道
  ReceivePort receivePort= ReceivePort();

  // 2.创建新的Isolate
  Isolate isolate = await Isolate.spawn<SendPort>(foo, receivePort.sendPort);

  // 3.监听管道消息
  receivePort.listen((data) {
    print('Data:$data');
    // 不再使用时,我们会关闭管道
    receivePort.close();
    // 需要将isolate杀死
    isolate?.kill(priority: Isolate.immediate);
  });
}

void foo(SendPort sendPort) {
  sendPort.send("Hello World");
}

但是我们上面的通信变成了单向通信,如果需要双向通信呢?

  • 事实上双向通信的代码会比较麻烦;
  • Flutter提供了支持并发计算的compute函数,它内部封装了Isolate的创建和双向通信;
  • 利用它我们可以充分利用多核心CPU,并且使用起来也非常简单;

注意:下面的代码不是dart的API,而是Flutter的API,所以只有在Flutter项目中才能运行

main(List<String> args) async {
  int result = await compute(powerNum, 5);
  print(result);
}

int powerNum(int num) {
  return num * num;
}
转载自:https://juejin.cn/post/7259234035392741413
评论
请登录