分类： Flutter

2019 Google I/O 大会，Flutter 团队在“Pragmatic State Management in Flutter ”演讲上正式介绍了 Provider。自此，Provider 代替 Provide 成为官方推荐的状态管理方式之一。

一、为什么需要状态管理

如果我们的应用足够简单，Flutter 作为一个声明式框架，你或许只需要将数据映射成视图就可以了。你可能并不需要状态管理，就像下面这样。

但是随着功能的增加，你的应用程序将会有几十个甚至上百个状态。这个时候你的应用可能会是这样。

随着你的应用需要共享多处统一状态时，我们很难再清楚的测试维护我们的状态，因为它看上去实在是太复杂了！而且还会有多个页面共享同一个状态，例如当你进入一个文章点赞，退出到外部缩略展示的时候，外部也需要显示点赞数，这时候就需要同步这两个状态。

Flutter 实际上在一开始就为我们提供了一种状态管理方式 — StatefulWidget。然而我们发现它仅适合用于在单个 Widget 内部维护其状态。当我们需要使用跨组件的状态时，StatefulWidget 将不再是一个好的选择。

State 属于某一个特定的 StatefulWidget，在多个 Widget 之间进行交流的时候，虽然你可以使用 callback 解决，但是当嵌套足够深的话，很容易就增大代码耦合度。

这时候，我们便迫切的需要一个架构来帮助我们理清这些关系，状态管理框架应运而生。

二、什么是 Provider

那么我们该如何解决上面这种糟糕的情况呢。在上手了 Provider 之后，我可以说这个库是一个相当不错的解决方案。我们先来简单说一下 Provider 的基本作用。

Provider 从名字上就很容易理解，它用来提供数据，而它的优秀之处在于无论是在单个页面还是在整个 app 都有相应的解决方案，我们可以很方便的管理状态，并在合适的时机释放资源。可以说，Provider 的目标就是完全替代 StatefulWidget。

说了很多还是很抽象，我们先一起做一个最简单的例子。

三、创建一个简单计数器 app

这里我们用这个 Counter App 为例，给大家介绍如何在两个独立的页面中共享计数器（counter）的状态应该怎么做,具体会像下面这样。

• 两个页面中心字体共用了同一个字体大小。
• 第二个页面的按钮将会让数字增加（第一个页面的数字将会同步增加。）

3.1 第一步：添加依赖

在 pubspec.yaml 中添加 Provider 的依赖。

• 实际添加请参考：https://pub.flutter-io.cn/packages/provider/install
• 由于版本冲突添加失败请参考: https://juejin.cn/post/6844903667955400718

3.2 第二步：创建数据 Model

这里的 Model 实际上就是我们的状态，它不仅储存了我们的数据模型，而且还包含了更改数据的方法，并暴露出它想要暴露出的数据。

这个类意图很清晰，数据就是一个 int 类型的 _count，下划线代表私有。通过 get value 把 _count 值暴露出来。并提供 increment 方法用于更改数据。

这里使用了 mixin 混入了 ChangeNotifier，这个类能够帮助我们自动管理所有听众。

当调用 notifyListeners() 时，它会通知所有听众进行刷新。

3.3 第三步：创建顶层共享数据

我们在 main 方法中初始化全局数据：刚才编写的 CounterModel 以及 textSize。为了要在不同页面共享这个数据，我们就需要将其放入顶层节点（MaterialApp 之上）进行保存。

通过 Provider<T>.value 能够管理一个恒定的数据，并提供给子孙节点使用。我们只需要将数据在其 value 属性中声明即可。在这里我们将textSize 传入。

而 ChangeNotifierProvider<T>.value 不仅能够提供数据供子孙节点使用，还可以在数据改变的时候通知所有听众刷新。(通过之前我们说过的 notifyListeners)

此处的 <T> 泛型可省略。但是我建议大家还是进行声明，这会使你的应用更加健壮。

除上述几个属性之外 Provider<T>.value 还提供 UpdateShouldNotify Function，用于控制刷新时机。

typedef UpdateShouldNotify<T> = bool Function(T previous, T current);

我们可以在这里传入一个方法 (T previous, T current){...}，并获得前后两个 Model 的实例，然后通过比较两个 Model 以自定义刷新规则，这个方法将返回 bool 表示是听众否需要刷新。（默认为 previous != current 则刷新。）

为了让各位思维连贯，我还是在这里放上这个平淡无奇的 MyApp Widget 代码。

3.4 第四步：在子页面中获取状态

在这里我们有两个页面，FirstScreen 和 SecondScreen。我们先来看 FirstScreen 的代码。

