跳到正文
CH 08工程化Dart9 分钟阅读

Dart 进阶:mixin、extension、pub 包管理、isolate 并发

第 8 章 · Dart 进阶:mixin、extension、pub 包管理、isolate 并发

本章示例examples/ch08-advanced在线阅读源码下载 zip

run

$cd examples/ch08-advanced && dart pub get && dart run

已验证

  • dart analyze 0 告警、dart test 21 个用例全绿
  • 完整工程已打包:打包下载
本章目录 · 21 节

8.1 本章目标

  • 用 mixin 横向复用实现,理解"线性化"——多个 mixin 同名方法时谁赢;
  • 用 extension 给别人的类型加方法,并知道它是静态分派的;
  • 会管理 pubspec.yaml:语义化版本、pubspec.lock、dart pub add/outdated/deps;
  • 真正理解 isolate:为什么 Dart 需要它、它和 goroutine 差在哪、什么时候该把计算丢进去。

本章是纯 Dart,但每一节都指向 Flutter:SingleTickerProviderStateMixin(ch07)、ChangeNotifier(ch11)、compute()、以及 Pub 上那几十万个包,全在这里。

8.2 mixin:横向复用实现

Dart 只有单继承,mixin 用来在多个不相关的类之间复用实现(不是接口)。

dartlib/mixins.dart源文件
// examples/ch08-advanced/lib/mixins.dart
abstract class Entity {
  String get id;
}

mixin Loggable {
  final List<String> _log = <String>[];
  void log(String message) => _log.add('[$runtimeType] $message');
  List<String> get logs => List<String>.unmodifiable(_log);
}

/// `on Entity, Loggable`:宿主必须已经是 Entity 并混入了 Loggable,
/// 所以这里可以直接调用 `id` 和 `log()`。
mixin Persistable on Entity, Loggable {
  bool _saved = false;
  bool get isSaved => _saved;
  void save() {
    _saved = true;
    log('saved $id');
  }
}

class User extends Entity with Loggable, Persistable {
  User(this.id, this.name);
  @override
  final String id;
  final String name;
}
项 Go Dart
复用实现 结构体嵌入(embedding) with Mixin
横向组合 多个嵌入字段 多个 mixin
约束宿主 无(嵌入啥都行) on SomeType
方法冲突 外层覆盖内层 线性化:后写的赢
抽象基类 接口 + 嵌入 abstract class + mixin

线性化:with A, B 谁赢

dart
mixin GreetA { String greet() => 'A'; }
mixin GreetB { String greet() => 'B'; }

class RightWins with GreetA, GreetB {}   // greet() == 'B'
class LeftWins with GreetB, GreetA {}    // greet() => 'A'

方法解析顺序从右向左(最后混入的最先被找到),和 Python 的 MRO、Scala 的 trait 线性化同一套思路。C++ 的多重继承在这里换成了"一条链"。

super 可以调用链上的下一个实现,写成中间件风格:

dart
abstract class Greeter {
  String greet() => 'base';
}

mixin Brackets on Greeter {
  @override
  String greet() => '[${super.greet()}]';
}

class Decorated extends Greeter with Brackets {}   // '[base]'

编译期踩坑:最初写的是 class Decorated extends GreetA with WrapBrackets,编译报 The superclass, 'GreetA', has no unnamed constructor ——因为 GreetA 是 mixin,不是类。 mixin 只能混入类,不能当父类;on 的宿主也必须是类。

同理,Persistable 声明 on Entity 后,宿主必须 extends Entity;写成 implements Entity 会失败,因为 implements 只承诺"有这些方法",不改变父类链。

mixin class(Dart 3)

dart
mixin class Timestamped {
  final DateTime createdAt = DateTime.now();
  String get createdAtText => '...';
}

class Note with Timestamped { ... }
final t = Timestamped();   // 也能直接实例化

mixin class = 既能当普通类用,也能被混入。Flutter 里的 ChangeNotifier 就是这种角色:你既 extends ChangeNotifier,也可以混入。

Flutter 里的三个高频 mixin

