likes
comments
collection
share

Flutter开发实战：通过工厂模式和yield/future/async/await，实现数据流处理的模块化与复用

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

相信大家对工厂模式并不陌生，我们就不过多介绍了。接下来，让我们一起来探讨在Flutter开发中如何利用工厂模式以及yield、future,async和await这些强大的特性，实现数据流处理的模块化与复用。

  1. yield：

    • 在生成器函数（Generator Function）中使用，用于产生（yield）序列化的值。
    • 允许函数在每次产生值后暂停执行，等待下一次迭代。
    • 用于实现惰性求值的效果，只在需要时才产生下一个值。
    • 适用于生成大量数据或者按需加载数据的场景。

  2. Future：

    • Future代表一个可能在未来完成的值或事件的承诺。
    • 通过Future，可以处理一些耗时的操作，例如网络请求、数据库查询等。
    • Future提供了一些方法来处理异步任务的完成情况，如then()、catchError()等。
    • 通过Future的链式调用，可以组合多个异步任务，并按顺序执行。

  3. async和await：

    • async用于将函数标记为异步函数，表示函数内部可能包含异步操作。
    • await用于等待一个异步操作的完成，并获取其结果。
    • await只能在异步函数内部使用，它会暂停当前函数的执行，等待异步操作完成后再继续执行后续代码。
    • 使用async和await可以使代码在处理异步任务时更具有同步代码的风格，提高可读性和维护性。

这些关键字的组合使用使得编写异步代码更加直观和简洁，类似于同步代码的风格。yield和future/async/await是不同的机制，用于不同的场景：

  • yield用于生成器函数中，按需产生序列化的值，实现惰性求值。
  • future/async/await用于处理异步操作，等待异步任务的完成，使得代码按照同步的方式执行，提高代码的可读性和维护性。

在Flutter中，future/async/await常用于处理网络请求、数据库操作、文件读写等耗时的异步任务，而yield可以用于生成大量数据或者按需加载数据的情况。

通过使用这些关键字，Flutter开发者可以更好地处理异步操作，提高应用的性能和用户体验，并编写更简洁、可读性更强的代码。

在使用yield关键字前我们先来了解一下什么是惰性求值：

惰性求值（Lazy Evaluation）是一种编程策略，它延迟计算或产生值，直到真正需要使用这些值时才进行计算。相对于直接计算和生成所有值，惰性求值可以提供更高的效率和节省资源的能力。

在惰性求值中，只有当需要获取值时，才会进行计算或生成值。这可以在处理大量数据、无限序列或按需加载的情况下提供很大的优势。通过只计算或生成实际需要的部分，可以避免不必要的计算或生成过程，节省时间和内存。

在编程语言中，惰性求值通常通过使用生成器（Generator）或迭代器（Iterator）来实现。生成器函数（Generator Function）是一种特殊的函数，它可以在需要时按需生成值，并在生成值后暂停执行，等待下一次迭代。

在Dart和Flutter中，使用yield关键字可以实现惰性求值。在生成器函数中，yield关键字用于产生（yield）序列化的值。每次调用生成器函数时，只会生成一个值并暂停执行，等待下一次迭代。这样可以按需产生值，避免一次性生成所有值。

惰性求值在处理大型数据集、无限序列、按需加载数据等方面非常有用。它可以提高性能、降低内存消耗，并允许处理更复杂和动态的数据流。在Flutter开发中，惰性求值常用于处理数据流、列表操作、UI渲染等场景，以提供更高效的数据处理和更好的用户体验。

总结起来，惰性求值是一种延迟计算或产生值的策略，只在真正需要时进行计算或生成。在Flutter中，可以通过使用yield关键字来实现惰性求值，提高代码的性能和资源利用率。

  • yield：yield是在生成器函数中使用的关键字，用于产生（yield）序列化的值。生成器函数可以在多次产生值的方式下构建一个序列。

示例：

Iterable<int> countDown(int from) sync* {
  while (from > 0) {
    yield from;
    from--;
  }
}

在上述示例中，countDown函数是一个生成器函数，使用sync*关键字进行声明。在循环中，通过yield语句产生从from开始递减的整数序列。

运行上述代码，将会输出：

void main() {
  Iterable<int> countDown(int from) sync* {
    while (from > 0) {
      yield from;
      from--;
    }
  }

  final countdown = countDown(5);
  for (final value in countdown) {
    print(value);
  }
}


5
4
3
2
1

  • 使用Future、async和await的常见场景和用法：

    • 发起一个网络请求并等待其响应：
    Future<String> fetchData() async {
  final response = await http.get(Uri.parse('https://example.com/data'));
  return response.body;
}
    • 组合多个异步任务并按顺序执行：
    Future<void> executeTasks() async {
  await task1();
  await task2();
  await task3();
}
    • 并行执行多个异步任务：
    Future<void> executeTasks() async {
  final task1 = task1Async();
  final task2 = task2Async();
  await Future.wait([task1, task2]);
  // 所有任务完成后继续执行
  print('All tasks completed');
}
    • 异常处理：
    Future<void> fetchData() async {
  try {
    final response = await http.get(Uri.parse('https://example.com/data'));
    // 处理成功的情况
  } catch (e) {
    // 处理异常情况
  }
}