3.4.1 Provider.of<T>(context)

获取顶层数据最简单的方法就是 Provider.of<T>(context);

这里的泛型 <T> 指定了获取 FirstScreen 向上寻找最近的储存了 T 的祖先节点的数据。我们通过这个方法获取了顶层的 CounterModel 及 textSize。并在 Text 组件中进行使用。

在 Provider.of(context) 中还有一个 bool 类型的 listen 参数，它代表了是否监听数据变化，默认为 true。

floatingActionButton 用来点击跳转到 SecondScreen 页面，和我们的主题无关，你可以忽略这部分代码。

3.4.2 Consumer

看到这里你可能会想，两个页面都是获取顶层状态，代码不都一样吗。别忙着跳到下一节，我们来看另外一种获取状态的方式，使用它能够改善应用程序性能。

这里我们要介绍的是第二种方式，使用 Consumer 获取祖先节点中的数据。

在这个页面中，我们有两处使用到了公共 Model。

• 应用中心的文字：使用 CounterModel 在 Text 中展示文字，以及通过 textSize 定义自身的大小。使用到了两个 Model 中的数据。
• 浮动按钮：使用 CounterModel 的 increment 方法触发计数器的值增加。使用到了一个 Model。

（1） Single Model Consumer

我们先看 floatingActionButton，使用了一个 Consumer 的情况。

Consumer 使用了 Builder 模式，收到更新通知就会通过 builder 重新构建。Consumer<T> 代表了它要获取哪一个祖先中的 Model。

Consumer 的 builder 实际上就是一个 Function，它接收三个参数(BuildContext context, T model, Widget child)。

• context： context 就是 build 方法传进来的 BuildContext。
• T：T也很简单，就是获取到的最近一个祖先节点中的数据模型。
• child：它用来构建那些与 Model 无关的部分，在多次运行 builder 中，child 不会进行重建。

然后它会返回一个通过这三个参数映射的 Widget 用于构建自身。

在这个浮动按钮的例子中，我们通过 Consumer 获取到了顶层的CounterModel 实例。并在浮动按钮 onPressed 的 callback 中调用其increment 方法。

而且我们成功抽离出 Consumer 中不变的部分，也就是浮动按钮中心的Icon 并将其作为 child 参数传入 builder 方法中。

（2）Consumer2

现在我们再来看中心的文字部分。这时候你可能会有疑惑了，刚才我们讲的 Consumer 获取的只有一个 Model，而现在 Text 组件不仅需要 CounterModel 用以显示计数器，而且还需要获得 textSize 以调整字体大小，该怎么做呢？

遇到这种情况你可以使用 Consumer2<A,B>。使用方式基本上和 Consumer<T> 一致，只不过泛型改为了两个，并且 builder 方法也变成了Function(BuildContext context, A value, B value2, Widget child)。

从源码里面可以看到，这样的帮助类最多的是 Consumer6。如果还有个更多的需求，可以直接按照源码定制你的 Consumer。（感觉并不是很优雅）

（3）Provider.of<T>(context) 与 Consumer 的区别

那么，二者到底有什么差别呢？我们来看 Consumer 的内部实现。

可以发现，Consumer 就是通过 Provider.of<T>(context) 来实现的。但是从实现来讲 Provider.of<T>(context) 比 Consumer 简单好用太多，为什么我要使用更加复杂的 Consumer？

实际上 Consumer 非常有用，它的经典之处在于能够在复杂项目中，极大地缩小你的控件刷新范围。Provider.of<T>(context) 将会把调用了该方法的 context 作为听众，并在 notifyListeners 的时候通知其刷新。

举个例子来说，我们的 FirstScreen 使用了 Provider.of<T>(context) 来获取数据，SecondScreen 则没有。

• 你在 FirstScreen 中的 build 方法中添加一个 print('first screen rebuild');
• 然后在 SecondScreen 中的 build 方法中添加一个 print('second screen rebuild');
• 点击第二个页面的浮动按钮，那么你会在控制台看到这句输出。

3.5 First screen rebuild

首先这证明了 Provider.of<T>(context) 会导致调用的 context 页面范围的刷新。

那么第二个页面刷新没有呢？ 刷新了，但是只刷新了 Consumer 的部分，甚至连浮动按钮中的 Icon 的不刷新我们都给控制了。你可以在Consumer 的 builder 方法中验证，这里不再啰嗦。

假如你在你的应用的 页面级别 的 Widget 中，使用了 Provider.of<T>(context)。会导致什么后果已经显而易见了，每当其状态改变的时候，你都会重新刷新整个页面。虽然你有 Flutter 的自动优化算法给你撑腰，但你肯定无法获得最好的性能。