mixin 用途 出自
SingleTickerProviderStateMixin 给一个 AnimationController 提供 vsync(ch07) Flutter
TickerProviderStateMixin 给多个 controller 提供 vsync Flutter
AutomaticKeepAliveClientMixin 让列表项滚出屏幕后不被销毁 Flutter
ChangeNotifier(mixin class) 提供 notifyListeners()(ch11) Flutter

8.3 extension:给别人的类型加方法

Go 里你只能写自由函数 stringsXxx(s);Dart 里可以给 String 加"方法":

dartlib/extensions.dart源文件
// examples/ch08-advanced/lib/extensions.dart
extension StringX on String {
  String get capitalized =>
      isEmpty ? this : '${substring(0, 1).toUpperCase()}${substring(1)}';
  String get reversed => split('').reversed.join();
}

extension NullableStringX on String? {
  bool get isNullOrBlank => this == null || this!.trim().isEmpty;
  String orElse(String fallback) => isNullOrBlank ? fallback : this!;
}

extension IntMoneyX on int {
  String get asCny => '¥${(this / 100).toStringAsFixed(2)}';
}

extension IterableChunkX<T> on Iterable<T> {
  Iterable<List<T>> chunked(int size) sync* { /* ... */ }
}

用法:'hello'.capitalized、2050.asCny、xs.chunked(3)。

三条硬规则

  1. 扩展是静态分派:编译器按变量的静态类型挑选扩展,不看运行时类型。

    dart
    const String nullable = 'hello';   // 静态类型 String → StringX
    const String? maybeNull = 'hello'; // 静态类型 String? → NullableStringX
    

    拿到 dynamic 或 Object 时,扩展不会生效(编译期就找不到方法)。

  2. 扩展不能加字段:只能加 getter/方法/运算符。想加状态就必须用 mixin 或包装类。

  3. 冲突时显式调用:两个扩展都定义了 foo,编译器报"ambiguous";用 StringX(s).foo 指定。

扩展 vs 包装类 vs 自由函数

方案 优点 缺点
extension 调用点最自然、零成本、能作用于 null 静态分派、不能加字段、需要 import 可见
包装类 有状态、可多态 要多写一层、转换麻烦
顶层函数 最简单、无歧义 调用点 foo(s) 不如 s.foo 顺

Flutter SDK 自己大量使用扩展:Theme.of(context).textTheme 是方法,而 context.mounted、MediaQuery.sizeOf(context) 之类也都受益于同一思路。

8.4 pub 包管理

pubspec.yaml

yaml
name: ch08_advanced
environment:
  sdk: ^3.13.0          # >=3.13.0 <4.0.0
dependencies:
  collection: ^1.19.0    # >=1.19.0 <2.0.0
dev_dependencies:
  test: ^1.25.0
项 含义 Go 对比
^1.19.0 兼容范围(caret) Go 模块的 major 版本规则
1.19.0 精确锁定 go.mod 里的精确版本
>=1.0.0 <2.0.0 显式范围 —
path: ../foo 本地路径依赖 replace 指令
git: url/ref Git 依赖 replace + go get
pubspec.lock 锁定全部传递依赖 go.sum / go.mod 的 indirect

日常命令

bash
dart pub get            # 安装并生成 pubspec.lock
dart pub add collection # 加依赖并自动选版本
dart pub outdated       # 哪些有新版本
dart pub deps --style=compact   # 依赖树
dart pub upgrade        # 在允许范围内升级
dart pub get --offline  # 只用本地缓存(CI 无网时有用)

pubspec.lock 要提交到版本库(应用/示例项目)。库包(要被别人依赖的)通常不提交,让下游自行解析。

用真实包:collection

dartlib/pub_packages.dart源文件
// examples/ch08-advanced/lib/pub_packages.dart
import 'package:collection/collection.dart';

int? findFirstEven(List<int> xs) => xs.firstWhereOrNull((int x) => x.isEven);

Map<bool, List<int>> splitBySign(List<int> xs) => groupBy<int, bool>(xs, (int x) => x >= 0);

List<String> namesSorted(List<String> names) => names.sorted();

bool sameNumbers(List<int> a, List<int> b) => const ListEquality<int>().equals(a, b);