通过使用Future、async和await，我们可以更简洁地编写异步代码，避免了回调地狱和层层嵌套的问题。它们提供了一种直观且易于理解的方式来处理异步任务，使代码更具可读性和可维护性。在Flutter开发中，它们被广泛应用于处理网络请求、数据库操作、文件读写等耗时的异步任务，以及实现响应式UI和数据流处理。

需求： 要建立一个汔车生产工厂，工厂有多条生产线，每条生产线负责生产不同类型的汔车。每种汔车都有自己的特点和生产流程。并且使用yield、async和await来处理异步操作。最后需要一个消费者来消费生产出来的汔车。

实现： 我们可以使用工厂设计模式来组织汔车生产工厂的结构，使用yield、async和await处理异步操作，以及创建一个消费者来消费生产出来的汔车。

下面是一个简单的示例，展示了如何实现汔车生产工厂并消费生产出来的汔车：

import 'dart:async';

// 汔车接口
abstract class Car {
  void produce();
}

// 汔车实现类：轿车
class Sedan implements Car {
  @override
  void produce() {
    print('Producing Sedan car...');
    // 生产逻辑...
  }
}

// 汔车实现类：SUV
class SUV implements Car {
  @override
  void produce() {
    print('Producing SUV car...');
    // 生产逻辑...
  }
}

// 汔车实现类：跑车
class SportsCar implements Car {
  @override
  void produce() {
    print('Producing Sports Car...');
    // 生产逻辑...
  }
}

// 汔车工厂
class CarFactory {
  static Car createCar(String type) {
    if (type == 'Sedan') {
      return Sedan();
    } else if (type == 'SUV') {
      return SUV();
    } else if (type == 'SportsCar') {
      return SportsCar();
    }
    return null;
  }
}

// 生产线
Stream<Car> productionLine() async* {
  while (true) {
    yield CarFactory.createCar('Sedan');
    await Future.delayed(Duration(seconds: 2));
    yield CarFactory.createCar('SUV');
    await Future.delayed(Duration(seconds: 1));
    yield CarFactory.createCar('SportsCar');
    await Future.delayed(Duration(seconds: 3));
  }
}

// 消费者
void consumeCars(Stream<Car> carStream) {
  carStream.listen((car) {
    car.produce();
  });
}

void main() {
  final carStream = productionLine();
  consumeCars(carStream);
}

在上述示例中，我们首先定义了Car接口，然后实现了三种汔车类型：轿车（Sedan）、SUV（SUV）和跑车（SportsCar）。每个汔车类型都实现了produce方法来表示其生产逻辑。

接下来，我们创建了一个CarFactory工厂类，其中的createCar方法根据传入的汔车类型返回相应的汔车实例。

在productionLine函数中，我们使用async*和yield来创建

多个生产线的汔车流。每个生产线会按照一定的时间间隔生产不同类型的汔车，并使用yield将其加入流中。

最后，我们定义了consumeCars函数作为消费者，它接收一个汔车流，并通过监听流中的汔车数据来消费汔车。在示例中，我们简单地调用produce方法来模拟消费的操作。

在main函数中，我们创建了一个生产线的汔车流，并将其传递给consumeCars函数来消费汔车。

执行上述代码，会打印出类似以下的结果：

Producing Sedan car...
Producing Sedan car...
Producing SUV car...
Producing Sedan car...
Producing Sports Car...
Producing SUV car...
Producing Sedan car...
Producing SUV car...
Producing Sports Car...
Producing Sedan car...
Producing SUV car...
Producing Sedan car...
Producing Sports Car...
Producing SUV car...
Producing Sedan car...
Producing SUV car...
Producing Sports Car...
...

每个生产线按照一定的时间间隔生产不同类型的汔车，并且多条生产线看起来是无序的。消费者通过监听汔车流，打印出每个汔车的生产信息。

通过以上实现，我们满足了需求：建立了多条生产线的汔车生产工厂，并使用工厂设计模式来创建不同类型的汔车。使用yield、async和await来处理异步操作，以及创建了消费者来消费生产出来的汔车。

我们在本文介绍了在Flutter开发中利用工厂模式和yield/future/async/await这些强大特性实现数据流处理的模块化与复用。我们首先提到了工厂模式的熟悉程度，然后深入探讨了在Flutter开发中如何应用工厂模式以及yield、future、async和await等关键字。

接下来简要解释了yield关键字在生成器函数中的使用，展示了如何通过生成器函数产生序列化的值。接着，详细介绍了future、async和await的常见用法，包括发起网络请求、组合异步任务、并行执行任务和异常处理等。

最后，我们举了一个例子，描述了一个汔车生产工厂的需求，其中工厂有多条生产线负责生产不同类型的汔车，而yield、async和await则用于处理异步操作。最后，我们提到了需要一个消费者来消费生产出来的汔车。

希望本文能够帮助大家更好地理解和应用工厂模式和yield/future/async/await，以实现数据流处理的模块化与复用。通过合理利用这些特性，我们可以构建高效、可维护的Flutter应用程序，并提供出色的用户体验。让我们在Flutter开发实战中深入探索，并掌握这些强大的技术！

希望对您有所帮助谢谢!!！

转载自:https://juejin.cn/post/7252521365239857213
评论
请登录