所以在这里我建议各位尽量使用 Consumer 而不是 Provider.of<T>(context) 获取顶层数据。

以上便是一个最简单的使用 Provider 的例子。

四、你还需要知道的

4.1 合理选择使用 Provider 的构造方法

在上面这个例子中，我们选择了使用 Provider<T>.value 的构造方法来创建祖先节点中的提供者。除了这种方式，我们还可以使用默认构造方法。

常规的 key/child 属性我们不在这里展开讲解了。先来看这个看上去相对教复杂一点的 builder。

4.1.1 ValueBuilder

相比起 .value 构造方式中直接传入一个 value 就 ok，这里的 builder 要求我们传入一个 ValueBuilder。这是什么东西呢？

通过源码可以看到，ValueBuilder 其实很简单，就是传入一个 Function 返回一个数据而已。在上面这个例子中，你可以替换成这样。

由于是 Builder 模式，这里默认需要传入 context，实际上我们的 Model（textSize）与 context 并没有关系，所以你完全可以这样写。

4.1.2 Disposer

现在我们知道了 builder，那这个 dispose 方法又用来做什么的呢。实际上这才是 Provider 的点睛之笔。

dispose 属性需要一个 Disposer<T>,而这个其实也是一个回调。

如果你之前使用过 BLoC 的话，相信你肯定遇到过一个头疼的问题。我应该在什么时候释放资源呢？ BloC 使用了观察者模式，它旨在替代 StatefulWidget。然而大量的流使用完毕之后必须 close 掉，以释放资源。

然而 Stateless Widget 并没有给我们类似于 dispose 之类的方法，这便是 BLoC 的硬伤。你不得不为了释放资源而使用 StatefulWidget，这与我们的本意相违。而 Provider 则为我们解决了这一点。

当 Provider 所在节点被移除的时候，它就会启动 Disposer<T>，然后我们便可以在这里释放资源。

举个例子，假如我们有这样一个 BLoC。

这时候我们想要在某个页面提供这个 BLoC 但是又不想使用 StatefulWidget。这时候我们可以在页面顶层套上这个 Provider。

我们在 dispose 回调中关闭不再使用的流，这样就完美解决了数据释放的问题！

现在我们可以放心的结合 BLoC 一起使用了，很赞有没有。但是现在你可能又有疑问了，在使用 Provider 的时候，我应该选择哪种构造方法呢。

我的推荐是，简单模型就选择 Provider<T>.value，好处是可以精确控制刷新时机。而需要对资源进行释放处理等复杂模型的时候，Provider()默认构造方式绝对是你的最佳选择。

其他几种 Provider 也遵循该模式，需要的时候可以自行查看源码。

4.2 我该使用哪种 Provider

如果你在 Provider 中提供了可监听对象（Listenable 或者 Stream）及其子类的话，那么你会得到下面这个异常警告。

你可以将本文中所使用到的 CounterModel 放入 Provider 进行提供（记得 hot restart 而不是 hot reload），那么你就能看到上面这个 FlutterError 了。

你也可以在 main 方法中通过下面这行代码来禁用此提示。
Provider.debugCheckInvalidValueType = null;

这是由于 Provider 只能提供恒定的数据，不能通知依赖它的子部件刷新。提示也说的很清楚了，假如你想使用一个会发生 change 的 Provider，请使用下面的 Provider。

• ListenableProvider
• ChangeNotifierProvider
• ValueListenableProvider
• StreamProvider

4.2.1 ListenableProvider / ChangeNotifierProvider

你可能会在这里产生一个疑问，不是说（Listenable 或者 Stream）才不行吗，为什么我们的 CounterModel 混入的是 ChangeNotifier 但是还是出现了这个 FlutterError 呢。

我们再来看上面的这几个 Provider 有什么异同。先关注ListenableProvider / ChangeNotifierProvider 这两个类。

ListenableProvider 提供（provide）的对象是继承了 Listenable 抽象类的子类。由于无法混入，所以通过继承来获得 Listenable 的能力，同时必须实现其 addListener / removeListener 方法，手动管理收听者。显然，这样太过复杂，我们通常都不需要这样做。

而混入了 ChangeNotifier 的类自动帮我们实现了听众管理，所以 ListenableProvider 同样也可以接收混入了 ChangeNotifier 的类。

ChangeNotifierProvider 则更为简单，它能够对子节点提供一个 继承/混入/实现 了 ChangeNotifier 的类。通常我们只需要在 Model 中 with ChangeNotifier ，然后在需要刷新状态的时候调用 notifyListeners 即可。