这四个函数解决了 Dart 标准库的四个常见缺口:

需求 原生写法 collection
找不到返回 null firstWhere 会抛 StateError firstWhereOrNull
分组 手写 ??= 循环 groupBy
排序返回新列表 [...xs]..sort() sorted()
List 结构相等 没有(== 是引用相等) ListEquality / DeepCollectionEquality

最后一条特别重要:ch03 说 Dart 的 List == 是引用相等,const ListEquality<int>().equals(a, b) 就是官方答案。

选包原则(本项目 AGENTS.md 也这么要求):优先官方/高维护度、支持桌面三平台 + Android/iOS 的包。带原生插件的包必须确认各平台都有实现,否则 flutter run 到某个平台会直接编译失败。

8.5 isolate:Dart 唯一的真并行

内存模型:不共享,只发消息

text
主 isolate                          worker isolate
┌──────────────────┐   SendPort    ┌──────────────────┐
│ 自己的堆          │ ───────────▶  │ 自己的堆          │
│ 自己的事件循环     │   (复制/转移)  │ 自己的事件循环     │
└──────────────────┘               └──────────────────┘
  • 每个 isolate 是独立的 堆 + 事件循环;
  • 不共享任何可变状态 → 不需要锁,也不会有数据竞争;
  • 通信只有 SendPort/ReceivePort,消息会被复制(TransferableTypedData 是零拷贝转移)。

对照 Go:

项 Go Dart
并发单位 goroutine(共享地址空间) isolate(独立堆)
并行 默认多核(GOMAXPROCS) 只有 isolate 才并行
同步 channel / mutex / atomic 消息传递,无共享
启动成本 ~2KB 栈,极轻 较重(独立堆 + 事件循环,毫秒级)
数据传递 引用/指针 复制(或转移)

Isolate.run:一次性的并行计算

dart
/// examples/ch08-advanced/lib/isolates.dart
Future<int> sumInIsolate(int n) => Isolate.run<int>(() => burnCpu(n));

Future<List<int>> sumParallel(List<int> inputs) =>
    Future.wait(inputs.map((int n) => Isolate.run<int>(() => burnCpu(n))));

实测(dart run,4 个任务,每个约 31M 次循环):

text
串行结果 [...] → 75ms
并行结果 [...] → 25ms
结果一致: true

4 个任务、3 倍加速(spawn 开销 + 机器核数决定的,不会线性到 4 倍)。这就是"await 不能让 CPU 密集代码变快,Isolate.run 才行"的量化证据。

Flutter 里的 compute(fn, arg) 就是 Isolate.run 的封装,用法完全一样。

传过去的是副本

dart
final original = <int>[1, 2, 3];
final mutated = await mutateInIsolate(original);
// mutated == [1, 2, 3, 999]
// original == [1, 2, 3]   ← 没有共享内存,isolate 里改的是副本

想"共享"大块数据,用 TransferableTypedData(转移所有权,不复制)或者把结果序列化回来。不要指望在 isolate 之间共享可变对象——这是设计上的不可能。

手动 spawn:长驻 worker + 消息协议

Isolate.run 适合"一次性任务"。要复用 worker(避免反复 spawn 的开销),就手动管理:

dart
Future<List<int>> runWorker(List<int> tasks) async {
  final responses = ReceivePort();
  final results = <int>[];
  final completer = Completer<List<int>>();

  responses.listen((Object? message) {
    if (message is int) results.add(message);
    else if (message == workerDone) {
      responses.close();
      completer.complete(results);
    }
  });

  await Isolate.spawn(_workerEntry, (responses.sendPort, tasks));
  return completer.future;
}

void _workerEntry((SendPort, List<int>) args) {
  final (SendPort send, List<int> tasks) = args;
  for (final task in tasks) {
    send.send(burnCpu(task));
  }
  send.send(workerDone);
}

实测 runWorker([100, 200, 300]) → [338350, 2686700, 9045050]。