那么 ChangeNotifierProvider 和 ListenableProvider 究竟区别在哪呢，ListenableProvider 不是也可以提供（provide）混入了 ChangeNotifier 的 Model 吗。

还是那个你需要思考的问题。你在这里的 Model 究竟是一个简单模型还是复杂模型。这是因为 ChangeNotifierProvider 会在你需要的时候，自动调用其 _disposer 方法。

我们可以在 Model 中重写 ChangeNotifier 的 dispose 方法，来释放其资源。这对于复杂 Model 的情况下十分有用。

4.2.2 ValueListenableProvider

现在你应该已经十分清楚 ListenableProvider / ChangeNotifierProvider 的区别了。下面我们来看 ValueListenableProvider。

ValueListenableProvider 用于提供实现了 继承/混入/实现 了 ValueListenable 的 Model。它实际上是专门用于处理只有一个单一变化数据的 ChangeNotifier。

通过 ValueListenable 处理的类不再需要数据更新的时候调用notifyListeners。

好了，终于只剩下最后一个StreamProvider 了。

4.2.3 StreamProvider

StreamProvider 专门用作提供（provide）一条 Single Stream。我在这里仅对其核心属性进行讲解。

• T initialData：你可以通过这个属性声明这条流的初始值。
• ErrorBuilder catchError：这个属性用来捕获流中的 error。在这条流 addError 了之后，你会能够通过 T Function(BuildContext context, Object error) 回调来处理这个异常数据。实际开发中它非常有用。
• updateShouldNotify：和之前的回调一样，这里不再赘述。

除了这三个构造方法都有的属性以外，StreamProvider 还有三种不同的构造方法。

• StreamProvider(…)：默认构造方法用作创建一个 Stream 并收听它。
• StreamProvider.controller(…)：通过 builder 方式创建一个StreamController。并且在 StreamProvider 被移除时，自动释放 StreamController。
• StreamProvider.value(…)：监听一个已有的 Stream 并将其 value 提供给子孙节点。

除了上面这五种已经提到过的 Provider，还有一种 FutureProvider，它提供了一个 Future 给其子孙节点，并在 Future 完成时，通知依赖的子孙节点进行刷新，这里不再详细介绍，需要的话自行查看 api 文档。

4.3 优雅地处理多个 Provider

在我们之前的例子中，我们使用了嵌套的方式来组合多个 Provider，但是这样看上去有些傻。这时候我们就可以使用一个非常 sweet 的组件 —— MultiProvider。

这时候我们刚才那个例子就可以改成这样。

可以看到我们的代码意图清晰很多，而且与刚才的嵌套做法完全等价。

4.4 单元测试

直接执行原来的测试用例，一般会报错如下：

修改后的测试用例如下：

五、Tips

5.1 保证 build 方法无副作用

Build 无副作用也通常被人叫做，build 保持 pure，二者是同一个意思。

通常我们经常会看到，为了获取顶层数据我们会在 build 方法中调用 XXX.of(context) 方法。你必须非常小心，你的 build 函数不应该产生任何副作用，包括新的对象（Widget 以外），请求网络，或作出一个映射视图以外的操作等。

这是因为，你的根本无法控制什么时候你的 build 函数将会被调用。（我可以说随时）每当你的 build 函数被调用，那么都会产生一个副作用。这将会发生非常恐怖的事情。

我这样说你肯定会感到比较抽象，我们来举一个例子。

假如你有一个 ArticleModel 这个 Model 的作用是 通过网络 获取一页 List 数据，并用 ListView 显示在页面上。

这时候，我们假设你在 build 函数中做了下面这些事情。

我们在 build 函数中获得了祖先节点中的 articleModel，随后调用了 getPage 方法来获取第一页的数据。

这时候会发生什么事情呢？当我们请求成功获得了结果的时候，根据之前我们已经介绍过的，调用了 Provider.of<T>(context); 之后数据更改会重新运行其 build。这样 getPage 就又被执行了一次。

而你的 Model 中每次请求 getPage 都会导致 Model 中保存的当前请求页自增（第一次请求第一页的数据，第二次请求第二页的数据以此类推），那么每次 build 都会导致新的一次数据请求，并在新的数据 get 的时候请求下一页的数据。你的服务器挂掉那是迟早的事情。

所以你应该严格遵守这项原则，否则会导致一系列糟糕的后果。

那么怎么解决数据初始化这个问题呢，请看 Q&A 部分。

5.2 不要所有状态都放在全局

第二个小贴士是不要把你的所有状态都放在顶层。开发者为了图方便省事，再接触了状态管理之后经常喜欢把所有东西都放在顶层 MaterialApp 之上。这样看上去就很方便共享数据了，我要数据就直接去获取。

不要这么做。严格区分你的全局数据与局部数据，资源不用了就要释放！否则将会一定程度上影响你的应用性能。

5.3 尽量在 Model 中使用私有变量“_”

这可能是我们每个人在新手阶段都会出现的疑问。为什么要用私有变量呢，我在任何地方都能够操作成员不是很方便吗。

一个应用需要大量开发人员参与，你写的代码也许在几个月之后被另外一个开发看到了，这时候假如你的变量没有被保护的话，也许同样是让 count++，他会用 countController.sink.add(++_count) 这种原始方法，而不是调用你已经封装好了的 increment 方法。

虽然两种方式的效果完全一样，但是第一种方式将会让我们的业务逻辑零散的混入其他代码中。久而久之项目中就会大量充斥着这些垃圾代码增加项目代码耦合程度，非常不利于代码的维护以及阅读。

所以，请务必使用私有变量保护你的 Model。

5.4 控制你的刷新范围

在 Flutter 中，组合大于继承的特性随处可见。常见的 Widget 实际上都是由更小的 Widget 组合而成，直到基本组件为止。为了使我们的应用拥有更高的性能，控制 Widget 的刷新范围便显得至关重要。

我们已经通过前面的介绍了解到了，在 Provider 中获取 Model 的方式会影响刷新范围。所有，请尽量使用 Consumer 来获取祖先 Model，以维持最小刷新范围。

在不需要时刻监听状态变化的类中可以通过 Provider<T>.of(context, listen: false); 取消监听, 也是提升刷新效率的方式之一。

六、Q&A

在这里对一些大家可能会有疑问的常见问题做一个回答，如果你还有这之外的疑问的话，欢迎在下方评论区一起讨论。

6.1 Provider 是如何做到状态共享的

这个问题实际上得分两步。

6.1.1 获取顶层数据

实际上在祖先节点中共享数据都是通过系统的 InheritedWidget 进行实现的。

Provider 也不例外，在所有 Provider 的 build 方法中，返回了一个 InheritedProvider。

Flutter 通过在每个 Element 上维护一个 InheritedWidget 哈希表来向下传递 Element 树中的信息。通常情况下，多个
Element 引用相同的哈希表，并且该表仅在 Element 引入新的InheritedWidget 时改变。

所以寻找祖先节点的时间复杂度为 O(1) !

6.1.2 通知刷新

通知刷新这一步实际上在讲各种 Provider 的时候已经讲过了，其实就是使用了 Listener 模式。Model 中维护了一堆听众，每次调用Provider.of(context)的时候会进行注册 ，然后 notifiedListener 通知所有听众刷新。

6.2 为什么全局状态需要放在顶层 MaterialApp 之上

这个问题需要结合 Navigator 以及 BuildContext 来回答。由于 Flutter 本质上是一个单页面应用程序，所以必须放在 Navigator 的 Element 之上才能够在全局共享数据。

6.3 我应该在哪里进行数据初始化

对于数据初始化这个问题，我简单将其分为全局数据初始化与单页面数据初始化两种情况。

6.3.1 全局数据

当我们需要获取全局顶层数据（就像之前 CounterApp 例子一样）并需要做一些会产生额外结果的时候，main 函数是一个很好的选择。

我们可以在 main 方法中创建 Model 并进行初始化的工作，这样就只会执行一次。

6.3.2 单页面

如果我们的数据只是在这个页面中需要使用，那么你有这两种方式可以选择。

（1）StatefulWidget

第一种是页面级别还是使用 StatefulWidget，然后在其 State 的 didChangeDependence 生命周期中，做这些会产生额外结果的动作的事。由于 State 是长声明周期对象，在其存在期间，didChangeDependence 只会在创建的时候执行一次。

（2）cascade

你也可以在使用 dart 的级连语法 ..do() 直接在页面的 StatelessWidget 成员变量声明时进行初始化。

使用这种方式需要注意，当这个 StatelessWidget 重新运行 build 的时候，状态会丢失。这种情况在 TabBarView 中的子页面切换过程中就可能会出现。

所以建议还是使用第一种，在 State 中初始化数据。

6.4 我需要担心性能问题吗