要点:

  1. 入口函数必须是顶层/静态函数(不能是闭包捕获了不可发送对象的实例方法);
  2. 消息协议要自己设计(这里用字符串 'done' 当结束标记);
  3. 收完要 responses.close(),否则 ReceivePort 泄漏;
  4. worker 内部抛异常会让 isolate 死掉,主 isolate 收不到"错误事件"除非你显式 send 出去;Isolate.run 则会把它变成失败 Future:
dart
await failingIsolate();   // StateError: isolate 内部爆炸

什么时候该开 isolate

dart
bool shouldOffload(Duration budget) => budget > const Duration(milliseconds: 16);

经验法则:纯 Dart 计算超过一帧(16ms)就该挪走。典型场景:图片解码、大 JSON 解析、加解密、压缩、搜索/排序大列表、复杂布局计算。

不该用的场景:轻量计算(spawn 比计算还贵)、频繁小任务(用 worker 复用)、需要共享状态的逻辑(改成消息协议)。

顺带解释了一个细节:Isolate.run 里 Isolate.current.debugName 打出来是 _RemoteRunner._remoteExecute——证明你确实在另一个 isolate 里跑,而不是同一个事件循环。

8.6 运行与验证

bash
cd examples/ch08-advanced
dart pub get && dart analyze && dart test && dart run

真实输出(节选):

text
logs: [[User] created, [User] saved u-1]
线性化:RightWins.greet()=B, LeftWins.greet()=A
super 链:Decorated.greet()=[base]
chunked(3) = [[1, 2, 3], [4, 5, 6], [7]]
按符号分组: {false: [-2], true: [0, 3, 4]}
结构相等 [1,2]==[1,2]: true

串行结果 [...] → 75ms
并行结果 [...] → 25ms
结果一致: true
isolate 内改后: [1, 2, 3, 999], 原列表: [1, 2, 3](不共享内存)
当前 isolate 名字: _RemoteRunner._remoteExecute
isolate 内的异常传回来了: isolate 内部爆炸

附:C/Go 代码对照:嵌入 vs mixin

go
// Go:结构体嵌入把方法"提升"到外层类型
type Logger struct{}

func (Logger) Log(msg string) { fmt.Println(msg) }

type Repo struct {
    Logger                 // 嵌入:Repo 自动拥有 Log 方法
    ds   *sql.DB
}

r := Repo{}
r.Log("connected")         // 提升后的方法
dart
// Dart:mixin 把实现注入类,且可以叠加多个、线性化解决冲突
mixin Loggable {
  void log(String msg) => print('[$runtimeType] $msg');
}

class Repo with Loggable {
  Repo(this._db);
  final Object _db;
}

Repo(Object()).log('connected');

两者都是"横向复用实现",区别在于:Go 的嵌入是组合 + 方法提升(Repo 里有 Logger 字段),Dart 的 mixin 是把代码复制进类(Repo 没有 Logger 字段,Repo is Loggable 为真)。

8.7 本章小结 + C/Go 对照清单

主题 C Go Dart 陷阱
横向复用 宏 / 手写 vtable 结构体嵌入 mixin 线性化顺序、on 约束
给外部类型加方法 自由函数 自由函数 extension 静态分派、不能加字段
依赖管理 make/pkg-config go.mod pubspec.yaml + lock lock 要提交(应用)
版本范围 — major 版本语义 ^x.y.z ^0.x.y 表示 <0.(x+1).0
并行 pthread goroutine Isolate.run / spawn 无共享内存、消息复制
线程安全 mutex mutex/atomic 不需要 但也就没有共享便利
跨并发通信 共享内存 / 管道 channel SendPort / ReceivePort 协议要自己设计

给 C/Go 老兵的三句话:

  1. mixin 是"实现复用",extension 是"语法糖",两者都不是多态——Dart 的多态只有接口(虚表)。
  2. ^1.19.0 比 Go 的 module 语义更严格,pubspec.lock 保证可重现构建,要提交。
  3. isolate 才是并行;Future/Stream 只是在单线程里交错。没有共享内存,所以也没有锁。

下一章回到 Flutter:路由与导航、资源(assets)与主题。你会用到本章的 extension(主题扩展)和 mixin(路由观察器),也会第一次看到"桌面端和移动端路由行为差异"。