是的，你需要随时注意应用性能是否会因为一些不当操作而降低。虽然 Flutter 可以在不做大量优化的情况下媲美原生应用的体验。然而当我们不遵守其行为规范的时候，会出现这样的情况。性能会因为你的各种不当操作而变得很糟糕。

然而 Provider 仅仅是对 InheritedWidget 的一个升级，你不必担心引入 Provider 会对应用造成性能问题。但是在使用过程中我有下面三个建议，以避免进入性能陷阱：

• 控制 Widget 刷新范围；
• 保持 build 方法 pure；
• 必要时，通过重写 UpdateShouldNotify 进行性能优化。

6.5 为什么选择 Provider

Provider 不仅做到了提供数据，而且它拥有着一套完整的解决方案，覆盖了你会遇到的绝大多数情况。就连 BLoC 未解决的那个棘手的 dispose 问题，和 ScopedModel 的侵入性问题，它也都解决了。

然而它就是完美的吗，并不是，至少现在来说。Flutter Widget 构建模式很容易在 UI 层面上组件化，但是仅仅使用 Provider，Model 和 View 之间还是容易产生依赖。我们只有通过手动将 Model 转化为 ViewModel 这样才能消除掉依赖关系，所以假如各位有组件化的需求，还需要另外处理。

不过对于大多数情况来说，Provider 足以优秀，它能够让你开发出 简单、高性能、层次清晰、高可扩展性 的应用。

6.6 我应该如何选择状态管理

介绍了这么多状态管理，你可能会发现，一些状态管理之间职责并不冲突。例如 BLoC 可以结合 RxDart 库变得很强大，很好用。而 BLoC 也可以结合 Provider / ScopedModel 一起使用。那我应该选择哪种状态管理方式呢。

我的看法是，没有最好的，只有最合适的。根据你的业务来选择最合适的状态管理方式，面对不同复杂度的业务，往往会得出完全不同的结论。

我建议遵守以下几点：

1. 使用状态管理的目的是为了让编写代码变得更简单，任何会增加你的应用复杂度的状态管理，统统都不要用。

2. 选择自己能够 hold 住的，BLoC / Rxdart / Redux / Fish-Redux 这些状态管理方式都有一定上手难度，不要选自己无法理解的状态管理方式。

3. 在做最终决定之前，敲一敲 demo，真正感受各个状态管理方式给你带来的 好处/坏处 然后再做你的决定。

希望能够帮助到你。

七、源码浅析

7.1 Flutter 中的 Builder 模式

在 Provider 中，各种 Provider 的原始构造方法都有一个 builder 参数，这里一般就用 (_) => XXXModel() 就行了。感觉有点多此一举，为什么不能像 .value() 构造方法那样简洁呢。

实际上，Provider 为了帮我们管理 Model，使用到了 delegation pattern。

builder 声明的 ValueBuilder 最终被传入代理类 BuilderStateDelegate /SingleValueDelegate。 然后通过代理类才实现的 Model 声明周期管理。

这里就仅放 BuilderStateDelegate，其余的请自行查看源码。

7.2 如何实现 MultiProvider

MultiProvider 实际上就是通过每一个 provider 都实现了的 cloneWithChild 方法，用循环把自己一层一层包裹起来。

等价于：

以上，是本人在状态管理方面遇到的心得的总结，希望能够给各位提供参考。

参考链接

---

• 简单聊聊Android和Flutter的ViewModel实现方案
• 这种方式教你简单的在Flutter中分离View与Model的方法
• Flutter 状态管理(Provider)
• Flutter 状态管理指南之 Provider
• State management
• provider
• Flutter开发 Provider详解
• await tester.pumpWidget(MyApp()) throw Exception #57992
• Testing widget which are using provider #182
• Flutter Provider状态管理-Consume

目前大多数使用Flutter的应用都是采用add2app的方式，在APP中与Flutter相关的内容主要有FlutterEngine、APP产物、资源文件。我们可以在应用市场上寻找一个接入Flutter的应用做实验。(apk可在各大应用市场下载，ipa下载可以在mac上安装Apple Configurator 2进行)，apk和ipa中flutter相关产物目录如下：

iOS包文件为ipa，下载后将其后缀重命名为zip进行解压，解压后Payload下即可看到应用文件夹，其中FlutterEngine、APP产物、资源文件分别在如下位置：

Android包文件为apk，下载后将其后缀重命名为zip进行解压，其中FlutterEngine、APP产物、资源文件分别在如下位置：

FlutterEngine各个app都是使用官方或者在官方基础上进行修改，差别不多，我们暂不关心这部分的逆向。资源文件多是图片，字体等无需逆向即可查看的资源。我们主要关心的是使用Dart编写的业务逻辑或者某些框架代码，这部分代码在APP产物中。即：App.framework/App 或 armeabi/libapp.o这两个文件都是动态库，我们先简单看看里面包含什么？

可以看到无论是Android还是iOS，Dart App产物中都包含4个程序段。（来自https://github.com/flutter/flutter/wiki/Flutter-engine-operation-in-AOT-Mode）

• '_kDartVmSnapshotData'： 代表 isolate 之间共享的 Dart 堆 (heap) 的初始状态。有助于更快地启动 Dart isolate，但不包含任何 isolate 专属的信息。

• '_kDartVmSnapshotInstructions'：包含 VM 中所有 Dart isolate 之间共享的通用例程的 AOT 指令。这种快照的体积通常非常小，并且大多会包含程序桩 (stub)。

• '_kDartIsolateSnapshotData'：代表 Dart 堆的初始状态，并包含 isolate 专属的信息。

• '_kDartIsolateSnapshotInstructions'：包含由 Dart isolate 执行的 AOT 代码。

看了上面可能还是一脸懵o((⊙﹏⊙))o，为什么分四块，Data与Instructions，Vm与Isolate是什么？为什么使用Snapshot（快照）命名。关于这些问题，推荐一篇博客https://mrale.ph/dartvm/ 。Data与Instructions，Vm与Isolate这些概念两两组合，正好对应上面四个段。也就是VmData、VmInstructions、IsolateData、IsolateInstructions。

先说一下Data与Instructions。首先我们知道的是Flutter编译运行在app上分为JIT和AOT模式，线上只能使用AOT模式，也就是Flutter引入的DartVM包含了执行AOT产物的功能。为了与JIT模式兼容，DartVM采用了所谓快照的方式，即JIT运行时编译后的基本结构与AOT编译的基本结构相同。将类信息、全局变量、函数指令直接以序列化的方式存在磁盘中，称为Snapshot（快照）。

由于快照的序列化格式针对性的为读取速率做了设计，从快照读取也大大提高代码的加载速度（创建所需类信息、全局数据等，可以类比OC Runtime启动加载元类、类信息等）。最开始快照中是不包含机器代码的（即函数体内部的执行逻辑），后来随着AOT模式的开发这部分被加入到快照中了，这些后来者也就是前面说的Instructions。

这里要补充的是，Instructions指的是可执行汇编指令，在.o文件中必须放在text段里，标记为可执行（否则iOS无法加载并执行它）。类信息、全局变量这些内容可以放在data端作为普通数据被加载。（字节的优化50%包体积也是基于此，有兴趣可以看一下文章：https://juejin.im/post/6844904014170030087）。

接着说DartVmSnapshot 与DartIsolateSnapshot。这就涉及Data虚拟机是如何运行业务代码。虚拟是Data代码运行的载体，VM中运行的逻辑都跑在一个抽象的叫做Isolate（隔离）的实体中。你可以把Isolate当做OC里一个带有Runloop的Thread看待（至于他们之间的关系又是一个令人头疼的面试题，这里不展开了）。简要来说Isolate中维护了堆栈变量，函数调用栈帧，用于GC、JIT等辅助任务的子线程等， 而这里的堆栈变量就是要被序列化到磁盘上的东西，即IsolateSnapshot。此外像dart预置的全局对象，比如null,true,false等等等是由VMIsolate管理的，这些东西需序列化后即VmSnapshot。

到这里大致了解Flutter APP产物中的结构。那如何读取他们呢？我们可以从clustered_snapshot.cc中的FullSnapshotReader:: 函数看起,看他是如何反序列化的。

要看懂这部分也是十分费力，另一个大神的分析文章可能会为我们带来很多启示：https://blog.tst.sh/reverse-engineering-flutter-apps-part-1/

我们要看如何读取RawObject对象

每个对象均以包含以下标记的uint32_t开头：

原则上我们自己可以写一个读取的程序进行分析，但是网上有一个使用Python写好的读取程序(只支持读取ELF格式文件，也就是只支持Android包产物的分析)：https://github.com/hdw09/darter 基于这个读取工具提供的API我们可以写一个导出应用所有类定义的工具。

这个脚本最终会提取所有指定文件的源码，其中对友商app其中一个类的导出结果如下：

其中标注了类对象 与函数的索引，可以在控制台使用s.refs[xxxxx].x继续跟查。

参考链接

---

如何逆向Flutter应用（反编译）

关于 Dart mixin 的一些理解。理解 mixin 概念的关键在于理解中间类。

Mixins are a way of reusing code in multiple class hierarchies

先来看一个简单例子：

PilotedCraft 拥有 astronauts 字段和 describeCrew() 方法。

mixin 是什么？

维基百科中这样定义 mixin：

In object-oriented programming languages, a Mixin is a class that contains methods for use by other classes without having to be the parent class of those other classes.

即，mixin 是另外一个普通类，我们可以在不继承这个类的情况下从这个类”借用”方法和变量。

Support for the mixin keyword was introduced in Dart 2.1. Code in earlier releases usually used abstract class instead.

从这个角度来讲，mixin 不过是 abstract class。

Java tries to make up for this by using Interfaces, but that is not as useful or flexible as mixins.

从这个角度来讲，可以认为 mixin 是带实现的接口。

小节

• mixin 有点类似 abstract class
• mixin 有点类似 interface
• 不能继承 mixin
• 可以使用 mixin, abstract class, class 来作为 mixin

如何使用 mixin?

使用 mixin 的方法很简单：with 关键字后面跟上 mixin 的名字即可。

实现 mixin 的方法同样也很简单：创建一个继承自 Object 的类并且不要声明构造方法。如果想让 mixin 作为普通类使用，使用 class 关键字；如果不想让 mixin 作为普通类使用，使用 mixin 关键字代替 class。

on 的用法

The keyword on is used to restrict our mixin’s use to only classes which either extends or implements the class it is declared on. In order to use the on keyword, you must declare your mixin using the mixin keyword

则有如下错误提示：

Error: 'Object' doesn't implement 'B' so it can't be used with 'Y'.

on 关键字限制了 Y 的使用范围：Y 只能用于继承或实现了 B 的类。修复方式是让 Q 继承自 B：

mixin 解决了什么问题？

mixin 解决了多重继承中的 Deadly Diamond of Death(DDD) 问题。

多重继承问题简单描述。各个类的继承关系如下：

问题来了，当调用 Musician.perform() 时，到底会调用哪个 perform() 方法是模糊的。

来看 mixin 如何解决这个问题。见 Dart for Flutter : Mixins in Dart - Flutter Community - Medium

现在，当调用 Musician.perform() 时，到底会调用哪个 perform() 方法是确定的。在这里是调用 Singer.perform()。

mixin 有一套明确的机制来选择调用哪个方法。

假设 Musician 类使用多个 mixin (Dancer, Singer)。该类有个方法名为 perform()，Musician 类继承自 Performer 类。

• 首先，将 Performer 类置于栈顶
• 其次，后声明的 mixin 优先于先声明的 mixin。按顺序将 mixin 置于栈中，在这里分别是 Dancer, Singer
• 最后，将 Musician 类自己置于栈中。Musician 类中的 perform() 被优先调用

---

Dart 使用的是单重继承 (Java 也是单重继承，C++ 是多重继承)。多重继承更为强大，但会引起 Deadly Diamond of Death(DDD) 问题。

Java 使用接口(interface)来部分实现多重继承。多重继承的问题是需要在每个类中实现接口(interface)，所以并不是一个好的方案。(实际上 Java 已经通过默认方法修复了这个问题)

所以 Dart 中就有了 mixin。

理解 mixin

Mixins in Dart work by creating a new class that layers the implementation of the mixin on top of a superclass to create a new class — it is not “on the side” but “on top” of the superclass, so there is no ambiguity in how to resolve lookups.
Mixins is not a way to get multiple inheritance in the classical sense. Mixins is a way to abstract and reuse a family of operations and state. It is similar to the reuse you get from extending a class, but it is compatible with single-inheritance because it is linear.
StackOverflow

以上这段代码输出 BA。

从语义上讲以上这段代码等同于：

继承结构图是这样的：

Since each mixin application creates a new class, it also creates a new interface (because all Dart classes also define interfaces). As described, the new class extends the superclass and includes copies of the mixin class members, but it also implements the mixin class interface.
In most cases, there is no way to refer to that mixin-application class or its interface; the class for Super with Mixin is just an anonymous superclass of the class declared like class C extends Super with Mixin {}. If you name a mixin application like class CSuper = Super with Mixin {}, then you can refer to the mixin application class and its interface, and it will be a sub-type of both Super and Mixin.

理解 mixin 的关键在于它是线性的。

使用场景

• 在没有共同父类的各个类中共享代码时
• 在父类中实现某种方法无意义时

在 Dart 语言中，我们经常可以看到对 mixin 关键字的使用，根据字面理解，就是混合的意思。那么，mixin 如何使用，它的使用场景是什么呢。

继续阅读Dart Mixin介绍